[patch] Proposal for \rotate in psql

diff --git a/doc/src/sgml/ref/psql-ref.sgml b/doc/src/sgml/ref/psql-ref.sgml
index f5c9552..0ed2e3d 100644
--- a/doc/src/sgml/ref/psql-ref.sgml
+++ b/doc/src/sgml/ref/psql-ref.sgml
@@ -2445,6 +2445,96 @@ lo_import 152801
         </listitem>
       </varlistentry>
 
+      <varlistentry>
+        <term><literal>\rotate [ <replaceable class="parameter">colV</replaceable>  [-]<replaceable class="parameter">colH</replaceable>] </literal></term>
+        <listitem>
+        <para>
+        Execute the current query buffer (like <literal>\g</literal>) and shows the results
+        inside a crosstab grid.  The contents at
+        output column <replaceable class="parameter">colV</replaceable> are transformed into a
+        vertical header and the contents at
+        output column <replaceable class="parameter">colH</replaceable> into a
+        horizontal header. The results for the other output columns are projected inside the grid.
+
+        </para>
+        <para>
+        <replaceable class="parameter">colV</replaceable>
+        and <replaceable class="parameter">colH</replaceable> can indicate a
+        column position (starting at 1), or a column name. Normal case folding
+        and quoting rules apply on column names. By default,
+        <replaceable class="parameter">colV</replaceable> designates column 1
+        and <replaceable class="parameter">colH</replaceable> column 2.
+        A query having less than two output columns cannot be rotated, and
+        <replaceable class="parameter">colH</replaceable> must differ from
+        <replaceable class="parameter">colV</replaceable>.
+
+        </para>
+        <para>
+        The vertical header, displayed as the leftmost column in the output,
+        contains the set of all distinct values found in
+        column <replaceable class="parameter">colV</replaceable>, in the order
+        of their first appearance in the results.
+        </para>
+        <para>
+        The horizontal header, displayed as the first row in the output,
+        contains the set of all distinct non-null values found in
+        column <replaceable class="parameter">colH</replaceable>.  It is
+        sorted in ascending order of values, unless a minus (-) sign
+        precedes <replaceable class="parameter">colH</replaceable>, in which
+        case this order is reversed.
+        </para>
+
+        <para>
+        The query results being tuples of <literal>N</literal> columns
+        (including <replaceable class="parameter">colV</replaceable> and
+        <replaceable class="parameter">colH</replaceable>),
+        for each distinct value <literal>x</literal> of
+        <replaceable class="parameter">colH</replaceable>
+        and each distinct value <literal>y</literal> of
+        <replaceable class="parameter">colV</replaceable>,
+        a cell is output at the intersection <literal>(x,y)</literal> in the grid,
+        and its contents are determined by these rules:
+        <itemizedlist>
+        <listitem>
+        <para>
+         if there is no corresponding row in the results such that the value
+         for <replaceable class="parameter">colH</replaceable>
+         is <literal>x</literal> and the value
+         for <replaceable class="parameter">colV</replaceable>
+         is <literal>y</literal>, the cell is empty.
+        </para>
+        </listitem>
+
+        <listitem>
+        <para>
+         if there is exactly one row such that the value
+         for <replaceable class="parameter">colH</replaceable>
+         is <literal>x</literal> and the value
+         for <replaceable class="parameter">colV</replaceable>
+         is <literal>y</literal>, then the <literal>N-2</literal> other
+         columns are displayed in the cell, separated between each other by
+         a space character if needed.
+
+         If <literal>N=2</literal>, the letter <literal>X</literal> is displayed in the cell as
+         if a virtual third column contained that character.
+        </para>
+        </listitem>
+
+        <listitem>
+        <para>
+         if there are several corresponding rows, the behavior is identical to one row
+         except that the values coming from different rows are stacked
+         vertically, rows being separated by newline characters inside
+         the same cell.
+        </para>
+        </listitem>
+
+        </itemizedlist>
+        </para>
+
+        </listitem>
+      </varlistentry>
+
 
       <varlistentry>
         <term><literal>\s [ <replaceable class="parameter">filename</replaceable> ]</literal></term>
diff --git a/src/bin/psql/Makefile b/src/bin/psql/Makefile
index f1336d5..92f9f44 100644
--- a/src/bin/psql/Makefile
+++ b/src/bin/psql/Makefile
@@ -23,7 +23,7 @@ override CPPFLAGS := -I. -I$(srcdir) -I$(libpq_srcdir) -I$(top_srcdir)/src/bin/p
 OBJS=	command.o common.o help.o input.o stringutils.o mainloop.o copy.o \
 	startup.o prompt.o variables.o large_obj.o print.o describe.o \
 	tab-complete.o mbprint.o dumputils.o keywords.o kwlookup.o \
-	sql_help.o \
+	sql_help.o rotate.o \
 	$(WIN32RES)
 
 
diff --git a/src/bin/psql/command.c b/src/bin/psql/command.c
index 8156b76..3550d6c 100644
--- a/src/bin/psql/command.c
+++ b/src/bin/psql/command.c
@@ -46,6 +46,7 @@
 #include "mainloop.h"
 #include "print.h"
 #include "psqlscan.h"
+#include "rotate.h"
 #include "settings.h"
 #include "variables.h"
 
@@ -1083,6 +1084,34 @@ exec_command(const char *cmd,
 		free(pw2);
 	}
 
+	/* \rotate -- execute a query and show results rotated along axis */
+	else if (strcmp(cmd, "rotate") == 0)
+	{
+		char	*opt1,
+				*opt2;
+
+		opt1 = psql_scan_slash_option(scan_state,
+									  OT_NORMAL, NULL, false);
+		opt2 = psql_scan_slash_option(scan_state,
+									  OT_NORMAL, NULL, false);
+
+		if (opt1 && !opt2)
+		{
+			psql_error(_("\\%s: missing second argument\n"), cmd);
+			success = false;
+		}
+		else
+		{
+			pset.rotate_col_V = opt1 ? pg_strdup(opt1): NULL;
+			pset.rotate_col_H = opt2 ? pg_strdup(opt2): NULL;
+			pset.rotate_output = true;
+			status = PSQL_CMD_SEND;
+		}
+
+		free(opt1);
+		free(opt2);
+	}
+
 	/* \prompt -- prompt and set variable */
 	else if (strcmp(cmd, "prompt") == 0)
 	{
diff --git a/src/bin/psql/common.c b/src/bin/psql/common.c
index 0e266a3..032db38 100644
--- a/src/bin/psql/common.c
+++ b/src/bin/psql/common.c
@@ -23,6 +23,7 @@
 #include "command.h"
 #include "copy.h"
 #include "mbprint.h"
+#include "rotate.h"
 
 
 
@@ -1061,7 +1062,12 @@ SendQuery(const char *query)
 
 		/* but printing results isn't: */
 		if (OK && results)
-			OK = PrintQueryResults(results);
+		{
+			if (pset.rotate_output)
+				OK = PrintRotate(results, pset.rotate_col_V, pset.rotate_col_H);
+			else
+				OK = PrintQueryResults(results);
+		}
 	}
 	else
 	{
@@ -1177,6 +1183,17 @@ sendquery_cleanup:
 		pset.gset_prefix = NULL;
 	}
 
+	pset.rotate_output = false;
+	if (pset.rotate_col_V)
+	{
+		free(pset.rotate_col_V);
+		pset.rotate_col_V = NULL;
+	}
+	if (pset.rotate_col_H)
+	{
+		free(pset.rotate_col_H);
+		pset.rotate_col_H = NULL;
+	}
 	return OK;
 }
 
diff --git a/src/bin/psql/help.c b/src/bin/psql/help.c
index 5b63e76..3dde055 100644
--- a/src/bin/psql/help.c
+++ b/src/bin/psql/help.c
@@ -175,6 +175,7 @@ slashUsage(unsigned short int pager)
 	fprintf(output, _("  \\g [FILE] or ;         execute query (and send results to file or |pipe)\n"));
 	fprintf(output, _("  \\gset [PREFIX]         execute query and store results in psql variables\n"));
 	fprintf(output, _("  \\q                     quit psql\n"));
+	fprintf(output, _("  \\rotate [COLV COLH]    execute query and rotate results into crosstab view\n"));
 	fprintf(output, _("  \\watch [SEC]           execute query every SEC seconds\n"));
 	fprintf(output, "\n");
 
diff --git a/src/bin/psql/rotate.c b/src/bin/psql/rotate.c
new file mode 100644
index 0000000..7dcc3e9
--- /dev/null
+++ b/src/bin/psql/rotate.c
@@ -0,0 +1,566 @@
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright (c) 2000-2015, PostgreSQL Global Development Group
+ *
+ * src/bin/psql/rotate.c
+ */
+
+#include "common.h"
+#include "pqexpbuffer.h"
+#include "rotate.h"
+#include "settings.h"
+
+#include <string.h>
+
+static int
+headerCompare(const void *a, const void *b)
+{
+	return strcmp( ((struct pivot_field*)a)->name,
+				   ((struct pivot_field*)b)->name);
+}
+
+static void
+accumHeader(char* name, int* count, struct pivot_field **sorted_tab, int row_number)
+{
+	struct pivot_field *p;
+
+	/*
+	 * Search for name in sorted_tab. If it doesn't exist, insert it,
+	 * otherwise do nothing.
+	 */
+
+	if (*count >= 1)
+	{
+		p = (struct pivot_field*) bsearch(&name,
+										  *sorted_tab,
+										  *count,
+										  sizeof(struct pivot_field),
+										  headerCompare);
+	}
+	else
+		p=NULL;
+
+	if (!p)
+	{
+		*sorted_tab = pg_realloc(*sorted_tab, sizeof(struct pivot_field) * (1+*count));
+		(*sorted_tab)[*count].name = name;
+		(*sorted_tab)[*count].rank = *count;
+		(*count)++;
+
+		qsort(*sorted_tab,
+			  *count,
+			  sizeof(struct pivot_field),
+			  headerCompare);
+	}
+}
+
+/*
+ * Send a query to sort all column values cast to the Oid passed in a VALUES clause
+ */
+static bool
+sortColumns(Oid coltype, struct pivot_field *columns, int nb_cols, int direction)
+{
+	bool retval = false;
+	PGresult *res = NULL;
+	PQExpBufferData query;
+	int i;
+	Oid *param_types;
+	const char** param_values;
+	int* param_lengths;
+	int* param_formats;
+
+	if (nb_cols < 2)
+		return true;					/* nothing to sort */
+
+	param_types = (Oid*) pg_malloc(nb_cols*sizeof(Oid));
+	param_values = (const char**) pg_malloc(nb_cols*sizeof(char*));
+	param_lengths = (int*) pg_malloc(nb_cols*sizeof(int));
+	param_formats = (int*) pg_malloc(nb_cols*sizeof(int));
+
+	initPQExpBuffer(&query);
+
+	/*
+	 * The query returns the original position of each value in our list,
+	 * ordered by its new position. The value itself is not returned.
+	 */
+	appendPQExpBuffer(&query, "SELECT n FROM (VALUES");
+
+	for (i=1; i <= nb_cols; i++)
+	{
+		if (i < nb_cols)
+			appendPQExpBuffer(&query, "($%d,%d),", i, i);
+		else
+		{
+			appendPQExpBuffer(&query, "($%d,%d)) AS l(x,n) ORDER BY x", i, i);
+			if (direction < 0)
+				appendPQExpBuffer(&query, " DESC");
+		}
+
+		param_types[i-1] = coltype;
+		param_values[i-1] = columns[i-1].name;
+		param_lengths[i-1] = strlen(columns[i-1].name);
+		param_formats[i-1] = 0;
+	}
+
+	res = PQexecParams(pset.db,
+					   query.data,
+					   nb_cols,
+					   param_types,
+					   param_values,
+					   param_lengths,
+					   param_formats,
+					   0);
+
+	if (res)
+	{
+		ExecStatusType status = PQresultStatus(res);
+		if (status == PGRES_TUPLES_OK)
+		{
+			for (i=0; i < PQntuples(res); i++)
+			{
+				int old_pos = atoi(PQgetvalue(res, i, 0));
+
+				if (old_pos < 1 || old_pos > nb_cols || i >= nb_cols)
+				{
+					/*
+					 * A position outside of the range is normally impossible.
+					 * If this happens, we're facing a malfunctioning or hostile
+					 * server or middleware.
+					 */
+					psql_error(_("Unexpected value when sorting horizontal headers"));
+					goto cleanup;
+				}
+				else
+				{
+					columns[old_pos-1].rank = i;
+				}
+			}
+		}
+		else
+		{
+			psql_error(_("Query error when sorting horizontal headers: %s"),
+					   PQerrorMessage(pset.db));
+			goto cleanup;
+		}
+	}
+
+	retval = true;
+
+cleanup:
+	termPQExpBuffer(&query);
+	if (res)
+		PQclear(res);
+	pg_free(param_types);
+	pg_free(param_values);
+	pg_free(param_lengths);
+	pg_free(param_formats);
+	return retval;
+}
+
+static void
+printRotation(const PGresult *results,
+			  int num_columns,
+			  struct pivot_field *piv_columns,
+			  int field_for_columns,
+			  int num_rows,
+			  struct pivot_field *piv_rows,
+			  int field_for_rows)
+{
+	printQueryOpt popt = pset.popt;
+	printTableContent cont;
+	int	i, j, rn;
+	int* horiz_map;			 /* map indices from sorted horizontal headers to piv_columns */
+	char** allocated_cells; 	/*  Pointers for cell contents that are allocated
+								 *  in this function, when cells cannot simply point to
+								 *  PQgetvalue(results, ...) */
+
+	printTableInit(&cont, &popt.topt, popt.title, num_columns+1, num_rows);
+
+	/* Step 1: set target column names (horizontal header) */
+
+	/* The name of the first column is kept unchanged by the rotation */
+	printTableAddHeader(&cont, PQfname(results, 0), false, 'l');
+
+	/*
+	 * To iterate over piv_columns[] by piv_columns[].rank, create a reverse map
+	 *  associating each piv_columns[].rank to its index in piv_columns.
+	 *  This avoids an O(N^2) loop later
+	 */
+	horiz_map = (int*) pg_malloc(sizeof(int) * num_columns);
+	for (i = 0; i < num_columns; i++)
+	{
+		horiz_map[piv_columns[i].rank] = i;
+	}
+
+	for (i = 0; i < num_columns; i++)
+	{
+		printTableAddHeader(&cont, piv_columns[horiz_map[i]].name, false, 'l');
+	}
+	pg_free(horiz_map);
+
+	/* Step 2: set row names in the first output column (vertical header) */
+	for (i = 0; i < num_rows; i++)
+	{
+		int k = piv_rows[i].rank;
+		cont.cells[k*(num_columns+1)] = piv_rows[i].name;
+		/* Initialize all cells inside the grid to an empty value */
+		for (j = 0; j < num_columns; j++)
+			cont.cells[k*(num_columns+1)+j+1] = "";
+	}
+	cont.cellsadded = num_rows * (num_columns+1);
+
+	allocated_cells = (char**) pg_malloc0(num_rows * num_columns * sizeof(char*));
+
+	/* Step 3: set all the cells "inside the grid" */
+	for (rn = 0; rn < PQntuples(results); rn++)
+	{
+		char* row_name;
+		char* col_name;
+		int row_number;
+		int col_number;
+		struct pivot_field *p;
+
+		row_number = col_number = -1;
+		/* Find target row */
+		if (!PQgetisnull(results, rn, field_for_rows))
+		{
+			row_name = PQgetvalue(results, rn, field_for_rows);
+			p = (struct pivot_field*) bsearch(&row_name,
+											  piv_rows,
+											  num_rows,
+											  sizeof(struct pivot_field),
+											  headerCompare);
+			if (p)
+				row_number = p->rank;
+		}
+
+		/* Find target column */
+		if (!PQgetisnull(results, rn, field_for_columns))
+		{
+			col_name = PQgetvalue(results, rn, field_for_columns);
+			p = (struct pivot_field*) bsearch(&col_name,
+											  piv_columns,
+											  num_columns,
+											  sizeof(struct pivot_field),
+											  headerCompare);
+			if (p)
+				col_number = p->rank;
+		}
+
+		/* Place value into cell */
+		if (col_number>=0 && row_number>=0)
+		{
+			int idx = 1 + col_number + row_number*(num_columns+1);
+			int src_col = 0;			/* column number in source result */
+			int k = 0;
+
+			do {
+				char *content;
+
+				if (PQnfields(results) == 2)
+				{
+					/*
+					  special case: when the source has only 2 columns, use a
+					  X (cross/checkmark) for the cell content, and set
+					  src_col to a virtual additional column.
+					*/
+					content = "X";
+					src_col = 3;
+				}
+				else if (src_col == field_for_rows || src_col == field_for_columns)
+				{
+					/*
+					  The source values that produce headers are not processed
+					  in this loop, only the values that end up inside the grid.
+					*/
+					src_col++;
+					continue;
+				}
+				else
+				{
+					content = (!PQgetisnull(results, rn, src_col)) ?
+						PQgetvalue(results, rn, src_col) :
+						(popt.nullPrint ? popt.nullPrint : "");
+				}
+
+				if (cont.cells[idx] != NULL && cont.cells[idx][0] != '\0')
+				{
+					/*
+					 * Multiple values for the same (row,col) are projected
+					 * into the same cell. When this happens, separate the
+					 * previous content of the cell from the new value by a
+					 * newline.
+					 */
+					int content_size =
+						strlen(cont.cells[idx])
+						+ 2 			/* room for [CR],LF or space */
+						+ strlen(content)
+						+ 1;			/* '\0' */
+					char *new_content;
+
+					/*
+					 * idx2 is an index into allocated_cells. It differs from
+					 * idx (index into cont.cells), because vertical and
+					 * horizontal headers are included in `cont.cells` but
+					 * excluded from allocated_cells.
+					 */
+					int idx2 = (row_number * num_columns) + col_number;
+
+					if (allocated_cells[idx2] != NULL)
+					{
+						new_content = pg_realloc(allocated_cells[idx2], content_size);
+					}
+					else
+					{
+						/*
+						 * At this point, cont.cells[idx] still contains a
+						 * PQgetvalue() pointer.  Just after, it will contain
+						 * a new pointer maintained in allocated_cells[], and
+						 * freed at the end of this function.
+						 */
+						new_content = pg_malloc(content_size);
+						strcpy(new_content, cont.cells[idx]);
+					}
+					cont.cells[idx] = new_content;
+					allocated_cells[idx2] = new_content;
+
+					/*
+					 * Contents that are on adjacent columns in the source results get
+					 * separated by one space in the target.
+					 * Contents that are on different rows in the source get
+					 * separated by newlines in the target.
+					 */
+					if (k==0)
+						strcat(new_content, "\n");
+					else
+						strcat(new_content, " ");
+					strcat(new_content, content);
+				}
+				else
+				{
+					cont.cells[idx] = content;
+				}
+				k++;
+				src_col++;
+			} while (src_col < PQnfields(results));
+		}
+	}
+
+	printTable(&cont, pset.queryFout, pset.logfile);
+	printTableCleanup(&cont);
+
+
+	for (i=0; i < num_rows * num_columns; i++)
+	{
+		if (allocated_cells[i] != NULL)
+			pg_free(allocated_cells[i]);
+	}
+
+	pg_free(allocated_cells);
+}
+
+/*
+ * Compare a user-supplied argument against a field name obtained by PQfname(),
+ * which is already case-folded.
+ * If arg is not enclosed in double quotes, pg_strcasecmp applies, otherwise
+ * do a case-sensitive comparison with these rules:
+ * - double quotes enclosing 'arg' are filtered out
+ * - double quotes inside 'arg' are expected to be doubled 
+ */
+static int
+fieldnameCmp(const char* arg, const char* fieldname)
+{
+	const unsigned char* p = (const unsigned char*) arg;
+	const unsigned char* f = (const unsigned char*) fieldname;
+	unsigned char c;
+
+	if (*p++ != '"')
+		return pg_strcasecmp(arg, fieldname);
+
+	while ((c=*p++))
+	{
+		if (c=='"')
+		{
+			if (*p=='"')
+				p++;			/* skip second quote and continue */
+			else if (*p=='\0')
+			    return *p-*f;		/* p finishes before f or is identical */
+
+		}
+		if (*f=='\0')
+			return 1;			/* f finishes before p */
+		if (c!=*f)
+			return c-*f;
+		f++;
+	}
+	return (*f=='\0') ? 0 : 1;
+}
+
+
+/*
+ * arg can be a number or a column name, possibly quoted (like in an ORDER BY clause)
+ * Returns:
+ *  on success, the 0-based index of the column
+ *  or -1 if the column number or name cannot correspond to the PGresult,
+ *        or if it's ambiguous (arg corresponding to several columns)
+ */
+static int
+indexOfColumn(const char* arg, PGresult* res)
+{
+	int idx;
+
+	if (strspn(arg, "0123456789") == strlen(arg))
+	{
+		/* if arg contains only digits, it's a column number */
+		idx = atoi(arg) - 1;
+		if (idx < 0  || idx >= PQnfields(res))
+		{
+			psql_error(_("Invalid column number: %s\n"), arg);
+			return -1;
+		}
+	}
+	else
+	{
+		int i;
+		idx = -1;
+		for (i=0; i < PQnfields(res); i++)
+		{
+			if (fieldnameCmp(arg, PQfname(res, i)) == 0)
+			{
+				if (idx>=0)
+				{
+					/* if another idx was already found for the same name */
+					psql_error(_("Ambiguous column name: %s\n"), arg);
+					return -1;
+				}
+				idx = i;
+			}
+		}
+		if (idx == -1)
+		{
+			psql_error(_("Invalid column name: %s\n"), arg);
+			return -1;
+		}
+	}
+	return idx;
+}
+
+bool
+PrintRotate(PGresult* res,
+			const char* opt_field_for_rows,    /* COLV or null */
+			const char* opt_field_for_columns) /* [-]COLH or null */
+{
+	int		rn;
+	struct pivot_field	*piv_columns = NULL;
+	struct pivot_field	*piv_rows = NULL;
+	int		num_columns = 0;
+	int		num_rows = 0;
+	bool 	retval = false;
+	int		columns_sort_direction = 1; /* 1:ascending, -1:descending */
+
+	/* 0-based index of the field whose distinct values will become COLUMN headers */
+	int		field_for_columns;
+
+	/* 0-based index of the field whose distinct values will become ROW headers */
+	int		field_for_rows;
+
+	if (PQresultStatus(res) != PGRES_TUPLES_OK)
+		goto error_return;
+
+	if (PQnfields(res) < 2)
+	{
+		psql_error(_("A query to rotate must return at least two columns\n"));
+		goto error_return;
+	}
+
+	field_for_rows = (opt_field_for_rows != NULL)
+		? indexOfColumn(opt_field_for_rows, res)
+		: 0;
+
+	if (field_for_rows < 0)
+		goto error_return;
+
+	if (opt_field_for_columns == NULL)
+		field_for_columns = 1;
+	else
+	{
+		/*
+		 * descending sort is requested if the column reference is
+		 * preceded with a minus sign
+		 */
+		if (*opt_field_for_columns == '-')
+		{
+			columns_sort_direction = -1;
+			opt_field_for_columns++;
+		}
+		field_for_columns = indexOfColumn(opt_field_for_columns, res);
+		if (field_for_columns < 0)
+			goto error_return;
+	}
+
+
+	if (field_for_columns == field_for_rows)
+	{
+		psql_error(_("The same column cannot be used for both vertical and horizontal headers\n"));
+		goto error_return;
+	}
+
+	/*
+	 * First pass: accumulate row names and column names, each into their
+	 * array. Use client-side sort but only to build the set of DISTINCT
+	 * values. The final order displayed depends only on server-side
+	 * sorts.
+	 */
+	for (rn = 0; rn < PQntuples(res); rn++)
+	{
+		if (!PQgetisnull(res, rn, field_for_rows))
+		{
+			accumHeader(PQgetvalue(res, rn, field_for_rows),
+						&num_rows,
+						&piv_rows,
+						rn);
+		}
+
+		if (!PQgetisnull(res, rn, field_for_columns))
+		{
+			accumHeader(PQgetvalue(res, rn, field_for_columns),
+						&num_columns,
+						&piv_columns,
+						rn);
+			if (num_columns > 1600)
+			{
+				psql_error(_("Maximum number of columns (1600) exceeded\n"));
+				goto error_return;
+			}
+		}
+	}
+
+	/*
+	 * Second pass: sort the list of target columns on the server.
+	 */
+	if (!sortColumns(PQftype(res, field_for_columns),
+					 piv_columns,
+					 num_columns,
+					 columns_sort_direction))
+		goto error_return;
+
+	/*
+	 * Third pass: print the rotated results.
+	 */
+	printRotation(res,
+				  num_columns,
+				  piv_columns,
+				  field_for_columns,
+				  num_rows,
+				  piv_rows,
+				  field_for_rows);
+
+	retval = true;
+
+error_return:
+	pg_free(piv_columns);
+	pg_free(piv_rows);
+
+	return retval;
+}
diff --git a/src/bin/psql/rotate.h b/src/bin/psql/rotate.h
new file mode 100644
index 0000000..ba027b6
--- /dev/null
+++ b/src/bin/psql/rotate.h
@@ -0,0 +1,33 @@
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright (c) 2000-2015, PostgreSQL Global Development Group
+ *
+ * src/bin/psql/rotate.h
+ */
+
+#ifndef ROTATE_H
+#define ROTATE_H
+
+struct pivot_field
+{
+	/* Pointer obtained from PGgetvalue() for colV or colH */
+	char*	name;
+
+	/* Rank of the field in its list, starting at 0.
+	 * - For headers stacked vertically, rank=N means it's the
+	 *   Nth distinct field encountered when looping through rows
+	 *   in their initial order.
+	 * - For headers stacked horizontally, rank is obtained
+	 *   by server-side sorting in sortColumns()
+	 */
+	int		rank;
+};
+
+/* prototypes */
+extern bool
+PrintRotate(PGresult* res,
+			const char* opt_field_for_rows,
+			const char* opt_field_for_columns);
+
+#endif   /* ROTATE_H */
diff --git a/src/bin/psql/settings.h b/src/bin/psql/settings.h
index 1885bb1..2164928 100644
--- a/src/bin/psql/settings.h
+++ b/src/bin/psql/settings.h
@@ -90,6 +90,9 @@ typedef struct _psqlSettings
 
 	char	   *gfname;			/* one-shot file output argument for \g */
 	char	   *gset_prefix;	/* one-shot prefix argument for \gset */
+	bool		rotate_output;  /* one-shot request to print rotated results */
+	char		*rotate_col_V;  /* one-shot \rotate 1st argument */
+	char		*rotate_col_H;  /* one-shot \rotate 2nd argument */
 
 	bool		notty;			/* stdin or stdout is not a tty (as determined
 								 * on startup) */

diff --git a/doc/src/sgml/ref/psql-ref.sgml b/doc/src/sgml/ref/psql-ref.sgml
index f5c9552..0ed2e3d 100644
--- a/doc/src/sgml/ref/psql-ref.sgml
+++ b/doc/src/sgml/ref/psql-ref.sgml
@@ -2445,6 +2445,96 @@ lo_import 152801
         </listitem>
       </varlistentry>
 
+      <varlistentry>
+        <term><literal>\rotate [ <replaceable class="parameter">colV</replaceable>  [-]<replaceable class="parameter">colH</replaceable>] </literal></term>
+        <listitem>
+        <para>
+        Execute the current query buffer (like <literal>\g</literal>) and shows the results
+        inside a crosstab grid.  The contents at
+        output column <replaceable class="parameter">colV</replaceable> are transformed into a
+        vertical header and the contents at
+        output column <replaceable class="parameter">colH</replaceable> into a
+        horizontal header. The results for the other output columns are projected inside the grid.
+
+        </para>
+        <para>
+        <replaceable class="parameter">colV</replaceable>
+        and <replaceable class="parameter">colH</replaceable> can indicate a
+        column position (starting at 1), or a column name. Normal case folding
+        and quoting rules apply on column names. By default,
+        <replaceable class="parameter">colV</replaceable> designates column 1
+        and <replaceable class="parameter">colH</replaceable> column 2.
+        A query having less than two output columns cannot be rotated, and
+        <replaceable class="parameter">colH</replaceable> must differ from
+        <replaceable class="parameter">colV</replaceable>.
+
+        </para>
+        <para>
+        The vertical header, displayed as the leftmost column in the output,
+        contains the set of all distinct values found in
+        column <replaceable class="parameter">colV</replaceable>, in the order
+        of their first appearance in the results.
+        </para>
+        <para>
+        The horizontal header, displayed as the first row in the output,
+        contains the set of all distinct non-null values found in
+        column <replaceable class="parameter">colH</replaceable>.  It is
+        sorted in ascending order of values, unless a minus (-) sign
+        precedes <replaceable class="parameter">colH</replaceable>, in which
+        case this order is reversed.
+        </para>
+
+        <para>
+        The query results being tuples of <literal>N</literal> columns
+        (including <replaceable class="parameter">colV</replaceable> and
+        <replaceable class="parameter">colH</replaceable>),
+        for each distinct value <literal>x</literal> of
+        <replaceable class="parameter">colH</replaceable>
+        and each distinct value <literal>y</literal> of
+        <replaceable class="parameter">colV</replaceable>,
+        a cell is output at the intersection <literal>(x,y)</literal> in the grid,
+        and its contents are determined by these rules:
+        <itemizedlist>
+        <listitem>
+        <para>
+         if there is no corresponding row in the results such that the value
+         for <replaceable class="parameter">colH</replaceable>
+         is <literal>x</literal> and the value
+         for <replaceable class="parameter">colV</replaceable>
+         is <literal>y</literal>, the cell is empty.
+        </para>
+        </listitem>
+
+        <listitem>
+        <para>
+         if there is exactly one row such that the value
+         for <replaceable class="parameter">colH</replaceable>
+         is <literal>x</literal> and the value
+         for <replaceable class="parameter">colV</replaceable>
+         is <literal>y</literal>, then the <literal>N-2</literal> other
+         columns are displayed in the cell, separated between each other by
+         a space character if needed.
+
+         If <literal>N=2</literal>, the letter <literal>X</literal> is displayed in the cell as
+         if a virtual third column contained that character.
+        </para>
+        </listitem>
+
+        <listitem>
+        <para>
+         if there are several corresponding rows, the behavior is identical to one row
+         except that the values coming from different rows are stacked
+         vertically, rows being separated by newline characters inside
+         the same cell.
+        </para>
+        </listitem>
+
+        </itemizedlist>
+        </para>
+
+        </listitem>
+      </varlistentry>
+
 
       <varlistentry>
         <term><literal>\s [ <replaceable class="parameter">filename</replaceable> ]</literal></term>
diff --git a/src/bin/psql/Makefile b/src/bin/psql/Makefile
index f1336d5..92f9f44 100644
--- a/src/bin/psql/Makefile
+++ b/src/bin/psql/Makefile
@@ -23,7 +23,7 @@ override CPPFLAGS := -I. -I$(srcdir) -I$(libpq_srcdir) -I$(top_srcdir)/src/bin/p
 OBJS=	command.o common.o help.o input.o stringutils.o mainloop.o copy.o \
 	startup.o prompt.o variables.o large_obj.o print.o describe.o \
 	tab-complete.o mbprint.o dumputils.o keywords.o kwlookup.o \
-	sql_help.o \
+	sql_help.o rotate.o \
 	$(WIN32RES)
 
 
diff --git a/src/bin/psql/command.c b/src/bin/psql/command.c
index 8156b76..3550d6c 100644
--- a/src/bin/psql/command.c
+++ b/src/bin/psql/command.c
@@ -46,6 +46,7 @@
 #include "mainloop.h"
 #include "print.h"
 #include "psqlscan.h"
+#include "rotate.h"
 #include "settings.h"
 #include "variables.h"
 
@@ -1083,6 +1084,34 @@ exec_command(const char *cmd,
 		free(pw2);
 	}
 
+	/* \rotate -- execute a query and show results rotated along axis */
+	else if (strcmp(cmd, "rotate") == 0)
+	{
+		char	*opt1,
+				*opt2;
+
+		opt1 = psql_scan_slash_option(scan_state,
+									  OT_NORMAL, NULL, false);
+		opt2 = psql_scan_slash_option(scan_state,
+									  OT_NORMAL, NULL, false);
+
+		if (opt1 && !opt2)
+		{
+			psql_error(_("\\%s: missing second argument\n"), cmd);
+			success = false;
+		}
+		else
+		{
+			pset.rotate_col_V = opt1 ? pg_strdup(opt1): NULL;
+			pset.rotate_col_H = opt2 ? pg_strdup(opt2): NULL;
+			pset.rotate_output = true;
+			status = PSQL_CMD_SEND;
+		}
+
+		free(opt1);
+		free(opt2);
+	}
+
 	/* \prompt -- prompt and set variable */
 	else if (strcmp(cmd, "prompt") == 0)
 	{
diff --git a/src/bin/psql/common.c b/src/bin/psql/common.c
index 0e266a3..032db38 100644
--- a/src/bin/psql/common.c
+++ b/src/bin/psql/common.c
@@ -23,6 +23,7 @@
 #include "command.h"
 #include "copy.h"
 #include "mbprint.h"
+#include "rotate.h"
 
 
 
@@ -1061,7 +1062,12 @@ SendQuery(const char *query)
 
 		/* but printing results isn't: */
 		if (OK && results)
-			OK = PrintQueryResults(results);
+		{
+			if (pset.rotate_output)
+				OK = PrintRotate(results, pset.rotate_col_V, pset.rotate_col_H);
+			else
+				OK = PrintQueryResults(results);
+		}
 	}
 	else
 	{
@@ -1177,6 +1183,17 @@ sendquery_cleanup:
 		pset.gset_prefix = NULL;
 	}
 
+	pset.rotate_output = false;
+	if (pset.rotate_col_V)
+	{
+		free(pset.rotate_col_V);
+		pset.rotate_col_V = NULL;
+	}
+	if (pset.rotate_col_H)
+	{
+		free(pset.rotate_col_H);
+		pset.rotate_col_H = NULL;
+	}
 	return OK;
 }
 
diff --git a/src/bin/psql/help.c b/src/bin/psql/help.c
index 5b63e76..3dde055 100644
--- a/src/bin/psql/help.c
+++ b/src/bin/psql/help.c
@@ -175,6 +175,7 @@ slashUsage(unsigned short int pager)
 	fprintf(output, _("  \\g [FILE] or ;         execute query (and send results to file or |pipe)\n"));
 	fprintf(output, _("  \\gset [PREFIX]         execute query and store results in psql variables\n"));
 	fprintf(output, _("  \\q                     quit psql\n"));
+	fprintf(output, _("  \\rotate [COLV COLH]    execute query and rotate results into crosstab view\n"));
 	fprintf(output, _("  \\watch [SEC]           execute query every SEC seconds\n"));
 	fprintf(output, "\n");
 
diff --git a/src/bin/psql/print.c b/src/bin/psql/print.c
index cab9e6e..0691723 100644
--- a/src/bin/psql/print.c
+++ b/src/bin/psql/print.c
@@ -3164,30 +3164,9 @@ printQuery(const PGresult *result, const printQueryOpt *opt, FILE *fout, FILE *f
 
 	for (i = 0; i < cont.ncolumns; i++)
 	{
-		char		align;
-		Oid			ftype = PQftype(result, i);
-
-		switch (ftype)
-		{
-			case INT2OID:
-			case INT4OID:
-			case INT8OID:
-			case FLOAT4OID:
-			case FLOAT8OID:
-			case NUMERICOID:
-			case OIDOID:
-			case XIDOID:
-			case CIDOID:
-			case CASHOID:
-				align = 'r';
-				break;
-			default:
-				align = 'l';
-				break;
-		}
-
 		printTableAddHeader(&cont, PQfname(result, i),
-							opt->translate_header, align);
+							opt->translate_header,
+							column_type_alignment(PQftype(result, i)));
 	}
 
 	/* set cells */
@@ -3229,6 +3208,31 @@ printQuery(const PGresult *result, const printQueryOpt *opt, FILE *fout, FILE *f
 	printTableCleanup(&cont);
 }
 
+char
+column_type_alignment(Oid ftype)
+{
+	char		align;
+
+	switch (ftype)
+	{
+		case INT2OID:
+		case INT4OID:
+		case INT8OID:
+		case FLOAT4OID:
+		case FLOAT8OID:
+		case NUMERICOID:
+		case OIDOID:
+		case XIDOID:
+		case CIDOID:
+		case CASHOID:
+			align = 'r';
+			break;
+		default:
+			align = 'l';
+			break;
+	}
+	return align;
+}
 
 void
 setDecimalLocale(void)
diff --git a/src/bin/psql/print.h b/src/bin/psql/print.h
index b0b6bf5..db6dfb5 100644
--- a/src/bin/psql/print.h
+++ b/src/bin/psql/print.h
@@ -171,7 +171,7 @@ extern FILE *PageOutput(int lines, const printTableOpt *topt);
 extern void ClosePager(FILE *pagerpipe);
 
 extern void html_escaped_print(const char *in, FILE *fout);
-
+extern char column_type_alignment(Oid);
 extern void printTableInit(printTableContent *const content,
 			   const printTableOpt *opt, const char *title,
 			   const int ncolumns, const int nrows);
diff --git a/src/bin/psql/rotate.c b/src/bin/psql/rotate.c
new file mode 100644
index 0000000..540252f
--- /dev/null
+++ b/src/bin/psql/rotate.c
@@ -0,0 +1,603 @@
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright (c) 2000-2015, PostgreSQL Global Development Group
+ *
+ * src/bin/psql/rotate.c
+ */
+
+#include "common.h"
+#include "pqexpbuffer.h"
+#include "rotate.h"
+#include "settings.h"
+
+#include <string.h>
+
+static int
+headerCompare(const void *a, const void *b)
+{
+	return strcmp( ((struct pivot_field*)a)->name,
+				   ((struct pivot_field*)b)->name);
+}
+
+static void
+accumHeader(char* name, int* count, struct pivot_field **sorted_tab, int row_number)
+{
+	struct pivot_field *p;
+
+	/*
+	 * Search for name in sorted_tab. If it doesn't exist, insert it,
+	 * otherwise do nothing.
+	 */
+
+	if (*count >= 1)
+	{
+		p = (struct pivot_field*) bsearch(&name,
+										  *sorted_tab,
+										  *count,
+										  sizeof(struct pivot_field),
+										  headerCompare);
+	}
+	else
+		p=NULL;
+
+	if (!p)
+	{
+		*sorted_tab = pg_realloc(*sorted_tab, sizeof(struct pivot_field) * (1+*count));
+		(*sorted_tab)[*count].name = name;
+		(*sorted_tab)[*count].rank = *count;
+		(*count)++;
+
+		qsort(*sorted_tab,
+			  *count,
+			  sizeof(struct pivot_field),
+			  headerCompare);
+	}
+}
+
+/*
+ * Send a query to sort all column values cast to the Oid passed in a VALUES clause
+ */
+static bool
+sortColumns(Oid coltype, struct pivot_field *columns, int nb_cols, int direction)
+{
+	bool retval = false;
+	PGresult *res = NULL;
+	PQExpBufferData query;
+	int i;
+	Oid *param_types;
+	const char** param_values;
+	int* param_lengths;
+	int* param_formats;
+
+	if (nb_cols < 2)
+		return true;					/* nothing to sort */
+
+	param_types = (Oid*) pg_malloc(nb_cols*sizeof(Oid));
+	param_values = (const char**) pg_malloc(nb_cols*sizeof(char*));
+	param_lengths = (int*) pg_malloc(nb_cols*sizeof(int));
+	param_formats = (int*) pg_malloc(nb_cols*sizeof(int));
+
+	initPQExpBuffer(&query);
+
+	/*
+	 * The query returns the original position of each value in our list,
+	 * ordered by its new position. The value itself is not returned.
+	 */
+	appendPQExpBuffer(&query, "SELECT n FROM (VALUES");
+
+	for (i=1; i <= nb_cols; i++)
+	{
+		if (i < nb_cols)
+			appendPQExpBuffer(&query, "($%d,%d),", i, i);
+		else
+		{
+			appendPQExpBuffer(&query, "($%d,%d)) AS l(x,n) ORDER BY x", i, i);
+			if (direction < 0)
+				appendPQExpBuffer(&query, " DESC");
+		}
+
+		param_types[i-1] = coltype;
+		param_values[i-1] = columns[i-1].name;
+		param_lengths[i-1] = strlen(columns[i-1].name);
+		param_formats[i-1] = 0;
+	}
+
+	res = PQexecParams(pset.db,
+					   query.data,
+					   nb_cols,
+					   param_types,
+					   param_values,
+					   param_lengths,
+					   param_formats,
+					   0);
+
+	if (res)
+	{
+		ExecStatusType status = PQresultStatus(res);
+		if (status == PGRES_TUPLES_OK)
+		{
+			for (i=0; i < PQntuples(res); i++)
+			{
+				int old_pos = atoi(PQgetvalue(res, i, 0));
+
+				if (old_pos < 1 || old_pos > nb_cols || i >= nb_cols)
+				{
+					/*
+					 * A position outside of the range is normally impossible.
+					 * If this happens, we're facing a malfunctioning or hostile
+					 * server or middleware.
+					 */
+					psql_error(_("Unexpected value when sorting horizontal headers"));
+					goto cleanup;
+				}
+				else
+				{
+					columns[old_pos-1].rank = i;
+				}
+			}
+		}
+		else
+		{
+			psql_error(_("Query error when sorting horizontal headers: %s"),
+					   PQerrorMessage(pset.db));
+			goto cleanup;
+		}
+	}
+
+	retval = true;
+
+cleanup:
+	termPQExpBuffer(&query);
+	if (res)
+		PQclear(res);
+	pg_free(param_types);
+	pg_free(param_values);
+	pg_free(param_lengths);
+	pg_free(param_formats);
+	return retval;
+}
+
+static void
+printRotation(const PGresult *results,
+			  int num_columns,
+			  struct pivot_field *piv_columns,
+			  int field_for_columns,
+			  int num_rows,
+			  struct pivot_field *piv_rows,
+			  int field_for_rows)
+{
+	printQueryOpt popt = pset.popt;
+	printTableContent cont;
+	int	i, j, rn;
+	char col_align = 'l';		/* alignment for values inside the grid */
+	int* horiz_map;			 	/* map indices from sorted horizontal headers to piv_columns */
+	char** allocated_cells; 	/*  Pointers for cell contents that are allocated
+								 *  in this function, when cells cannot simply point to
+								 *  PQgetvalue(results, ...) */
+
+	printTableInit(&cont, &popt.topt, popt.title, num_columns+1, num_rows);
+
+	/* Step 1: set target column names (horizontal header) */
+
+	/* The name of the first column is kept unchanged by the rotation */
+	printTableAddHeader(&cont,
+						PQfname(results, field_for_rows),
+						false,
+						column_type_alignment(PQftype(results, field_for_rows)));
+
+	/*
+	 * To iterate over piv_columns[] by piv_columns[].rank, create a reverse map
+	 *  associating each piv_columns[].rank to its index in piv_columns.
+	 *  This avoids an O(N^2) loop later
+	 */
+	horiz_map = (int*) pg_malloc(sizeof(int) * num_columns);
+	for (i = 0; i < num_columns; i++)
+	{
+		horiz_map[piv_columns[i].rank] = i;
+	}
+
+	/*
+	 * In the case of 3 output columns, the contents in the cells are exactly
+	 * the contents of the "value" column (3rd column by default), so their
+	 * alignment is determined by PQftype(). Otherwise the contents are
+	 * made-up strings, so the alignment is 'l'
+	 */
+	if (PQnfields(results) == 3)
+	{
+		int colnum;				/* column placed inside the grid */
+		/*
+		 * find colnum in the permutations of (0,1,2) where colnum is
+		 * neither field_for_rows nor field_for_columns
+		 */
+		switch (field_for_rows)
+		{
+		case 0:
+			colnum = (field_for_columns == 1) ? 2 : 1;
+			break;
+		case 1:
+			colnum = (field_for_columns == 0) ? 2: 0;
+			break;
+		default:				/* should be always 2 */
+			colnum = (field_for_columns == 0) ? 1: 0;
+			break;
+		}
+		col_align = column_type_alignment(PQftype(results, colnum));
+	}
+	else
+		col_align = 'l';
+
+	for (i = 0; i < num_columns; i++)
+	{
+		printTableAddHeader(&cont,
+							piv_columns[horiz_map[i]].name,
+							false,
+							col_align);
+	}
+	pg_free(horiz_map);
+
+	/* Step 2: set row names in the first output column (vertical header) */
+	for (i = 0; i < num_rows; i++)
+	{
+		int k = piv_rows[i].rank;
+		cont.cells[k*(num_columns+1)] = piv_rows[i].name;
+		/* Initialize all cells inside the grid to an empty value */
+		for (j = 0; j < num_columns; j++)
+			cont.cells[k*(num_columns+1)+j+1] = "";
+	}
+	cont.cellsadded = num_rows * (num_columns+1);
+
+	allocated_cells = (char**) pg_malloc0(num_rows * num_columns * sizeof(char*));
+
+	/* Step 3: set all the cells "inside the grid" */
+	for (rn = 0; rn < PQntuples(results); rn++)
+	{
+		char* row_name;
+		char* col_name;
+		int row_number;
+		int col_number;
+		struct pivot_field *p;
+
+		row_number = col_number = -1;
+		/* Find target row */
+		if (!PQgetisnull(results, rn, field_for_rows))
+		{
+			row_name = PQgetvalue(results, rn, field_for_rows);
+			p = (struct pivot_field*) bsearch(&row_name,
+											  piv_rows,
+											  num_rows,
+											  sizeof(struct pivot_field),
+											  headerCompare);
+			if (p)
+				row_number = p->rank;
+		}
+
+		/* Find target column */
+		if (!PQgetisnull(results, rn, field_for_columns))
+		{
+			col_name = PQgetvalue(results, rn, field_for_columns);
+			p = (struct pivot_field*) bsearch(&col_name,
+											  piv_columns,
+											  num_columns,
+											  sizeof(struct pivot_field),
+											  headerCompare);
+			if (p)
+				col_number = p->rank;
+		}
+
+		/* Place value into cell */
+		if (col_number>=0 && row_number>=0)
+		{
+			int idx = 1 + col_number + row_number*(num_columns+1);
+			int src_col = 0;			/* column number in source result */
+			int k = 0;
+
+			do {
+				char *content;
+
+				if (PQnfields(results) == 2)
+				{
+					/*
+					  special case: when the source has only 2 columns, use a
+					  X (cross/checkmark) for the cell content, and set
+					  src_col to a virtual additional column.
+					*/
+					content = "X";
+					src_col = 3;
+				}
+				else if (src_col == field_for_rows || src_col == field_for_columns)
+				{
+					/*
+					  The source values that produce headers are not processed
+					  in this loop, only the values that end up inside the grid.
+					*/
+					src_col++;
+					continue;
+				}
+				else
+				{
+					content = (!PQgetisnull(results, rn, src_col)) ?
+						PQgetvalue(results, rn, src_col) :
+						(popt.nullPrint ? popt.nullPrint : "");
+				}
+
+				if (cont.cells[idx] != NULL && cont.cells[idx][0] != '\0')
+				{
+					/*
+					 * Multiple values for the same (row,col) are projected
+					 * into the same cell. When this happens, separate the
+					 * previous content of the cell from the new value by a
+					 * newline.
+					 */
+					int content_size =
+						strlen(cont.cells[idx])
+						+ 2 			/* room for [CR],LF or space */
+						+ strlen(content)
+						+ 1;			/* '\0' */
+					char *new_content;
+
+					/*
+					 * idx2 is an index into allocated_cells. It differs from
+					 * idx (index into cont.cells), because vertical and
+					 * horizontal headers are included in `cont.cells` but
+					 * excluded from allocated_cells.
+					 */
+					int idx2 = (row_number * num_columns) + col_number;
+
+					if (allocated_cells[idx2] != NULL)
+					{
+						new_content = pg_realloc(allocated_cells[idx2], content_size);
+					}
+					else
+					{
+						/*
+						 * At this point, cont.cells[idx] still contains a
+						 * PQgetvalue() pointer.  Just after, it will contain
+						 * a new pointer maintained in allocated_cells[], and
+						 * freed at the end of this function.
+						 */
+						new_content = pg_malloc(content_size);
+						strcpy(new_content, cont.cells[idx]);
+					}
+					cont.cells[idx] = new_content;
+					allocated_cells[idx2] = new_content;
+
+					/*
+					 * Contents that are on adjacent columns in the source results get
+					 * separated by one space in the target.
+					 * Contents that are on different rows in the source get
+					 * separated by newlines in the target.
+					 */
+					if (k==0)
+						strcat(new_content, "\n");
+					else
+						strcat(new_content, " ");
+					strcat(new_content, content);
+				}
+				else
+				{
+					cont.cells[idx] = content;
+				}
+				k++;
+				src_col++;
+			} while (src_col < PQnfields(results));
+		}
+	}
+
+	printTable(&cont, pset.queryFout, pset.logfile);
+	printTableCleanup(&cont);
+
+
+	for (i=0; i < num_rows * num_columns; i++)
+	{
+		if (allocated_cells[i] != NULL)
+			pg_free(allocated_cells[i]);
+	}
+
+	pg_free(allocated_cells);
+}
+
+/*
+ * Compare a user-supplied argument against a field name obtained by PQfname(),
+ * which is already case-folded.
+ * If arg is not enclosed in double quotes, pg_strcasecmp applies, otherwise
+ * do a case-sensitive comparison with these rules:
+ * - double quotes enclosing 'arg' are filtered out
+ * - double quotes inside 'arg' are expected to be doubled
+ */
+static int
+fieldnameCmp(const char* arg, const char* fieldname)
+{
+	const unsigned char* p = (const unsigned char*) arg;
+	const unsigned char* f = (const unsigned char*) fieldname;
+	unsigned char c;
+
+	if (*p++ != '"')
+		return pg_strcasecmp(arg, fieldname);
+
+	while ((c=*p++))
+	{
+		if (c=='"')
+		{
+			if (*p=='"')
+				p++;			/* skip second quote and continue */
+			else if (*p=='\0')
+				return *p-*f;		/* p finishes before f or is identical */
+
+		}
+		if (*f=='\0')
+			return 1;			/* f finishes before p */
+		if (c!=*f)
+			return c-*f;
+		f++;
+	}
+	return (*f=='\0') ? 0 : 1;
+}
+
+
+/*
+ * arg can be a number or a column name, possibly quoted (like in an ORDER BY clause)
+ * Returns:
+ *  on success, the 0-based index of the column
+ *  or -1 if the column number or name cannot correspond to the PGresult,
+ *        or if it's ambiguous (arg corresponding to several columns)
+ */
+static int
+indexOfColumn(const char* arg, PGresult* res)
+{
+	int idx;
+
+	if (strspn(arg, "0123456789") == strlen(arg))
+	{
+		/* if arg contains only digits, it's a column number */
+		idx = atoi(arg) - 1;
+		if (idx < 0  || idx >= PQnfields(res))
+		{
+			psql_error(_("Invalid column number: %s\n"), arg);
+			return -1;
+		}
+	}
+	else
+	{
+		int i;
+		idx = -1;
+		for (i=0; i < PQnfields(res); i++)
+		{
+			if (fieldnameCmp(arg, PQfname(res, i)) == 0)
+			{
+				if (idx>=0)
+				{
+					/* if another idx was already found for the same name */
+					psql_error(_("Ambiguous column name: %s\n"), arg);
+					return -1;
+				}
+				idx = i;
+			}
+		}
+		if (idx == -1)
+		{
+			psql_error(_("Invalid column name: %s\n"), arg);
+			return -1;
+		}
+	}
+	return idx;
+}
+
+bool
+PrintRotate(PGresult* res,
+			const char* opt_field_for_rows,    /* COLV or null */
+			const char* opt_field_for_columns) /* [-]COLH or null */
+{
+	int		rn;
+	struct pivot_field	*piv_columns = NULL;
+	struct pivot_field	*piv_rows = NULL;
+	int		num_columns = 0;
+	int		num_rows = 0;
+	bool 	retval = false;
+	int		columns_sort_direction = 1; /* 1:ascending, -1:descending */
+
+	/* 0-based index of the field whose distinct values will become COLUMN headers */
+	int		field_for_columns;
+
+	/* 0-based index of the field whose distinct values will become ROW headers */
+	int		field_for_rows;
+
+	if (PQresultStatus(res) != PGRES_TUPLES_OK)
+		goto error_return;
+
+	if (PQnfields(res) < 2)
+	{
+		psql_error(_("A query to rotate must return at least two columns\n"));
+		goto error_return;
+	}
+
+	field_for_rows = (opt_field_for_rows != NULL)
+		? indexOfColumn(opt_field_for_rows, res)
+		: 0;
+
+	if (field_for_rows < 0)
+		goto error_return;
+
+	if (opt_field_for_columns == NULL)
+		field_for_columns = 1;
+	else
+	{
+		/*
+		 * descending sort is requested if the column reference is
+		 * preceded with a minus sign
+		 */
+		if (*opt_field_for_columns == '-')
+		{
+			columns_sort_direction = -1;
+			opt_field_for_columns++;
+		}
+		field_for_columns = indexOfColumn(opt_field_for_columns, res);
+		if (field_for_columns < 0)
+			goto error_return;
+	}
+
+
+	if (field_for_columns == field_for_rows)
+	{
+		psql_error(_("The same column cannot be used for both vertical and horizontal headers\n"));
+		goto error_return;
+	}
+
+	/*
+	 * First pass: accumulate row names and column names, each into their
+	 * array. Use client-side sort but only to build the set of DISTINCT
+	 * values. The final order displayed depends only on server-side
+	 * sorts.
+	 */
+	for (rn = 0; rn < PQntuples(res); rn++)
+	{
+		if (!PQgetisnull(res, rn, field_for_rows))
+		{
+			accumHeader(PQgetvalue(res, rn, field_for_rows),
+						&num_rows,
+						&piv_rows,
+						rn);
+		}
+
+		if (!PQgetisnull(res, rn, field_for_columns))
+		{
+			accumHeader(PQgetvalue(res, rn, field_for_columns),
+						&num_columns,
+						&piv_columns,
+						rn);
+			if (num_columns > 1600)
+			{
+				psql_error(_("Maximum number of columns (1600) exceeded\n"));
+				goto error_return;
+			}
+		}
+	}
+
+	/*
+	 * Second pass: sort the list of target columns on the server.
+	 */
+	if (!sortColumns(PQftype(res, field_for_columns),
+					 piv_columns,
+					 num_columns,
+					 columns_sort_direction))
+		goto error_return;
+
+	/*
+	 * Third pass: print the rotated results.
+	 */
+	printRotation(res,
+				  num_columns,
+				  piv_columns,
+				  field_for_columns,
+				  num_rows,
+				  piv_rows,
+				  field_for_rows);
+
+	retval = true;
+
+error_return:
+	pg_free(piv_columns);
+	pg_free(piv_rows);
+
+	return retval;
+}
diff --git a/src/bin/psql/rotate.h b/src/bin/psql/rotate.h
new file mode 100644
index 0000000..ba027b6
--- /dev/null
+++ b/src/bin/psql/rotate.h
@@ -0,0 +1,33 @@
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright (c) 2000-2015, PostgreSQL Global Development Group
+ *
+ * src/bin/psql/rotate.h
+ */
+
+#ifndef ROTATE_H
+#define ROTATE_H
+
+struct pivot_field
+{
+	/* Pointer obtained from PGgetvalue() for colV or colH */
+	char*	name;
+
+	/* Rank of the field in its list, starting at 0.
+	 * - For headers stacked vertically, rank=N means it's the
+	 *   Nth distinct field encountered when looping through rows
+	 *   in their initial order.
+	 * - For headers stacked horizontally, rank is obtained
+	 *   by server-side sorting in sortColumns()
+	 */
+	int		rank;
+};
+
+/* prototypes */
+extern bool
+PrintRotate(PGresult* res,
+			const char* opt_field_for_rows,
+			const char* opt_field_for_columns);
+
+#endif   /* ROTATE_H */
diff --git a/src/bin/psql/settings.h b/src/bin/psql/settings.h
index 1885bb1..2164928 100644
--- a/src/bin/psql/settings.h
+++ b/src/bin/psql/settings.h
@@ -90,6 +90,9 @@ typedef struct _psqlSettings
 
 	char	   *gfname;			/* one-shot file output argument for \g */
 	char	   *gset_prefix;	/* one-shot prefix argument for \gset */
+	bool		rotate_output;  /* one-shot request to print rotated results */
+	char		*rotate_col_V;  /* one-shot \rotate 1st argument */
+	char		*rotate_col_H;  /* one-shot \rotate 2nd argument */
 
 	bool		notty;			/* stdin or stdout is not a tty (as determined
 								 * on startup) */

diff --git a/doc/src/sgml/ref/psql-ref.sgml b/doc/src/sgml/ref/psql-ref.sgml
index 5899bb4..3836fbd 100644
--- a/doc/src/sgml/ref/psql-ref.sgml
+++ b/doc/src/sgml/ref/psql-ref.sgml
@@ -2449,6 +2449,95 @@ lo_import 152801
         </listitem>
       </varlistentry>
 
+      <varlistentry>
+        <term><literal>\crosstabview [ <replaceable class="parameter">colV</replaceable>  [-|+]<replaceable class="parameter">colH</replaceable> ] </literal></term>
+        <listitem>
+        <para>
+        Execute the current query buffer (like <literal>\g</literal>) and shows the results
+        inside a crosstab grid. The output column <replaceable class="parameter">colV</replaceable>
+        becomes a vertical header and the output column
+        <replaceable class="parameter">colH</replaceable> becomes a horizontal header.
+        The results for the other output columns are projected inside the grid.
+        </para>
+
+        <para>
+        <replaceable class="parameter">colV</replaceable>
+        and <replaceable class="parameter">colH</replaceable> can indicate a
+        column position (starting at 1), or a column name. Normal case folding
+        and quoting rules apply on column names. By default,
+        <replaceable class="parameter">colV</replaceable> is column 1
+        and <replaceable class="parameter">colH</replaceable> is column 2.
+        A query having only one output column cannot be viewed in crosstab, and
+        <replaceable class="parameter">colH</replaceable> must differ from
+        <replaceable class="parameter">colV</replaceable>.
+        </para>
+
+        <para>
+        The vertical header, displayed as the leftmost column,
+        contains the set of all distinct values found in
+        column <replaceable class="parameter">colV</replaceable>, in the order
+        of their first appearance in the query results.
+        </para>
+        <para>
+        The horizontal header, displayed as the first row,
+        contains the set of all distinct non-null values found in
+        column <replaceable class="parameter">colH</replaceable>.  They come
+        by default in their order of appearance in the query results, or in ascending
+        order if a plus (+) sign precedes <replaceable class="parameter">colH</replaceable>,
+        or in descending order if it's a minus (-) sign.
+        </para>
+
+        <para>
+        The query results being tuples of <literal>N</literal> columns
+        (including <replaceable class="parameter">colV</replaceable> and
+        <replaceable class="parameter">colH</replaceable>),
+        for each distinct value <literal>x</literal> of
+        <replaceable class="parameter">colH</replaceable>
+        and each distinct value <literal>y</literal> of
+        <replaceable class="parameter">colV</replaceable>,
+        a cell located at the intersection <literal>(x,y)</literal> in the grid
+        has contents determined by these rules:
+        <itemizedlist>
+        <listitem>
+        <para>
+         if there is no corresponding row in the results such that the value
+         for <replaceable class="parameter">colH</replaceable>
+         is <literal>x</literal> and the value
+         for <replaceable class="parameter">colV</replaceable>
+         is <literal>y</literal>, the cell is empty.
+        </para>
+        </listitem>
+
+        <listitem>
+        <para>
+         if there is exactly one row such that the value
+         for <replaceable class="parameter">colH</replaceable>
+         is <literal>x</literal> and the value
+         for <replaceable class="parameter">colV</replaceable>
+         is <literal>y</literal>, then the <literal>N-2</literal> other
+         columns are displayed in the cell, separated between each other by
+         a space character if needed.
+
+         If <literal>N=2</literal>, the letter <literal>X</literal> is displayed in the cell as
+         if a virtual third column contained that character.
+        </para>
+        </listitem>
+
+        <listitem>
+        <para>
+         if there are several corresponding rows, the behavior is identical to one row
+         except that the values coming from different rows are stacked
+         vertically, rows being separated by newline characters inside
+         the same cell.
+        </para>
+        </listitem>
+
+        </itemizedlist>
+        </para>
+
+        </listitem>
+      </varlistentry>
+
 
       <varlistentry>
         <term><literal>\s [ <replaceable class="parameter">filename</replaceable> ]</literal></term>
diff --git a/src/bin/psql/Makefile b/src/bin/psql/Makefile
index f1336d5..9cb0c4a 100644
--- a/src/bin/psql/Makefile
+++ b/src/bin/psql/Makefile
@@ -23,7 +23,7 @@ override CPPFLAGS := -I. -I$(srcdir) -I$(libpq_srcdir) -I$(top_srcdir)/src/bin/p
 OBJS=	command.o common.o help.o input.o stringutils.o mainloop.o copy.o \
 	startup.o prompt.o variables.o large_obj.o print.o describe.o \
 	tab-complete.o mbprint.o dumputils.o keywords.o kwlookup.o \
-	sql_help.o \
+	sql_help.o crosstabview.o \
 	$(WIN32RES)
 
 
diff --git a/src/bin/psql/command.c b/src/bin/psql/command.c
index 438a4ec..56f37a6 100644
--- a/src/bin/psql/command.c
+++ b/src/bin/psql/command.c
@@ -46,6 +46,7 @@
 #include "mainloop.h"
 #include "print.h"
 #include "psqlscan.h"
+#include "crosstabview.h"
 #include "settings.h"
 #include "variables.h"
 
@@ -1081,6 +1082,34 @@ exec_command(const char *cmd,
 		free(pw2);
 	}
 
+	/* \crosstabview -- execute a query and display results in crosstab */
+	else if (strcmp(cmd, "crosstabview") == 0)
+	{
+		char	*opt1,
+				*opt2;
+
+		opt1 = psql_scan_slash_option(scan_state,
+									  OT_NORMAL, NULL, false);
+		opt2 = psql_scan_slash_option(scan_state,
+									  OT_NORMAL, NULL, false);
+
+		if (opt1 && !opt2)
+		{
+			psql_error(_("\\%s: missing second argument\n"), cmd);
+			success = false;
+		}
+		else
+		{
+			pset.crosstabview_col_V = opt1 ? pg_strdup(opt1): NULL;
+			pset.crosstabview_col_H = opt2 ? pg_strdup(opt2): NULL;
+			pset.crosstabview_output = true;
+			status = PSQL_CMD_SEND;
+		}
+
+		free(opt1);
+		free(opt2);
+	}
+
 	/* \prompt -- prompt and set variable */
 	else if (strcmp(cmd, "prompt") == 0)
 	{
diff --git a/src/bin/psql/common.c b/src/bin/psql/common.c
index 0e266a3..4329fdc 100644
--- a/src/bin/psql/common.c
+++ b/src/bin/psql/common.c
@@ -23,6 +23,7 @@
 #include "command.h"
 #include "copy.h"
 #include "mbprint.h"
+#include "crosstabview.h"
 
 
 
@@ -1061,7 +1062,14 @@ SendQuery(const char *query)
 
 		/* but printing results isn't: */
 		if (OK && results)
-			OK = PrintQueryResults(results);
+		{
+			if (pset.crosstabview_output)
+				OK = PrintResultsInCrossTab(results,
+											pset.crosstabview_col_V,
+											pset.crosstabview_col_H);
+			else
+				OK = PrintQueryResults(results);
+		}
 	}
 	else
 	{
@@ -1177,6 +1185,17 @@ sendquery_cleanup:
 		pset.gset_prefix = NULL;
 	}
 
+	pset.crosstabview_output = false;
+	if (pset.crosstabview_col_V)
+	{
+		free(pset.crosstabview_col_V);
+		pset.crosstabview_col_V = NULL;
+	}
+	if (pset.crosstabview_col_H)
+	{
+		free(pset.crosstabview_col_H);
+		pset.crosstabview_col_H = NULL;
+	}
 	return OK;
 }
 
diff --git a/src/bin/psql/crosstabview.c b/src/bin/psql/crosstabview.c
new file mode 100644
index 0000000..08b4203
--- /dev/null
+++ b/src/bin/psql/crosstabview.c
@@ -0,0 +1,608 @@
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright (c) 2000-2015, PostgreSQL Global Development Group
+ *
+ * src/bin/psql/crosstabview.c
+ */
+
+#include "common.h"
+#include "pqexpbuffer.h"
+#include "crosstabview.h"
+#include "settings.h"
+
+#include <string.h>
+
+static int
+headerCompare(const void *a, const void *b)
+{
+	return strcmp( ((struct pivot_field*)a)->name,
+				   ((struct pivot_field*)b)->name);
+}
+
+static void
+accumHeader(char* name, int* count, struct pivot_field **sorted_tab, int row_number)
+{
+	struct pivot_field *p;
+
+	/*
+	 * Search for name in sorted_tab. If it doesn't exist, insert it,
+	 * otherwise do nothing.
+	 */
+
+	if (*count >= 1)
+	{
+		p = (struct pivot_field*) bsearch(&name,
+										  *sorted_tab,
+										  *count,
+										  sizeof(struct pivot_field),
+										  headerCompare);
+	}
+	else
+		p=NULL;
+
+	if (!p)
+	{
+		*sorted_tab = pg_realloc(*sorted_tab, sizeof(struct pivot_field) * (1+*count));
+		(*sorted_tab)[*count].name = name;
+		(*sorted_tab)[*count].rank = *count;
+		(*count)++;
+
+		qsort(*sorted_tab,
+			  *count,
+			  sizeof(struct pivot_field),
+			  headerCompare);
+	}
+}
+
+/*
+ * Send a query to sort all column values cast to the Oid passed in a VALUES clause
+ */
+static bool
+sortColumns(Oid coltype, struct pivot_field *columns, int nb_cols, int direction)
+{
+	bool retval = false;
+	PGresult *res = NULL;
+	PQExpBufferData query;
+	int i;
+	Oid *param_types;
+	const char** param_values;
+	int* param_lengths;
+	int* param_formats;
+
+	if (nb_cols < 2 || direction==0)
+		return true;					/* nothing to sort */
+
+	param_types = (Oid*) pg_malloc(nb_cols*sizeof(Oid));
+	param_values = (const char**) pg_malloc(nb_cols*sizeof(char*));
+	param_lengths = (int*) pg_malloc(nb_cols*sizeof(int));
+	param_formats = (int*) pg_malloc(nb_cols*sizeof(int));
+
+	initPQExpBuffer(&query);
+
+	/*
+	 * The query returns the original position of each value in our list,
+	 * ordered by its new position. The value itself is not returned.
+	 */
+	appendPQExpBuffer(&query, "SELECT n FROM (VALUES");
+
+	for (i=1; i <= nb_cols; i++)
+	{
+		if (i < nb_cols)
+			appendPQExpBuffer(&query, "($%d,%d),", i, i);
+		else
+		{
+			appendPQExpBuffer(&query, "($%d,%d)) AS l(x,n) ORDER BY x", i, i);
+			if (direction < 0)
+				appendPQExpBuffer(&query, " DESC");
+		}
+
+		param_types[i-1] = coltype;
+		param_values[i-1] = columns[i-1].name;
+		param_lengths[i-1] = strlen(columns[i-1].name);
+		param_formats[i-1] = 0;
+	}
+
+	res = PQexecParams(pset.db,
+					   query.data,
+					   nb_cols,
+					   param_types,
+					   param_values,
+					   param_lengths,
+					   param_formats,
+					   0);
+
+	if (res)
+	{
+		ExecStatusType status = PQresultStatus(res);
+		if (status == PGRES_TUPLES_OK)
+		{
+			for (i=0; i < PQntuples(res); i++)
+			{
+				int old_pos = atoi(PQgetvalue(res, i, 0));
+
+				if (old_pos < 1 || old_pos > nb_cols || i >= nb_cols)
+				{
+					/*
+					 * A position outside of the range is normally impossible.
+					 * If this happens, we're facing a malfunctioning or hostile
+					 * server or middleware.
+					 */
+					psql_error(_("Unexpected value when sorting horizontal headers"));
+					goto cleanup;
+				}
+				else
+				{
+					columns[old_pos-1].rank = i;
+				}
+			}
+		}
+		else
+		{
+			psql_error(_("Query error when sorting horizontal headers: %s"),
+					   PQerrorMessage(pset.db));
+			goto cleanup;
+		}
+	}
+
+	retval = true;
+
+cleanup:
+	termPQExpBuffer(&query);
+	if (res)
+		PQclear(res);
+	pg_free(param_types);
+	pg_free(param_values);
+	pg_free(param_lengths);
+	pg_free(param_formats);
+	return retval;
+}
+
+static void
+printCrosstab(const PGresult *results,
+			  int num_columns,
+			  struct pivot_field *piv_columns,
+			  int field_for_columns,
+			  int num_rows,
+			  struct pivot_field *piv_rows,
+			  int field_for_rows)
+{
+	printQueryOpt popt = pset.popt;
+	printTableContent cont;
+	int	i, j, rn;
+	char col_align = 'l';		/* alignment for values inside the grid */
+	int* horiz_map;			 	/* map indices from sorted horizontal headers to piv_columns */
+	char** allocated_cells; 	/*  Pointers for cell contents that are allocated
+								 *  in this function, when cells cannot simply point to
+								 *  PQgetvalue(results, ...) */
+
+	printTableInit(&cont, &popt.topt, popt.title, num_columns+1, num_rows);
+
+	/* Step 1: set target column names (horizontal header) */
+
+	/* The name of the first column is kept unchanged by the pivoting */
+	printTableAddHeader(&cont,
+						PQfname(results, field_for_rows),
+						false,
+						column_type_alignment(PQftype(results, field_for_rows)));
+
+	/*
+	 * To iterate over piv_columns[] by piv_columns[].rank, create a reverse map
+	 *  associating each piv_columns[].rank to its index in piv_columns.
+	 *  This avoids an O(N^2) loop later
+	 */
+	horiz_map = (int*) pg_malloc(sizeof(int) * num_columns);
+	for (i = 0; i < num_columns; i++)
+	{
+		horiz_map[piv_columns[i].rank] = i;
+	}
+
+	/*
+	 * In the case of 3 output columns, the contents in the cells are exactly
+	 * the contents of the "value" column (3rd column by default), so their
+	 * alignment is determined by PQftype(). Otherwise the contents are
+	 * made-up strings, so the alignment is 'l'
+	 */
+	if (PQnfields(results) == 3)
+	{
+		int colnum;				/* column placed inside the grid */
+		/*
+		 * find colnum in the permutations of (0,1,2) where colnum is
+		 * neither field_for_rows nor field_for_columns
+		 */
+		switch (field_for_rows)
+		{
+		case 0:
+			colnum = (field_for_columns == 1) ? 2 : 1;
+			break;
+		case 1:
+			colnum = (field_for_columns == 0) ? 2: 0;
+			break;
+		default:				/* should be always 2 */
+			colnum = (field_for_columns == 0) ? 1: 0;
+			break;
+		}
+		col_align = column_type_alignment(PQftype(results, colnum));
+	}
+	else
+		col_align = 'l';
+
+	for (i = 0; i < num_columns; i++)
+	{
+		printTableAddHeader(&cont,
+							piv_columns[horiz_map[i]].name,
+							false,
+							col_align);
+	}
+	pg_free(horiz_map);
+
+	/* Step 2: set row names in the first output column (vertical header) */
+	for (i = 0; i < num_rows; i++)
+	{
+		int k = piv_rows[i].rank;
+		cont.cells[k*(num_columns+1)] = piv_rows[i].name;
+		/* Initialize all cells inside the grid to an empty value */
+		for (j = 0; j < num_columns; j++)
+			cont.cells[k*(num_columns+1)+j+1] = "";
+	}
+	cont.cellsadded = num_rows * (num_columns+1);
+
+	allocated_cells = (char**) pg_malloc0(num_rows * num_columns * sizeof(char*));
+
+	/* Step 3: set all the cells "inside the grid" */
+	for (rn = 0; rn < PQntuples(results); rn++)
+	{
+		char* row_name;
+		char* col_name;
+		int row_number;
+		int col_number;
+		struct pivot_field *p;
+
+		row_number = col_number = -1;
+		/* Find target row */
+		if (!PQgetisnull(results, rn, field_for_rows))
+		{
+			row_name = PQgetvalue(results, rn, field_for_rows);
+			p = (struct pivot_field*) bsearch(&row_name,
+											  piv_rows,
+											  num_rows,
+											  sizeof(struct pivot_field),
+											  headerCompare);
+			if (p)
+				row_number = p->rank;
+		}
+
+		/* Find target column */
+		if (!PQgetisnull(results, rn, field_for_columns))
+		{
+			col_name = PQgetvalue(results, rn, field_for_columns);
+			p = (struct pivot_field*) bsearch(&col_name,
+											  piv_columns,
+											  num_columns,
+											  sizeof(struct pivot_field),
+											  headerCompare);
+			if (p)
+				col_number = p->rank;
+		}
+
+		/* Place value into cell */
+		if (col_number>=0 && row_number>=0)
+		{
+			int idx = 1 + col_number + row_number*(num_columns+1);
+			int src_col = 0;			/* column number in source result */
+			int k = 0;
+
+			do {
+				char *content;
+
+				if (PQnfields(results) == 2)
+				{
+					/*
+					  special case: when the source has only 2 columns, use a
+					  X (cross/checkmark) for the cell content, and set
+					  src_col to a virtual additional column.
+					*/
+					content = "X";
+					src_col = 3;
+				}
+				else if (src_col == field_for_rows || src_col == field_for_columns)
+				{
+					/*
+					  The source values that produce headers are not processed
+					  in this loop, only the values that end up inside the grid.
+					*/
+					src_col++;
+					continue;
+				}
+				else
+				{
+					content = (!PQgetisnull(results, rn, src_col)) ?
+						PQgetvalue(results, rn, src_col) :
+						(popt.nullPrint ? popt.nullPrint : "");
+				}
+
+				if (cont.cells[idx] != NULL && cont.cells[idx][0] != '\0')
+				{
+					/*
+					 * Multiple values for the same (row,col) are projected
+					 * into the same cell. When this happens, separate the
+					 * previous content of the cell from the new value by a
+					 * newline.
+					 */
+					int content_size =
+						strlen(cont.cells[idx])
+						+ 2 			/* room for [CR],LF or space */
+						+ strlen(content)
+						+ 1;			/* '\0' */
+					char *new_content;
+
+					/*
+					 * idx2 is an index into allocated_cells. It differs from
+					 * idx (index into cont.cells), because vertical and
+					 * horizontal headers are included in `cont.cells` but
+					 * excluded from allocated_cells.
+					 */
+					int idx2 = (row_number * num_columns) + col_number;
+
+					if (allocated_cells[idx2] != NULL)
+					{
+						new_content = pg_realloc(allocated_cells[idx2], content_size);
+					}
+					else
+					{
+						/*
+						 * At this point, cont.cells[idx] still contains a
+						 * PQgetvalue() pointer.  Just after, it will contain
+						 * a new pointer maintained in allocated_cells[], and
+						 * freed at the end of this function.
+						 */
+						new_content = pg_malloc(content_size);
+						strcpy(new_content, cont.cells[idx]);
+					}
+					cont.cells[idx] = new_content;
+					allocated_cells[idx2] = new_content;
+
+					/*
+					 * Contents that are on adjacent columns in the source results get
+					 * separated by one space in the target.
+					 * Contents that are on different rows in the source get
+					 * separated by newlines in the target.
+					 */
+					if (k==0)
+						strcat(new_content, "\n");
+					else
+						strcat(new_content, " ");
+					strcat(new_content, content);
+				}
+				else
+				{
+					cont.cells[idx] = content;
+				}
+				k++;
+				src_col++;
+			} while (src_col < PQnfields(results));
+		}
+	}
+
+	printTable(&cont, pset.queryFout, pset.logfile);
+	printTableCleanup(&cont);
+
+
+	for (i=0; i < num_rows * num_columns; i++)
+	{
+		if (allocated_cells[i] != NULL)
+			pg_free(allocated_cells[i]);
+	}
+
+	pg_free(allocated_cells);
+}
+
+/*
+ * Compare a user-supplied argument against a field name obtained by PQfname(),
+ * which is already case-folded.
+ * If arg is not enclosed in double quotes, pg_strcasecmp applies, otherwise
+ * do a case-sensitive comparison with these rules:
+ * - double quotes enclosing 'arg' are filtered out
+ * - double quotes inside 'arg' are expected to be doubled
+ */
+static int
+fieldnameCmp(const char* arg, const char* fieldname)
+{
+	const unsigned char* p = (const unsigned char*) arg;
+	const unsigned char* f = (const unsigned char*) fieldname;
+	unsigned char c;
+
+	if (*p++ != '"')
+		return pg_strcasecmp(arg, fieldname);
+
+	while ((c=*p++))
+	{
+		if (c=='"')
+		{
+			if (*p=='"')
+				p++;			/* skip second quote and continue */
+			else if (*p=='\0')
+				return *p-*f;		/* p finishes before f or is identical */
+
+		}
+		if (*f=='\0')
+			return 1;			/* f finishes before p */
+		if (c!=*f)
+			return c-*f;
+		f++;
+	}
+	return (*f=='\0') ? 0 : 1;
+}
+
+
+/*
+ * arg can be a number or a column name, possibly quoted (like in an ORDER BY clause)
+ * Returns:
+ *  on success, the 0-based index of the column
+ *  or -1 if the column number or name is not found in the result's structure,
+ *        or if it's ambiguous (arg corresponding to several columns)
+ */
+static int
+indexOfColumn(const char* arg, PGresult* res)
+{
+	int idx;
+
+	if (strspn(arg, "0123456789") == strlen(arg))
+	{
+		/* if arg contains only digits, it's a column number */
+		idx = atoi(arg) - 1;
+		if (idx < 0  || idx >= PQnfields(res))
+		{
+			psql_error(_("Invalid column number: %s\n"), arg);
+			return -1;
+		}
+	}
+	else
+	{
+		int i;
+		idx = -1;
+		for (i=0; i < PQnfields(res); i++)
+		{
+			if (fieldnameCmp(arg, PQfname(res, i)) == 0)
+			{
+				if (idx>=0)
+				{
+					/* if another idx was already found for the same name */
+					psql_error(_("Ambiguous column name: %s\n"), arg);
+					return -1;
+				}
+				idx = i;
+			}
+		}
+		if (idx == -1)
+		{
+			psql_error(_("Invalid column name: %s\n"), arg);
+			return -1;
+		}
+	}
+	return idx;
+}
+
+bool
+PrintResultsInCrossTab(PGresult* res,
+					   const char* opt_field_for_rows,    /* COLV or null */
+					   const char* opt_field_for_columns) /* [-+]COLH or null */
+{
+	int		rn;
+	struct pivot_field	*piv_columns = NULL;
+	struct pivot_field	*piv_rows = NULL;
+	int		num_columns = 0;
+	int		num_rows = 0;
+	bool 	retval = false;
+	int		columns_sort_direction = 0; /* 1:ascending, 0:none, -1:descending */
+
+	/* 0-based index of the field whose distinct values will become COLUMN headers */
+	int		field_for_columns;
+
+	/* 0-based index of the field whose distinct values will become ROW headers */
+	int		field_for_rows;
+
+	if (PQresultStatus(res) != PGRES_TUPLES_OK)
+		goto error_return;
+
+	if (PQnfields(res) < 2)
+	{
+		psql_error(_("The query must return at least two columns to be shown in crosstab\n"));
+		goto error_return;
+	}
+
+	field_for_rows = (opt_field_for_rows != NULL)
+		? indexOfColumn(opt_field_for_rows, res)
+		: 0;
+
+	if (field_for_rows < 0)
+		goto error_return;
+
+	if (opt_field_for_columns == NULL)
+		field_for_columns = 1;
+	else
+	{
+		/*
+		 * descending sort is requested if the column reference is
+		 * preceded with a minus sign
+		 */
+		if (*opt_field_for_columns == '-')
+		{
+			columns_sort_direction = -1;
+			opt_field_for_columns++;
+		}
+		else if (*opt_field_for_columns == '+')
+		{
+			columns_sort_direction = 1;
+			opt_field_for_columns++;
+		}
+		field_for_columns = indexOfColumn(opt_field_for_columns, res);
+		if (field_for_columns < 0)
+			goto error_return;
+	}
+
+
+	if (field_for_columns == field_for_rows)
+	{
+		psql_error(_("The same column cannot be used for both vertical and horizontal headers\n"));
+		goto error_return;
+	}
+
+	/*
+	 * First pass: accumulate row names and column names, each into their
+	 * array. Use client-side sort but only to build the set of DISTINCT
+	 * values. The final order displayed depends only on server-side
+	 * sorts.
+	 */
+	for (rn = 0; rn < PQntuples(res); rn++)
+	{
+		if (!PQgetisnull(res, rn, field_for_rows))
+		{
+			accumHeader(PQgetvalue(res, rn, field_for_rows),
+						&num_rows,
+						&piv_rows,
+						rn);
+		}
+
+		if (!PQgetisnull(res, rn, field_for_columns))
+		{
+			accumHeader(PQgetvalue(res, rn, field_for_columns),
+						&num_columns,
+						&piv_columns,
+						rn);
+			if (num_columns > 1600)
+			{
+				psql_error(_("Maximum number of columns (1600) exceeded\n"));
+				goto error_return;
+			}
+		}
+	}
+
+	/*
+	 * Second pass: sort the list of target columns on the server.
+	 */
+	if (!sortColumns(PQftype(res, field_for_columns),
+					 piv_columns,
+					 num_columns,
+					 columns_sort_direction))
+		goto error_return;
+
+	/*
+	 * Third pass: print the crosstab'ed results.
+	 */
+	printCrosstab(res,
+				  num_columns,
+				  piv_columns,
+				  field_for_columns,
+				  num_rows,
+				  piv_rows,
+				  field_for_rows);
+
+	retval = true;
+
+error_return:
+	pg_free(piv_columns);
+	pg_free(piv_rows);
+
+	return retval;
+}
diff --git a/src/bin/psql/crosstabview.h b/src/bin/psql/crosstabview.h
new file mode 100644
index 0000000..c18efef
--- /dev/null
+++ b/src/bin/psql/crosstabview.h
@@ -0,0 +1,33 @@
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright (c) 2000-2015, PostgreSQL Global Development Group
+ *
+ * src/bin/psql/crosstabview.h
+ */
+
+#ifndef CROSSTABVIEW_H
+#define CROSSTABVIEW_H
+
+struct pivot_field
+{
+	/* Pointer obtained from PGgetvalue() for colV or colH */
+	char*	name;
+
+	/* Rank of the field in its list, starting at 0.
+	 * - For headers stacked vertically, rank=N means it's the
+	 *   Nth distinct field encountered when looping through rows
+	 *   in their initial order.
+	 * - For headers stacked horizontally, rank is obtained
+	 *   by server-side sorting in sortColumns()
+	 */
+	int		rank;
+};
+
+/* prototypes */
+extern bool
+PrintResultsInCrossTab(PGresult* res,
+					   const char* opt_field_for_rows,
+					   const char* opt_field_for_columns);
+
+#endif   /* CROSSTABVIEW_H */
diff --git a/src/bin/psql/help.c b/src/bin/psql/help.c
index 5b63e76..c38d51d 100644
--- a/src/bin/psql/help.c
+++ b/src/bin/psql/help.c
@@ -175,6 +175,7 @@ slashUsage(unsigned short int pager)
 	fprintf(output, _("  \\g [FILE] or ;         execute query (and send results to file or |pipe)\n"));
 	fprintf(output, _("  \\gset [PREFIX]         execute query and store results in psql variables\n"));
 	fprintf(output, _("  \\q                     quit psql\n"));
+	fprintf(output, _("  \\crosstabview [V H]    execute query and display results in crosstab\n"));
 	fprintf(output, _("  \\watch [SEC]           execute query every SEC seconds\n"));
 	fprintf(output, "\n");
 
diff --git a/src/bin/psql/print.c b/src/bin/psql/print.c
index ad4350e..08d80db 100644
--- a/src/bin/psql/print.c
+++ b/src/bin/psql/print.c
@@ -3170,30 +3170,9 @@ printQuery(const PGresult *result, const printQueryOpt *opt, FILE *fout, FILE *f
 
 	for (i = 0; i < cont.ncolumns; i++)
 	{
-		char		align;
-		Oid			ftype = PQftype(result, i);
-
-		switch (ftype)
-		{
-			case INT2OID:
-			case INT4OID:
-			case INT8OID:
-			case FLOAT4OID:
-			case FLOAT8OID:
-			case NUMERICOID:
-			case OIDOID:
-			case XIDOID:
-			case CIDOID:
-			case CASHOID:
-				align = 'r';
-				break;
-			default:
-				align = 'l';
-				break;
-		}
-
 		printTableAddHeader(&cont, PQfname(result, i),
-							opt->translate_header, align);
+							opt->translate_header,
+							column_type_alignment(PQftype(result, i)));
 	}
 
 	/* set cells */
@@ -3235,6 +3214,31 @@ printQuery(const PGresult *result, const printQueryOpt *opt, FILE *fout, FILE *f
 	printTableCleanup(&cont);
 }
 
+char
+column_type_alignment(Oid ftype)
+{
+	char		align;
+
+	switch (ftype)
+	{
+		case INT2OID:
+		case INT4OID:
+		case INT8OID:
+		case FLOAT4OID:
+		case FLOAT8OID:
+		case NUMERICOID:
+		case OIDOID:
+		case XIDOID:
+		case CIDOID:
+		case CASHOID:
+			align = 'r';
+			break;
+		default:
+			align = 'l';
+			break;
+	}
+	return align;
+}
 
 void
 setDecimalLocale(void)
diff --git a/src/bin/psql/print.h b/src/bin/psql/print.h
index b0b6bf5..db6dfb5 100644
--- a/src/bin/psql/print.h
+++ b/src/bin/psql/print.h
@@ -171,7 +171,7 @@ extern FILE *PageOutput(int lines, const printTableOpt *topt);
 extern void ClosePager(FILE *pagerpipe);
 
 extern void html_escaped_print(const char *in, FILE *fout);
-
+extern char column_type_alignment(Oid);
 extern void printTableInit(printTableContent *const content,
 			   const printTableOpt *opt, const char *title,
 			   const int ncolumns, const int nrows);
diff --git a/src/bin/psql/settings.h b/src/bin/psql/settings.h
index 1885bb1..6069024 100644
--- a/src/bin/psql/settings.h
+++ b/src/bin/psql/settings.h
@@ -90,6 +90,9 @@ typedef struct _psqlSettings
 
 	char	   *gfname;			/* one-shot file output argument for \g */
 	char	   *gset_prefix;	/* one-shot prefix argument for \gset */
+	bool		crosstabview_output;  /* one-shot request to print results in crosstab */
+	char		*crosstabview_col_V;  /* one-shot \crosstabview 1st argument */
+	char		*crosstabview_col_H;  /* one-shot \crosstabview 2nd argument */
 
 	bool		notty;			/* stdin or stdout is not a tty (as determined
 								 * on startup) */

diff --git a/doc/src/sgml/ref/psql-ref.sgml b/doc/src/sgml/ref/psql-ref.sgml
new file mode 100644
index e4f72a8..ed802b3
*** a/doc/src/sgml/ref/psql-ref.sgml
--- b/doc/src/sgml/ref/psql-ref.sgml
*************** lo_import 152801
*** 2449,2454 ****
--- 2449,2543 ----
          </listitem>
        </varlistentry>
  
+       <varlistentry>
+         <term><literal>\crosstabview [ <replaceable class="parameter">colV</replaceable>  [-|+]<replaceable class="parameter">colH</replaceable> ] </literal></term>
+         <listitem>
+         <para>
+         Execute the current query buffer (like <literal>\g</literal>) and shows the results
+         inside a crosstab grid. The output column <replaceable class="parameter">colV</replaceable>
+         becomes a vertical header and the output column
+         <replaceable class="parameter">colH</replaceable> becomes a horizontal header.
+         The results for the other output columns are projected inside the grid.
+         </para>
+ 
+         <para>
+         <replaceable class="parameter">colV</replaceable>
+         and <replaceable class="parameter">colH</replaceable> can indicate a
+         column position (starting at 1), or a column name. Normal case folding
+         and quoting rules apply on column names. By default,
+         <replaceable class="parameter">colV</replaceable> is column 1
+         and <replaceable class="parameter">colH</replaceable> is column 2.
+         A query having only one output column cannot be viewed in crosstab, and
+         <replaceable class="parameter">colH</replaceable> must differ from
+         <replaceable class="parameter">colV</replaceable>.
+         </para>
+ 
+         <para>
+         The vertical header, displayed as the leftmost column,
+         contains the set of all distinct values found in
+         column <replaceable class="parameter">colV</replaceable>, in the order
+         of their first appearance in the query results.
+         </para>
+         <para>
+         The horizontal header, displayed as the first row,
+         contains the set of all distinct non-null values found in
+         column <replaceable class="parameter">colH</replaceable>.  They come
+         by default in their order of appearance in the query results, or in ascending
+         order if a plus (+) sign precedes <replaceable class="parameter">colH</replaceable>,
+         or in descending order if it's a minus (-) sign.
+         </para>
+ 
+         <para>
+         The query results being tuples of <literal>N</literal> columns
+         (including <replaceable class="parameter">colV</replaceable> and
+         <replaceable class="parameter">colH</replaceable>),
+         for each distinct value <literal>x</literal> of
+         <replaceable class="parameter">colH</replaceable>
+         and each distinct value <literal>y</literal> of
+         <replaceable class="parameter">colV</replaceable>,
+         a cell located at the intersection <literal>(x,y)</literal> in the grid
+         has contents determined by these rules:
+         <itemizedlist>
+         <listitem>
+         <para>
+          if there is no corresponding row in the results such that the value
+          for <replaceable class="parameter">colH</replaceable>
+          is <literal>x</literal> and the value
+          for <replaceable class="parameter">colV</replaceable>
+          is <literal>y</literal>, the cell is empty.
+         </para>
+         </listitem>
+ 
+         <listitem>
+         <para>
+          if there is exactly one row such that the value
+          for <replaceable class="parameter">colH</replaceable>
+          is <literal>x</literal> and the value
+          for <replaceable class="parameter">colV</replaceable>
+          is <literal>y</literal>, then the <literal>N-2</literal> other
+          columns are displayed in the cell, separated between each other by
+          a space character if needed.
+ 
+          If <literal>N=2</literal>, the letter <literal>X</literal> is displayed in the cell as
+          if a virtual third column contained that character.
+         </para>
+         </listitem>
+ 
+         <listitem>
+         <para>
+          if there are several corresponding rows, the behavior is identical to one row
+          except that the values coming from different rows are stacked
+          vertically, rows being separated by newline characters inside
+          the same cell.
+         </para>
+         </listitem>
+ 
+         </itemizedlist>
+         </para>
+ 
+         </listitem>
+       </varlistentry>
+ 
  
        <varlistentry>
          <term><literal>\s [ <replaceable class="parameter">filename</replaceable> ]</literal></term>
diff --git a/src/bin/psql/Makefile b/src/bin/psql/Makefile
new file mode 100644
index f1336d5..9cb0c4a
*** a/src/bin/psql/Makefile
--- b/src/bin/psql/Makefile
*************** override CPPFLAGS := -I. -I$(srcdir) -I$
*** 23,29 ****
  OBJS=	command.o common.o help.o input.o stringutils.o mainloop.o copy.o \
  	startup.o prompt.o variables.o large_obj.o print.o describe.o \
  	tab-complete.o mbprint.o dumputils.o keywords.o kwlookup.o \
! 	sql_help.o \
  	$(WIN32RES)
  
  
--- 23,29 ----
  OBJS=	command.o common.o help.o input.o stringutils.o mainloop.o copy.o \
  	startup.o prompt.o variables.o large_obj.o print.o describe.o \
  	tab-complete.o mbprint.o dumputils.o keywords.o kwlookup.o \
! 	sql_help.o crosstabview.o \
  	$(WIN32RES)
  
  
diff --git a/src/bin/psql/command.c b/src/bin/psql/command.c
new file mode 100644
index 8eca4cf..8305d1e
*** a/src/bin/psql/command.c
--- b/src/bin/psql/command.c
***************
*** 46,51 ****
--- 46,52 ----
  #include "mainloop.h"
  #include "print.h"
  #include "psqlscan.h"
+ #include "crosstabview.h"
  #include "settings.h"
  #include "variables.h"
  
*************** exec_command(const char *cmd,
*** 1081,1086 ****
--- 1082,1119 ----
  		free(pw2);
  	}
  
+ 	/* \crosstabview -- execute a query and display results in crosstab */
+ 	else if (strcmp(cmd, "crosstabview") == 0)
+ 	{
+ 		char	*opt1,
+ 				*opt2,
+ 				*opt3;
+ 
+ 		opt1 = psql_scan_slash_option(scan_state,
+ 									  OT_NORMAL, NULL, false);
+ 		opt2 = psql_scan_slash_option(scan_state,
+ 									  OT_NORMAL, NULL, false);
+ 		opt3 = psql_scan_slash_option(scan_state,
+ 									  OT_NORMAL, NULL, false);
+ 
+ 		if (opt1 && !opt2)
+ 		{
+ 			psql_error(_("\\%s: missing second argument\n"), cmd);
+ 			success = false;
+ 		}
+ 		else
+ 		{
+ 			pset.crosstabview_col_V = opt1 ? pg_strdup(opt1) : NULL;
+ 			pset.crosstabview_col_H = opt2 ? pg_strdup(opt2) : NULL;
+ 			pset.crosstabview_col_L = opt3 ? pg_strdup(opt3) : NULL;
+ 			pset.crosstabview_output = true;
+ 			status = PSQL_CMD_SEND;
+ 		}
+ 
+ 		free(opt1);
+ 		free(opt2);
+ 	}
+ 
  	/* \prompt -- prompt and set variable */
  	else if (strcmp(cmd, "prompt") == 0)
  	{
diff --git a/src/bin/psql/common.c b/src/bin/psql/common.c
new file mode 100644
index 3254a14..8a7984d
*** a/src/bin/psql/common.c
--- b/src/bin/psql/common.c
***************
*** 24,29 ****
--- 24,30 ----
  #include "command.h"
  #include "copy.h"
  #include "mbprint.h"
+ #include "crosstabview.h"
  
  
  
*************** SendQuery(const char *query)
*** 1062,1071 ****
  
  		/* but printing results isn't: */
  		if (OK && results)
! 			OK = PrintQueryResults(results);
  	}
  	else
  	{
  		/* Fetch-in-segments mode */
  		OK = ExecQueryUsingCursor(query, &elapsed_msec);
  		ResetCancelConn();
--- 1063,1084 ----
  
  		/* but printing results isn't: */
  		if (OK && results)
! 		{
! 			if (pset.crosstabview_output)
! 				OK = PrintResultsInCrossTab(results,
! 											pset.crosstabview_col_V,
! 											pset.crosstabview_col_H,
! 											pset.crosstabview_col_L);
! 			else
! 				OK = PrintQueryResults(results);
! 		}
  	}
  	else
  	{
+ 		if (pset.crosstabview_output)
+ 			psql_error("\\crosstabview is ignored due active FETCH_COUNT = %d\n",
+ 					pset.fetch_count);
+ 
  		/* Fetch-in-segments mode */
  		OK = ExecQueryUsingCursor(query, &elapsed_msec);
  		ResetCancelConn();
*************** sendquery_cleanup:
*** 1178,1183 ****
--- 1191,1213 ----
  		pset.gset_prefix = NULL;
  	}
  
+ 	pset.crosstabview_output = false;
+ 	if (pset.crosstabview_col_V)
+ 	{
+ 		free(pset.crosstabview_col_V);
+ 		pset.crosstabview_col_V = NULL;
+ 	}
+ 	if (pset.crosstabview_col_H)
+ 	{
+ 		free(pset.crosstabview_col_H);
+ 		pset.crosstabview_col_H = NULL;
+ 	}
+ 	if (pset.crosstabview_col_L)
+ 	{
+ 		free(pset.crosstabview_col_H);
+ 		pset.crosstabview_col_H = NULL;
+ 	}
+ 
  	return OK;
  }
  
diff --git a/src/bin/psql/crosstabview.c b/src/bin/psql/crosstabview.c
new file mode 100644
index ...6dce5a4
*** a/src/bin/psql/crosstabview.c
--- b/src/bin/psql/crosstabview.c
***************
*** 0 ****
--- 1,636 ----
+ /*
+  * psql - the PostgreSQL interactive terminal
+  *
+  * Copyright (c) 2000-2015, PostgreSQL Global Development Group
+  *
+  * src/bin/psql/crosstabview.c
+  */
+ 
+ #include "common.h"
+ #include "pqexpbuffer.h"
+ #include "crosstabview.h"
+ #include "settings.h"
+ 
+ #include <string.h>
+ 
+ static int
+ headerCompare(const void *a, const void *b)
+ {
+ 	return strcmp( ((struct pivot_field*)a)->name,
+ 				   ((struct pivot_field*)b)->name);
+ }
+ 
+ static void
+ accumHeader(char* name, char *label, int* count, struct pivot_field **sorted_tab, int row_number)
+ {
+ 	struct pivot_field *p;
+ 
+ 	/*
+ 	 * Search for name in sorted_tab. If it doesn't exist, insert it,
+ 	 * otherwise do nothing.
+ 	 */
+ 
+ 	if (*count >= 1)
+ 	{
+ 		p = (struct pivot_field*) bsearch(&name,
+ 										  *sorted_tab,
+ 										  *count,
+ 										  sizeof(struct pivot_field),
+ 										  headerCompare);
+ 	}
+ 	else
+ 		p=NULL;
+ 
+ 	if (!p)
+ 	{
+ 		*sorted_tab = pg_realloc(*sorted_tab, sizeof(struct pivot_field) * (1+*count));
+ 		(*sorted_tab)[*count].name = name;
+ 		(*sorted_tab)[*count].label = label;
+ 		(*sorted_tab)[*count].rank = *count;
+ 		(*count)++;
+ 
+ 		qsort(*sorted_tab,
+ 			  *count,
+ 			  sizeof(struct pivot_field),
+ 			  headerCompare);
+ 	}
+ }
+ 
+ /*
+  * Send a query to sort all column values cast to the Oid passed in a VALUES clause
+  */
+ static bool
+ sortColumns(Oid coltype, struct pivot_field *columns, int nb_cols, int direction)
+ {
+ 	bool retval = false;
+ 	PGresult *res = NULL;
+ 	PQExpBufferData query;
+ 	int i;
+ 	Oid *param_types;
+ 	const char** param_values;
+ 	int* param_lengths;
+ 	int* param_formats;
+ 
+ 	if (nb_cols < 2 || direction==0)
+ 		return true;					/* nothing to sort */
+ 
+ 	param_types = (Oid*) pg_malloc(nb_cols*sizeof(Oid));
+ 	param_values = (const char**) pg_malloc(nb_cols*sizeof(char*));
+ 	param_lengths = (int*) pg_malloc(nb_cols*sizeof(int));
+ 	param_formats = (int*) pg_malloc(nb_cols*sizeof(int));
+ 
+ 	initPQExpBuffer(&query);
+ 
+ 	/*
+ 	 * The query returns the original position of each value in our list,
+ 	 * ordered by its new position. The value itself is not returned.
+ 	 */
+ 	appendPQExpBuffer(&query, "SELECT n FROM (VALUES");
+ 
+ 	for (i=1; i <= nb_cols; i++)
+ 	{
+ 		if (i < nb_cols)
+ 			appendPQExpBuffer(&query, "($%d,%d),", i, i);
+ 		else
+ 		{
+ 			appendPQExpBuffer(&query, "($%d,%d)) AS l(x,n) ORDER BY x", i, i);
+ 			if (direction < 0)
+ 				appendPQExpBuffer(&query, " DESC");
+ 		}
+ 
+ 		param_types[i-1] = coltype;
+ 		param_values[i-1] = columns[i-1].name;
+ 		param_lengths[i-1] = strlen(columns[i-1].name);
+ 		param_formats[i-1] = 0;
+ 	}
+ 
+ 	res = PQexecParams(pset.db,
+ 					   query.data,
+ 					   nb_cols,
+ 					   param_types,
+ 					   param_values,
+ 					   param_lengths,
+ 					   param_formats,
+ 					   0);
+ 
+ 	if (res)
+ 	{
+ 		ExecStatusType status = PQresultStatus(res);
+ 		if (status == PGRES_TUPLES_OK)
+ 		{
+ 			for (i=0; i < PQntuples(res); i++)
+ 			{
+ 				int old_pos = atoi(PQgetvalue(res, i, 0));
+ 
+ 				if (old_pos < 1 || old_pos > nb_cols || i >= nb_cols)
+ 				{
+ 					/*
+ 					 * A position outside of the range is normally impossible.
+ 					 * If this happens, we're facing a malfunctioning or hostile
+ 					 * server or middleware.
+ 					 */
+ 					psql_error(_("Unexpected value when sorting horizontal headers"));
+ 					goto cleanup;
+ 				}
+ 				else
+ 				{
+ 					columns[old_pos-1].rank = i;
+ 				}
+ 			}
+ 		}
+ 		else
+ 		{
+ 			psql_error(_("Query error when sorting horizontal headers: %s"),
+ 					   PQerrorMessage(pset.db));
+ 			goto cleanup;
+ 		}
+ 	}
+ 
+ 	retval = true;
+ 
+ cleanup:
+ 	termPQExpBuffer(&query);
+ 	if (res)
+ 		PQclear(res);
+ 	pg_free(param_types);
+ 	pg_free(param_values);
+ 	pg_free(param_lengths);
+ 	pg_free(param_formats);
+ 	return retval;
+ }
+ 
+ static void
+ printCrosstab(const PGresult *results,
+ 			  int num_columns,
+ 			  struct pivot_field *piv_columns,
+ 			  int field_for_columns,
+ 			  int num_rows,
+ 			  struct pivot_field *piv_rows,
+ 			  int field_for_rows,
+ 			  int field_for_labels)
+ {
+ 	printQueryOpt popt = pset.popt;
+ 	printTableContent cont;
+ 	int	i, j, rn;
+ 	char col_align = 'l';		/* alignment for values inside the grid */
+ 	int* horiz_map;			 	/* map indices from sorted horizontal headers to piv_columns */
+ 	char** allocated_cells; 	/*  Pointers for cell contents that are allocated
+ 								 *  in this function, when cells cannot simply point to
+ 								 *  PQgetvalue(results, ...) */
+ 
+ 	printTableInit(&cont, &popt.topt, popt.title, num_columns+1, num_rows);
+ 
+ 	/* Step 1: set target column names (horizontal header) */
+ 
+ 	/* The name of the first column is kept unchanged by the pivoting */
+ 	printTableAddHeader(&cont,
+ 						PQfname(results, field_for_rows),
+ 						false,
+ 						column_type_alignment(PQftype(results, field_for_rows)));
+ 
+ 	/*
+ 	 * To iterate over piv_columns[] by piv_columns[].rank, create a reverse map
+ 	 *  associating each piv_columns[].rank to its index in piv_columns.
+ 	 *  This avoids an O(N^2) loop later
+ 	 */
+ 	horiz_map = (int*) pg_malloc(sizeof(int) * num_columns);
+ 	for (i = 0; i < num_columns; i++)
+ 	{
+ 		horiz_map[piv_columns[i].rank] = i;
+ 	}
+ 
+ 	/*
+ 	 * In the case of 3 output columns, the contents in the cells are exactly
+ 	 * the contents of the "value" column (3rd column by default), so their
+ 	 * alignment is determined by PQftype(). Otherwise the contents are
+ 	 * made-up strings, so the alignment is 'l'
+ 	 */
+ 	if (PQnfields(results) == 3)
+ 	{
+ 		int colnum;				/* column placed inside the grid */
+ 		/*
+ 		 * find colnum in the permutations of (0,1,2) where colnum is
+ 		 * neither field_for_rows nor field_for_columns
+ 		 */
+ 		switch (field_for_rows)
+ 		{
+ 		case 0:
+ 			colnum = (field_for_columns == 1) ? 2 : 1;
+ 			break;
+ 		case 1:
+ 			colnum = (field_for_columns == 0) ? 2: 0;
+ 			break;
+ 		default:				/* should be always 2 */
+ 			colnum = (field_for_columns == 0) ? 1: 0;
+ 			break;
+ 		}
+ 		col_align = column_type_alignment(PQftype(results, colnum));
+ 	}
+ 	else
+ 		col_align = 'l';
+ 
+ 	for (i = 0; i < num_columns; i++)
+ 	{
+ 		printTableAddHeader(&cont,
+ 						field_for_labels < 0 ?
+ 							piv_columns[horiz_map[i]].name :
+ 							piv_columns[horiz_map[i]].label,
+ 							false,
+ 							col_align);
+ 	}
+ 	pg_free(horiz_map);
+ 
+ 	/* Step 2: set row names in the first output column (vertical header) */
+ 	for (i = 0; i < num_rows; i++)
+ 	{
+ 		int k = piv_rows[i].rank;
+ 		cont.cells[k*(num_columns+1)] = piv_rows[i].name;
+ 		/* Initialize all cells inside the grid to an empty value */
+ 		for (j = 0; j < num_columns; j++)
+ 			cont.cells[k*(num_columns+1)+j+1] = "";
+ 	}
+ 	cont.cellsadded = num_rows * (num_columns+1);
+ 
+ 	allocated_cells = (char**) pg_malloc0(num_rows * num_columns * sizeof(char*));
+ 
+ 	/* Step 3: set all the cells "inside the grid" */
+ 	for (rn = 0; rn < PQntuples(results); rn++)
+ 	{
+ 		char* row_name;
+ 		char* col_name;
+ 		int row_number;
+ 		int col_number;
+ 		struct pivot_field *p;
+ 
+ 		row_number = col_number = -1;
+ 		/* Find target row */
+ 		if (!PQgetisnull(results, rn, field_for_rows))
+ 		{
+ 			row_name = PQgetvalue(results, rn, field_for_rows);
+ 			p = (struct pivot_field*) bsearch(&row_name,
+ 											  piv_rows,
+ 											  num_rows,
+ 											  sizeof(struct pivot_field),
+ 											  headerCompare);
+ 			if (p)
+ 				row_number = p->rank;
+ 		}
+ 
+ 		/* Find target column */
+ 		if (!PQgetisnull(results, rn, field_for_columns))
+ 		{
+ 			col_name = PQgetvalue(results, rn, field_for_columns);
+ 			p = (struct pivot_field*) bsearch(&col_name,
+ 											  piv_columns,
+ 											  num_columns,
+ 											  sizeof(struct pivot_field),
+ 											  headerCompare);
+ 			if (p)
+ 				col_number = p->rank;
+ 		}
+ 
+ 		/* Place value into cell */
+ 		if (col_number>=0 && row_number>=0)
+ 		{
+ 			int idx = 1 + col_number + row_number*(num_columns+1);
+ 			int src_col = 0;			/* column number in source result */
+ 			int k = 0;
+ 
+ 			do {
+ 				char *content;
+ 
+ 				if (PQnfields(results) == 2)
+ 				{
+ 					/*
+ 					  special case: when the source has only 2 columns, use a
+ 					  X (cross/checkmark) for the cell content, and set
+ 					  src_col to a virtual additional column.
+ 					*/
+ 					content = "X";
+ 					src_col = 3;
+ 				}
+ 				else if (src_col == field_for_rows || src_col == field_for_columns
+ 					    || src_col == field_for_labels)
+ 				{
+ 					/*
+ 					  The source values that produce headers are not processed
+ 					  in this loop, only the values that end up inside the grid.
+ 					*/
+ 					src_col++;
+ 					continue;
+ 				}
+ 				else
+ 				{
+ 					content = (!PQgetisnull(results, rn, src_col)) ?
+ 						PQgetvalue(results, rn, src_col) :
+ 						(popt.nullPrint ? popt.nullPrint : "");
+ 				}
+ 
+ 				if (cont.cells[idx] != NULL && cont.cells[idx][0] != '\0')
+ 				{
+ 					/*
+ 					 * Multiple values for the same (row,col) are projected
+ 					 * into the same cell. When this happens, separate the
+ 					 * previous content of the cell from the new value by a
+ 					 * newline.
+ 					 */
+ 					int content_size =
+ 						strlen(cont.cells[idx])
+ 						+ 2 			/* room for [CR],LF or space */
+ 						+ strlen(content)
+ 						+ 1;			/* '\0' */
+ 					char *new_content;
+ 
+ 					/*
+ 					 * idx2 is an index into allocated_cells. It differs from
+ 					 * idx (index into cont.cells), because vertical and
+ 					 * horizontal headers are included in `cont.cells` but
+ 					 * excluded from allocated_cells.
+ 					 */
+ 					int idx2 = (row_number * num_columns) + col_number;
+ 
+ 					if (allocated_cells[idx2] != NULL)
+ 					{
+ 						new_content = pg_realloc(allocated_cells[idx2], content_size);
+ 					}
+ 					else
+ 					{
+ 						/*
+ 						 * At this point, cont.cells[idx] still contains a
+ 						 * PQgetvalue() pointer.  Just after, it will contain
+ 						 * a new pointer maintained in allocated_cells[], and
+ 						 * freed at the end of this function.
+ 						 */
+ 						new_content = pg_malloc(content_size);
+ 						strcpy(new_content, cont.cells[idx]);
+ 					}
+ 					cont.cells[idx] = new_content;
+ 					allocated_cells[idx2] = new_content;
+ 
+ 					/*
+ 					 * Contents that are on adjacent columns in the source results get
+ 					 * separated by one space in the target.
+ 					 * Contents that are on different rows in the source get
+ 					 * separated by newlines in the target.
+ 					 */
+ 					if (k==0)
+ 						strcat(new_content, "\n");
+ 					else
+ 						strcat(new_content, " ");
+ 					strcat(new_content, content);
+ 				}
+ 				else
+ 				{
+ 					cont.cells[idx] = content;
+ 				}
+ 				k++;
+ 				src_col++;
+ 			} while (src_col < PQnfields(results));
+ 		}
+ 	}
+ 
+ 	printTable(&cont, pset.queryFout, false, pset.logfile);
+ 	printTableCleanup(&cont);
+ 
+ 
+ 	for (i=0; i < num_rows * num_columns; i++)
+ 	{
+ 		if (allocated_cells[i] != NULL)
+ 			pg_free(allocated_cells[i]);
+ 	}
+ 
+ 	pg_free(allocated_cells);
+ }
+ 
+ /*
+  * Compare a user-supplied argument against a field name obtained by PQfname(),
+  * which is already case-folded.
+  * If arg is not enclosed in double quotes, pg_strcasecmp applies, otherwise
+  * do a case-sensitive comparison with these rules:
+  * - double quotes enclosing 'arg' are filtered out
+  * - double quotes inside 'arg' are expected to be doubled
+  */
+ static int
+ fieldnameCmp(const char* arg, const char* fieldname)
+ {
+ 	const unsigned char* p = (const unsigned char*) arg;
+ 	const unsigned char* f = (const unsigned char*) fieldname;
+ 	unsigned char c;
+ 
+ 	if (*p++ != '"')
+ 		return pg_strcasecmp(arg, fieldname);
+ 
+ 	while ((c=*p++))
+ 	{
+ 		if (c=='"')
+ 		{
+ 			if (*p=='"')
+ 				p++;			/* skip second quote and continue */
+ 			else if (*p=='\0')
+ 				return *p-*f;		/* p finishes before f or is identical */
+ 
+ 		}
+ 		if (*f=='\0')
+ 			return 1;			/* f finishes before p */
+ 		if (c!=*f)
+ 			return c-*f;
+ 		f++;
+ 	}
+ 	return (*f=='\0') ? 0 : 1;
+ }
+ 
+ 
+ /*
+  * arg can be a number or a column name, possibly quoted (like in an ORDER BY clause)
+  * Returns:
+  *  on success, the 0-based index of the column
+  *  or -1 if the column number or name is not found in the result's structure,
+  *        or if it's ambiguous (arg corresponding to several columns)
+  */
+ static int
+ indexOfColumn(const char* arg, PGresult* res)
+ {
+ 	int idx;
+ 
+ 	if (strspn(arg, "0123456789") == strlen(arg))
+ 	{
+ 		/* if arg contains only digits, it's a column number */
+ 		idx = atoi(arg) - 1;
+ 		if (idx < 0  || idx >= PQnfields(res))
+ 		{
+ 			psql_error(_("Invalid column number: %s\n"), arg);
+ 			return -1;
+ 		}
+ 	}
+ 	else
+ 	{
+ 		int i;
+ 		idx = -1;
+ 		for (i=0; i < PQnfields(res); i++)
+ 		{
+ 			if (fieldnameCmp(arg, PQfname(res, i)) == 0)
+ 			{
+ 				if (idx>=0)
+ 				{
+ 					/* if another idx was already found for the same name */
+ 					psql_error(_("Ambiguous column name: %s\n"), arg);
+ 					return -1;
+ 				}
+ 				idx = i;
+ 			}
+ 		}
+ 		if (idx == -1)
+ 		{
+ 			psql_error(_("Invalid column name: %s\n"), arg);
+ 			return -1;
+ 		}
+ 	}
+ 	return idx;
+ }
+ 
+ bool
+ PrintResultsInCrossTab(PGresult* res,
+ 					   const char* opt_field_for_rows,    /* COLV or null */
+ 					   const char* opt_field_for_columns, /* [-+]COLH or null */
+ 					   const char* opt_field_for_labels)  /* COLL or NULL */
+ {
+ 	int		rn;
+ 	struct pivot_field	*piv_columns = NULL;
+ 	struct pivot_field	*piv_rows = NULL;
+ 	int		num_columns = 0;
+ 	int		num_rows = 0;
+ 	bool 	retval = false;
+ 	int		columns_sort_direction = 0; /* 1:ascending, 0:none, -1:descending */
+ 	int		field_for_labels;
+ 
+ 	/* 0-based index of the field whose distinct values will become COLUMN headers */
+ 	int		field_for_columns;
+ 
+ 	/* 0-based index of the field whose distinct values will become ROW headers */
+ 	int		field_for_rows;
+ 
+ 	if (PQresultStatus(res) != PGRES_TUPLES_OK)
+ 		goto error_return;
+ 
+ 	if (PQnfields(res) < 2)
+ 	{
+ 		psql_error(_("The query must return at least two columns to be shown in crosstab\n"));
+ 		goto error_return;
+ 	}
+ 
+ 	if (PQnfields(res) < 3 && opt_field_for_labels != NULL)
+ 	{
+ 		psql_error(_("The query must return at least three columns to be shown in crosstab\n"));
+ 		goto error_return;
+ 	}
+ 
+ 	field_for_rows = (opt_field_for_rows != NULL)
+ 		? indexOfColumn(opt_field_for_rows, res)
+ 		: 0;
+ 
+ 	if (field_for_rows < 0)
+ 		goto error_return;
+ 
+ 	if (opt_field_for_columns == NULL)
+ 		field_for_columns = 1;
+ 	else
+ 	{
+ 		/*
+ 		 * descending sort is requested if the column reference is
+ 		 * preceded with a minus sign
+ 		 */
+ 		if (*opt_field_for_columns == '-')
+ 		{
+ 			columns_sort_direction = -1;
+ 			opt_field_for_columns++;
+ 		}
+ 		else if (*opt_field_for_columns == '+')
+ 		{
+ 			columns_sort_direction = 1;
+ 			opt_field_for_columns++;
+ 		}
+ 		field_for_columns = indexOfColumn(opt_field_for_columns, res);
+ 		if (field_for_columns < 0)
+ 			goto error_return;
+ 	}
+ 
+ 
+ 	if (field_for_columns == field_for_rows)
+ 	{
+ 		psql_error(_("The same column cannot be used for both vertical and horizontal headers\n"));
+ 		goto error_return;
+ 	}
+ 
+ 	if (opt_field_for_labels)
+ 	{
+ 		field_for_labels = indexOfColumn(opt_field_for_labels, res);
+ 		if (field_for_labels == field_for_columns || field_for_labels == field_for_rows)
+ 		{
+ 			psql_error(_("The same column cannot be used for both vertical and horizontal headers or label\n"));
+ 			goto error_return;
+ 		}
+ 	}
+ 	else
+ 		field_for_labels = -1;
+ 
+ 	/*
+ 	 * First pass: accumulate row names and column names, each into their
+ 	 * array. Use client-side sort but only to build the set of DISTINCT
+ 	 * values. The final order displayed depends only on server-side
+ 	 * sorts.
+ 	 */
+ 	for (rn = 0; rn < PQntuples(res); rn++)
+ 	{
+ 		if (!PQgetisnull(res, rn, field_for_rows))
+ 		{
+ 			accumHeader(PQgetvalue(res, rn, field_for_rows), 
+ 				    NULL,
+ 						&num_rows,
+ 						&piv_rows,
+ 						rn);
+ 		}
+ 
+ 		if (!PQgetisnull(res, rn, field_for_columns))
+ 		{
+ 			accumHeader(PQgetvalue(res, rn, field_for_columns),
+ 				    field_for_labels >= 0 ? PQgetvalue(res, rn, field_for_labels) : NULL,
+ 						&num_columns,
+ 						&piv_columns,
+ 						rn);
+ 			if (num_columns > 1600)
+ 			{
+ 				psql_error(_("Maximum number of columns (1600) exceeded\n"));
+ 				goto error_return;
+ 			}
+ 		}
+ 	}
+ 
+ 	/*
+ 	 * Second pass: sort the list of target columns on the server.
+ 	 */
+ 	if (!sortColumns(PQftype(res, field_for_columns),
+ 					 piv_columns,
+ 					 num_columns,
+ 					 columns_sort_direction))
+ 		goto error_return;
+ 
+ 	/*
+ 	 * Third pass: print the crosstab'ed results.
+ 	 */
+ 	printCrosstab(res,
+ 				  num_columns,
+ 				  piv_columns,
+ 				  field_for_columns,
+ 				  num_rows,
+ 				  piv_rows,
+ 				  field_for_rows,
+ 				  field_for_labels);
+ 
+ 	retval = true;
+ 
+ error_return:
+ 	pg_free(piv_columns);
+ 	pg_free(piv_rows);
+ 
+ 	return retval;
+ }
diff --git a/src/bin/psql/crosstabview.h b/src/bin/psql/crosstabview.h
new file mode 100644
index ...58cd33b
*** a/src/bin/psql/crosstabview.h
--- b/src/bin/psql/crosstabview.h
***************
*** 0 ****
--- 1,35 ----
+ /*
+  * psql - the PostgreSQL interactive terminal
+  *
+  * Copyright (c) 2000-2015, PostgreSQL Global Development Group
+  *
+  * src/bin/psql/crosstabview.h
+  */
+ 
+ #ifndef CROSSTABVIEW_H
+ #define CROSSTABVIEW_H
+ 
+ struct pivot_field
+ {
+ 	/* Pointer obtained from PGgetvalue() for colV or colH */
+ 	char*	name;
+ 	char*	label;
+ 
+ 	/* Rank of the field in its list, starting at 0.
+ 	 * - For headers stacked vertically, rank=N means it's the
+ 	 *   Nth distinct field encountered when looping through rows
+ 	 *   in their initial order.
+ 	 * - For headers stacked horizontally, rank is obtained
+ 	 *   by server-side sorting in sortColumns()
+ 	 */
+ 	int		rank;
+ };
+ 
+ /* prototypes */
+ extern bool
+ PrintResultsInCrossTab(PGresult* res,
+ 					   const char* opt_field_for_rows,
+ 					   const char* opt_field_for_columns,
+ 					   const char* opt_field_for_labels);
+ 
+ #endif   /* CROSSTABVIEW_H */
diff --git a/src/bin/psql/help.c b/src/bin/psql/help.c
new file mode 100644
index 5b63e76..e4a9ddf
*** a/src/bin/psql/help.c
--- b/src/bin/psql/help.c
*************** slashUsage(unsigned short int pager)
*** 175,180 ****
--- 175,181 ----
  	fprintf(output, _("  \\g [FILE] or ;         execute query (and send results to file or |pipe)\n"));
  	fprintf(output, _("  \\gset [PREFIX]         execute query and store results in psql variables\n"));
  	fprintf(output, _("  \\q                     quit psql\n"));
+ 	fprintf(output, _("  \\crosstabview [V H L]  execute query and display results in crosstab\n"));
  	fprintf(output, _("  \\watch [SEC]           execute query every SEC seconds\n"));
  	fprintf(output, "\n");
  
diff --git a/src/bin/psql/print.c b/src/bin/psql/print.c
new file mode 100644
index 190f2bc..4e4b5e7
*** a/src/bin/psql/print.c
--- b/src/bin/psql/print.c
*************** printQuery(const PGresult *result, const
*** 3239,3268 ****
  
  	for (i = 0; i < cont.ncolumns; i++)
  	{
- 		char		align;
- 		Oid			ftype = PQftype(result, i);
- 
- 		switch (ftype)
- 		{
- 			case INT2OID:
- 			case INT4OID:
- 			case INT8OID:
- 			case FLOAT4OID:
- 			case FLOAT8OID:
- 			case NUMERICOID:
- 			case OIDOID:
- 			case XIDOID:
- 			case CIDOID:
- 			case CASHOID:
- 				align = 'r';
- 				break;
- 			default:
- 				align = 'l';
- 				break;
- 		}
- 
  		printTableAddHeader(&cont, PQfname(result, i),
! 							opt->translate_header, align);
  	}
  
  	/* set cells */
--- 3239,3247 ----
  
  	for (i = 0; i < cont.ncolumns; i++)
  	{
  		printTableAddHeader(&cont, PQfname(result, i),
! 							opt->translate_header,
! 							column_type_alignment(PQftype(result, i)));
  	}
  
  	/* set cells */
*************** printQuery(const PGresult *result, const
*** 3304,3309 ****
--- 3283,3313 ----
  	printTableCleanup(&cont);
  }
  
+ char
+ column_type_alignment(Oid ftype)
+ {
+ 	char		align;
+ 
+ 	switch (ftype)
+ 	{
+ 		case INT2OID:
+ 		case INT4OID:
+ 		case INT8OID:
+ 		case FLOAT4OID:
+ 		case FLOAT8OID:
+ 		case NUMERICOID:
+ 		case OIDOID:
+ 		case XIDOID:
+ 		case CIDOID:
+ 		case CASHOID:
+ 			align = 'r';
+ 			break;
+ 		default:
+ 			align = 'l';
+ 			break;
+ 	}
+ 	return align;
+ }
  
  void
  setDecimalLocale(void)
diff --git a/src/bin/psql/print.h b/src/bin/psql/print.h
new file mode 100644
index df514cf..409f3e5
*** a/src/bin/psql/print.h
--- b/src/bin/psql/print.h
*************** extern FILE *PageOutput(int lines, const
*** 171,177 ****
  extern void ClosePager(FILE *pagerpipe);
  
  extern void html_escaped_print(const char *in, FILE *fout);
! 
  extern void printTableInit(printTableContent *const content,
  			   const printTableOpt *opt, const char *title,
  			   const int ncolumns, const int nrows);
--- 171,177 ----
  extern void ClosePager(FILE *pagerpipe);
  
  extern void html_escaped_print(const char *in, FILE *fout);
! extern char column_type_alignment(Oid);
  extern void printTableInit(printTableContent *const content,
  			   const printTableOpt *opt, const char *title,
  			   const int ncolumns, const int nrows);
diff --git a/src/bin/psql/settings.h b/src/bin/psql/settings.h
new file mode 100644
index 1885bb1..429d6fb
*** a/src/bin/psql/settings.h
--- b/src/bin/psql/settings.h
*************** typedef struct _psqlSettings
*** 90,95 ****
--- 90,99 ----
  
  	char	   *gfname;			/* one-shot file output argument for \g */
  	char	   *gset_prefix;	/* one-shot prefix argument for \gset */
+ 	bool		crosstabview_output;  /* one-shot request to print results in crosstab */
+ 	char		*crosstabview_col_V;  /* one-shot \crosstabview 1st argument */
+ 	char		*crosstabview_col_H;  /* one-shot \crosstabview 2nd argument */
+ 	char		*crosstabview_col_L;  /* one-shot \crosstabview 3nd argument */
  
  	bool		notty;			/* stdin or stdout is not a tty (as determined
  								 * on startup) */
diff --git a/src/bin/psql/tab-complete.c b/src/bin/psql/tab-complete.c
new file mode 100644
index b58ec14..0f79e0a
*** a/src/bin/psql/tab-complete.c
--- b/src/bin/psql/tab-complete.c
*************** psql_completion(const char *text, int st
*** 936,943 ****
  
  	static const char *const backslash_commands[] = {
  		"\\a", "\\connect", "\\conninfo", "\\C", "\\cd", "\\copy", "\\copyright",
! 		"\\d", "\\da", "\\db", "\\dc", "\\dC", "\\dd", "\\ddp", "\\dD",
! 		"\\des", "\\det", "\\deu", "\\dew", "\\dE", "\\df",
  		"\\dF", "\\dFd", "\\dFp", "\\dFt", "\\dg", "\\di", "\\dl", "\\dL",
  		"\\dm", "\\dn", "\\do", "\\dO", "\\dp", "\\drds", "\\ds", "\\dS",
  		"\\dt", "\\dT", "\\dv", "\\du", "\\dx", "\\dy",
--- 936,943 ----
  
  	static const char *const backslash_commands[] = {
  		"\\a", "\\connect", "\\conninfo", "\\C", "\\cd", "\\copy", "\\copyright",
! 		"\\crosstabview", "\\d", "\\da", "\\db", "\\dc", "\\dC", "\\dd", "\\ddp",
! 		"\\dD", "\\des", "\\det", "\\deu", "\\dew", "\\dE", "\\df",
  		"\\dF", "\\dFd", "\\dFp", "\\dFt", "\\dg", "\\di", "\\dl", "\\dL",
  		"\\dm", "\\dn", "\\do", "\\dO", "\\dp", "\\drds", "\\ds", "\\dS",
  		"\\dt", "\\dT", "\\dv", "\\du", "\\dx", "\\dy",

diff --git a/doc/src/sgml/ref/psql-ref.sgml b/doc/src/sgml/ref/psql-ref.sgml
new file mode 100644
index 47e9da2..a45f4b8
*** a/doc/src/sgml/ref/psql-ref.sgml
--- b/doc/src/sgml/ref/psql-ref.sgml
*************** lo_import 152801
*** 2461,2466 ****
--- 2461,2555 ----
          </listitem>
        </varlistentry>
  
+       <varlistentry>
+         <term><literal>\crosstabview [ <replaceable class="parameter">colV</replaceable>  [-|+]<replaceable class="parameter">colH</replaceable> ] </literal></term>
+         <listitem>
+         <para>
+         Execute the current query buffer (like <literal>\g</literal>) and shows the results
+         inside a crosstab grid. The output column <replaceable class="parameter">colV</replaceable>
+         becomes a vertical header and the output column
+         <replaceable class="parameter">colH</replaceable> becomes a horizontal header.
+         The results for the other output columns are projected inside the grid.
+         </para>
+ 
+         <para>
+         <replaceable class="parameter">colV</replaceable>
+         and <replaceable class="parameter">colH</replaceable> can indicate a
+         column position (starting at 1), or a column name. Normal case folding
+         and quoting rules apply on column names. By default,
+         <replaceable class="parameter">colV</replaceable> is column 1
+         and <replaceable class="parameter">colH</replaceable> is column 2.
+         A query having only one output column cannot be viewed in crosstab, and
+         <replaceable class="parameter">colH</replaceable> must differ from
+         <replaceable class="parameter">colV</replaceable>.
+         </para>
+ 
+         <para>
+         The vertical header, displayed as the leftmost column,
+         contains the set of all distinct values found in
+         column <replaceable class="parameter">colV</replaceable>, in the order
+         of their first appearance in the query results.
+         </para>
+         <para>
+         The horizontal header, displayed as the first row,
+         contains the set of all distinct non-null values found in
+         column <replaceable class="parameter">colH</replaceable>.  They come
+         by default in their order of appearance in the query results, or in ascending
+         order if a plus (+) sign precedes <replaceable class="parameter">colH</replaceable>,
+         or in descending order if it's a minus (-) sign.
+         </para>
+ 
+         <para>
+         The query results being tuples of <literal>N</literal> columns
+         (including <replaceable class="parameter">colV</replaceable> and
+         <replaceable class="parameter">colH</replaceable>),
+         for each distinct value <literal>x</literal> of
+         <replaceable class="parameter">colH</replaceable>
+         and each distinct value <literal>y</literal> of
+         <replaceable class="parameter">colV</replaceable>,
+         a cell located at the intersection <literal>(x,y)</literal> in the grid
+         has contents determined by these rules:
+         <itemizedlist>
+         <listitem>
+         <para>
+          if there is no corresponding row in the results such that the value
+          for <replaceable class="parameter">colH</replaceable>
+          is <literal>x</literal> and the value
+          for <replaceable class="parameter">colV</replaceable>
+          is <literal>y</literal>, the cell is empty.
+         </para>
+         </listitem>
+ 
+         <listitem>
+         <para>
+          if there is exactly one row such that the value
+          for <replaceable class="parameter">colH</replaceable>
+          is <literal>x</literal> and the value
+          for <replaceable class="parameter">colV</replaceable>
+          is <literal>y</literal>, then the <literal>N-2</literal> other
+          columns are displayed in the cell, separated between each other by
+          a space character if needed.
+ 
+          If <literal>N=2</literal>, the letter <literal>X</literal> is displayed in the cell as
+          if a virtual third column contained that character.
+         </para>
+         </listitem>
+ 
+         <listitem>
+         <para>
+          if there are several corresponding rows, the behavior is identical to one row
+          except that the values coming from different rows are stacked
+          vertically, rows being separated by newline characters inside
+          the same cell.
+         </para>
+         </listitem>
+ 
+         </itemizedlist>
+         </para>
+ 
+         </listitem>
+       </varlistentry>
+ 
  
        <varlistentry>
          <term><literal>\s [ <replaceable class="parameter">filename</replaceable> ]</literal></term>
diff --git a/src/bin/psql/Makefile b/src/bin/psql/Makefile
new file mode 100644
index f1336d5..9cb0c4a
*** a/src/bin/psql/Makefile
--- b/src/bin/psql/Makefile
*************** override CPPFLAGS := -I. -I$(srcdir) -I$
*** 23,29 ****
  OBJS=	command.o common.o help.o input.o stringutils.o mainloop.o copy.o \
  	startup.o prompt.o variables.o large_obj.o print.o describe.o \
  	tab-complete.o mbprint.o dumputils.o keywords.o kwlookup.o \
! 	sql_help.o \
  	$(WIN32RES)
  
  
--- 23,29 ----
  OBJS=	command.o common.o help.o input.o stringutils.o mainloop.o copy.o \
  	startup.o prompt.o variables.o large_obj.o print.o describe.o \
  	tab-complete.o mbprint.o dumputils.o keywords.o kwlookup.o \
! 	sql_help.o crosstabview.o \
  	$(WIN32RES)
  
  
diff --git a/src/bin/psql/command.c b/src/bin/psql/command.c
new file mode 100644
index cf6876b..c743f57
*** a/src/bin/psql/command.c
--- b/src/bin/psql/command.c
***************
*** 46,51 ****
--- 46,52 ----
  #include "mainloop.h"
  #include "print.h"
  #include "psqlscan.h"
+ #include "crosstabview.h"
  #include "settings.h"
  #include "variables.h"
  
*************** exec_command(const char *cmd,
*** 1081,1086 ****
--- 1082,1119 ----
  		free(pw2);
  	}
  
+ 	/* \crosstabview -- execute a query and display results in crosstab */
+ 	else if (strcmp(cmd, "crosstabview") == 0)
+ 	{
+ 		char	*opt1,
+ 				*opt2,
+ 				*opt3;
+ 
+ 		opt1 = psql_scan_slash_option(scan_state,
+ 									  OT_NORMAL, NULL, false);
+ 		opt2 = psql_scan_slash_option(scan_state,
+ 									  OT_NORMAL, NULL, false);
+ 		opt3 = psql_scan_slash_option(scan_state,
+ 									  OT_NORMAL, NULL, false);
+ 
+ 		if (opt1 && !opt2)
+ 		{
+ 			psql_error(_("\\%s: missing second argument\n"), cmd);
+ 			success = false;
+ 		}
+ 		else
+ 		{
+ 			pset.crosstabview_col_V = opt1 ? pg_strdup(opt1) : NULL;
+ 			pset.crosstabview_col_H = opt2 ? pg_strdup(opt2) : NULL;
+ 			pset.crosstabview_col_O = opt3 ? pg_strdup(opt3) : NULL;
+ 			pset.crosstabview_output = true;
+ 			status = PSQL_CMD_SEND;
+ 		}
+ 
+ 		free(opt1);
+ 		free(opt2);
+ 	}
+ 
  	/* \prompt -- prompt and set variable */
  	else if (strcmp(cmd, "prompt") == 0)
  	{
diff --git a/src/bin/psql/common.c b/src/bin/psql/common.c
new file mode 100644
index a287eee..26cd233
*** a/src/bin/psql/common.c
--- b/src/bin/psql/common.c
***************
*** 24,29 ****
--- 24,30 ----
  #include "command.h"
  #include "copy.h"
  #include "mbprint.h"
+ #include "crosstabview.h"
  
  
  static bool ExecQueryUsingCursor(const char *query, double *elapsed_msec);
*************** SendQuery(const char *query)
*** 1076,1085 ****
  
  		/* but printing results isn't: */
  		if (OK && results)
! 			OK = PrintQueryResults(results);
  	}
  	else
  	{
  		/* Fetch-in-segments mode */
  		OK = ExecQueryUsingCursor(query, &elapsed_msec);
  		ResetCancelConn();
--- 1077,1102 ----
  
  		/* but printing results isn't: */
  		if (OK && results)
! 		{
! 			if (pset.crosstabview_output)
! 				OK = PrintResultsInCrossTab(results,
! 											pset.crosstabview_col_V,
! 											pset.crosstabview_col_H,
! 											pset.crosstabview_col_O);
! 			else
! 				OK = PrintQueryResults(results);
! 		}
  	}
  	else
  	{
+ 		if (pset.crosstabview_output)
+ 		{
+ 			psql_error("\\crosstabview cannot be executed since active FETCH_COUNT = %d\n",
+ 					pset.fetch_count);
+ 			OK = false;
+ 			goto sendquery_cleanup;
+ 		}
+ 
  		/* Fetch-in-segments mode */
  		OK = ExecQueryUsingCursor(query, &elapsed_msec);
  		ResetCancelConn();
*************** sendquery_cleanup:
*** 1192,1197 ****
--- 1209,1231 ----
  		pset.gset_prefix = NULL;
  	}
  
+ 	pset.crosstabview_output = false;
+ 	if (pset.crosstabview_col_V)
+ 	{
+ 		free(pset.crosstabview_col_V);
+ 		pset.crosstabview_col_V = NULL;
+ 	}
+ 	if (pset.crosstabview_col_H)
+ 	{
+ 		free(pset.crosstabview_col_H);
+ 		pset.crosstabview_col_H = NULL;
+ 	}
+ 	if (pset.crosstabview_col_O)
+ 	{
+ 		free(pset.crosstabview_col_O);
+ 		pset.crosstabview_col_O = NULL;
+ 	}
+ 
  	return OK;
  }
  
diff --git a/src/bin/psql/crosstabview.c b/src/bin/psql/crosstabview.c
new file mode 100644
index ...c11c628
*** a/src/bin/psql/crosstabview.c
--- b/src/bin/psql/crosstabview.c
***************
*** 0 ****
--- 1,749 ----
+ /*
+  * psql - the PostgreSQL interactive terminal
+  *
+  * Copyright (c) 2000-2015, PostgreSQL Global Development Group
+  *
+  * src/bin/psql/crosstabview.c
+  */
+ 
+ 
+ #include "common.h"
+ #include "pqexpbuffer.h"
+ #include "crosstabview.h"
+ #include "settings.h"
+ 
+ #include "catalog/pg_type.h"
+ 
+ #include <string.h>
+ 
+ static int
+ headerCompare(const void *a, const void *b)
+ {
+ 	return strcmp( ((struct pivot_field*)a)->name,
+ 				   ((struct pivot_field*)b)->name);
+ }
+ 
+ static void
+ accumHeader(char* name, char* outer_rank, int* count, struct pivot_field **sorted_tab, int row_number)
+ {
+ 	struct pivot_field *p;
+ 
+ 	/*
+ 	 * Search for name in sorted_tab. If it doesn't exist, insert it,
+ 	 * otherwise do nothing.
+ 	 */
+ 
+ 	if (*count >= 1)
+ 	{
+ 		p = (struct pivot_field*) bsearch(&name,
+ 										  *sorted_tab,
+ 										  *count,
+ 										  sizeof(struct pivot_field),
+ 										  headerCompare);
+ 	}
+ 	else
+ 		p=NULL;
+ 
+ 	if (!p)
+ 	{
+ 		*sorted_tab = pg_realloc(*sorted_tab, sizeof(struct pivot_field) * (1+*count));
+ 		(*sorted_tab)[*count].name = name;
+ 		(*sorted_tab)[*count].outer_rank = outer_rank ? strtod(outer_rank, NULL) : -1.0;
+ 		(*sorted_tab)[*count].rank = *count;
+ 		(*count)++;
+ 
+ 		qsort(*sorted_tab,
+ 			  *count,
+ 			  sizeof(struct pivot_field),
+ 			  headerCompare);
+ 	}
+ }
+ 
+ /*
+  * Auxilary structure using for sorting only
+  */
+ struct p_rank
+ {
+ 	double		outer_rank;
+ 	int	old_pos;
+ };
+ 
+ static int
+ RankCompare(const void *a, const void *b)
+ {
+ 	return ((struct p_rank*)a)->outer_rank - ((struct p_rank*)b)->outer_rank ;
+ }
+ 
+ static int
+ RankCompareDesc(const void *a, const void *b)
+ {
+ 	return ((struct p_rank*) b)->outer_rank - ((struct p_rank*) a)->outer_rank;
+ }
+ 
+ 
+ /*
+  * Resort header by rank, ensure uniq outer ranks
+  */
+ static bool
+ sortColumnsByRank(struct pivot_field *columns, int nb_cols, int direction)
+ {
+ 	int		i;
+ 	struct p_rank	*p_ranks;
+ 	bool		retval = true;
+ 
+ 	p_ranks = (struct p_rank *) pg_malloc(nb_cols * sizeof(struct p_rank));
+ 
+ 	for (i = 0; i < nb_cols; i++)
+ 	{
+ 		p_ranks[i].outer_rank = columns[i].outer_rank;
+ 		p_ranks[i].old_pos = i;
+ 	}
+ 
+ 	if (direction >= 0)
+ 		qsort(p_ranks,
+ 			  nb_cols,
+ 			  sizeof(struct p_rank),
+ 			  RankCompare);
+ 	else
+ 		qsort(p_ranks,
+ 			  nb_cols,
+ 			  sizeof(struct p_rank),
+ 			  RankCompareDesc);
+ 
+ 	for (i = 0; i < nb_cols; i++)
+ 	{
+ 		/* two adjecent outer sorted ranks should be different */
+ 		if (i > 0 && p_ranks[i].outer_rank == p_ranks[i - 1].outer_rank)
+ 		{
+ 			psql_error("Outer ranks are not unique.");
+ 			goto cleanup;
+ 		}
+ 
+ 		columns[p_ranks[i].old_pos].rank = i;
+ 	}
+ 
+ 	retval = true;
+ 
+ cleanup:
+ 
+ 	pg_free(p_ranks);
+ 
+ 	return retval;
+ }
+ 
+ /*
+  * Send a query to sort all column values cast to the Oid passed in a VALUES clause
+  */
+ static bool
+ sortColumns(Oid coltype, struct pivot_field *columns, int nb_cols, int direction)
+ {
+ 	bool retval = false;
+ 	PGresult *res = NULL;
+ 	PQExpBufferData query;
+ 	int i;
+ 	Oid *param_types;
+ 	const char** param_values;
+ 	int* param_lengths;
+ 	int* param_formats;
+ 
+ 	if (nb_cols < 2 || direction==0)
+ 		return true;					/* nothing to sort */
+ 
+ 	param_types = (Oid*) pg_malloc(nb_cols*sizeof(Oid));
+ 	param_values = (const char**) pg_malloc(nb_cols*sizeof(char*));
+ 	param_lengths = (int*) pg_malloc(nb_cols*sizeof(int));
+ 	param_formats = (int*) pg_malloc(nb_cols*sizeof(int));
+ 
+ 	initPQExpBuffer(&query);
+ 
+ 	/*
+ 	 * The query returns the original position of each value in our list,
+ 	 * ordered by its new position. The value itself is not returned.
+ 	 */
+ 	appendPQExpBuffer(&query, "SELECT n FROM (VALUES");
+ 
+ 	for (i=1; i <= nb_cols; i++)
+ 	{
+ 		if (i < nb_cols)
+ 			appendPQExpBuffer(&query, "($%d,%d),", i, i);
+ 		else
+ 		{
+ 			appendPQExpBuffer(&query, "($%d,%d)) AS l(x,n) ORDER BY x", i, i);
+ 			if (direction < 0)
+ 				appendPQExpBuffer(&query, " DESC");
+ 		}
+ 
+ 		param_types[i-1] = coltype;
+ 		param_values[i-1] = columns[i-1].name;
+ 		param_lengths[i-1] = strlen(columns[i-1].name);
+ 		param_formats[i-1] = 0;
+ 	}
+ 
+ 	res = PQexecParams(pset.db,
+ 					   query.data,
+ 					   nb_cols,
+ 					   param_types,
+ 					   param_values,
+ 					   param_lengths,
+ 					   param_formats,
+ 					   0);
+ 
+ 	if (res)
+ 	{
+ 		ExecStatusType status = PQresultStatus(res);
+ 		if (status == PGRES_TUPLES_OK)
+ 		{
+ 			for (i=0; i < PQntuples(res); i++)
+ 			{
+ 				int old_pos = atoi(PQgetvalue(res, i, 0));
+ 
+ 				if (old_pos < 1 || old_pos > nb_cols || i >= nb_cols)
+ 				{
+ 					/*
+ 					 * A position outside of the range is normally impossible.
+ 					 * If this happens, we're facing a malfunctioning or hostile
+ 					 * server or middleware.
+ 					 */
+ 					psql_error(_("Unexpected value when sorting horizontal headers"));
+ 					goto cleanup;
+ 				}
+ 				else
+ 				{
+ 					columns[old_pos-1].rank = i;
+ 				}
+ 			}
+ 		}
+ 		else
+ 		{
+ 			psql_error(_("Query error when sorting horizontal headers: %s"),
+ 					   PQerrorMessage(pset.db));
+ 			goto cleanup;
+ 		}
+ 	}
+ 
+ 	retval = true;
+ 
+ cleanup:
+ 	termPQExpBuffer(&query);
+ 	if (res)
+ 		PQclear(res);
+ 	pg_free(param_types);
+ 	pg_free(param_values);
+ 	pg_free(param_lengths);
+ 	pg_free(param_formats);
+ 	return retval;
+ }
+ 
+ static void
+ printCrosstab(const PGresult *results,
+ 			  int num_columns,
+ 			  struct pivot_field *piv_columns,
+ 			  int field_for_columns,
+ 			  int num_rows,
+ 			  struct pivot_field *piv_rows,
+ 			  int field_for_rows,
+ 			  int field_for_ranks)
+ {
+ 	printQueryOpt popt = pset.popt;
+ 	printTableContent cont;
+ 	int	i, j, rn;
+ 	char col_align = 'l';		/* alignment for values inside the grid */
+ 	int* horiz_map;			 	/* map indices from sorted horizontal headers to piv_columns */
+ 	char** allocated_cells; 	/*  Pointers for cell contents that are allocated
+ 								 *  in this function, when cells cannot simply point to
+ 								 *  PQgetvalue(results, ...) */
+ 
+ 	printTableInit(&cont, &popt.topt, popt.title, num_columns+1, num_rows);
+ 
+ 	/* Step 1: set target column names (horizontal header) */
+ 
+ 	/* The name of the first column is kept unchanged by the pivoting */
+ 	printTableAddHeader(&cont,
+ 						PQfname(results, field_for_rows),
+ 						false,
+ 						column_type_alignment(PQftype(results, field_for_rows)));
+ 
+ 	/*
+ 	 * To iterate over piv_columns[] by piv_columns[].rank, create a reverse map
+ 	 *  associating each piv_columns[].rank to its index in piv_columns.
+ 	 *  This avoids an O(N^2) loop later
+ 	 */
+ 	horiz_map = (int*) pg_malloc(sizeof(int) * num_columns);
+ 	for (i = 0; i < num_columns; i++)
+ 	{
+ 		horiz_map[piv_columns[i].rank] = i;
+ 	}
+ 
+ 	/*
+ 	 * In the case of 3 output columns, the contents in the cells are exactly
+ 	 * the contents of the "value" column (3rd column by default), so their
+ 	 * alignment is determined by PQftype(). Otherwise the contents are
+ 	 * made-up strings, so the alignment is 'l'
+ 	 */
+ 	if (PQnfields(results) == 3)
+ 	{
+ 		int colnum;				/* column placed inside the grid */
+ 		/*
+ 		 * find colnum in the permutations of (0,1,2) where colnum is
+ 		 * neither field_for_rows nor field_for_columns
+ 		 */
+ 		switch (field_for_rows)
+ 		{
+ 		case 0:
+ 			colnum = (field_for_columns == 1) ? 2 : 1;
+ 			break;
+ 		case 1:
+ 			colnum = (field_for_columns == 0) ? 2: 0;
+ 			break;
+ 		default:				/* should be always 2 */
+ 			colnum = (field_for_columns == 0) ? 1: 0;
+ 			break;
+ 		}
+ 		col_align = column_type_alignment(PQftype(results, colnum));
+ 	}
+ 	else
+ 		col_align = 'l';
+ 
+ 	for (i = 0; i < num_columns; i++)
+ 	{
+ 		printTableAddHeader(&cont,
+ 							piv_columns[horiz_map[i]].name,
+ 							false,
+ 							col_align);
+ 	}
+ 	pg_free(horiz_map);
+ 
+ 	/* Step 2: set row names in the first output column (vertical header) */
+ 	for (i = 0; i < num_rows; i++)
+ 	{
+ 		int k = piv_rows[i].rank;
+ 		cont.cells[k*(num_columns+1)] = piv_rows[i].name;
+ 		/* Initialize all cells inside the grid to an empty value */
+ 		for (j = 0; j < num_columns; j++)
+ 			cont.cells[k*(num_columns+1)+j+1] = "";
+ 	}
+ 	cont.cellsadded = num_rows * (num_columns+1);
+ 
+ 	allocated_cells = (char**) pg_malloc0(num_rows * num_columns * sizeof(char*));
+ 
+ 	/* Step 3: set all the cells "inside the grid" */
+ 	for (rn = 0; rn < PQntuples(results); rn++)
+ 	{
+ 		char* row_name;
+ 		char* col_name;
+ 		int row_number;
+ 		int col_number;
+ 		struct pivot_field *p;
+ 
+ 		row_number = col_number = -1;
+ 		/* Find target row */
+ 		if (!PQgetisnull(results, rn, field_for_rows))
+ 		{
+ 			row_name = PQgetvalue(results, rn, field_for_rows);
+ 			p = (struct pivot_field*) bsearch(&row_name,
+ 											  piv_rows,
+ 											  num_rows,
+ 											  sizeof(struct pivot_field),
+ 											  headerCompare);
+ 			if (p)
+ 				row_number = p->rank;
+ 		}
+ 
+ 		/* Find target column */
+ 		if (!PQgetisnull(results, rn, field_for_columns))
+ 		{
+ 			col_name = PQgetvalue(results, rn, field_for_columns);
+ 			p = (struct pivot_field*) bsearch(&col_name,
+ 											  piv_columns,
+ 											  num_columns,
+ 											  sizeof(struct pivot_field),
+ 											  headerCompare);
+ 			if (p)
+ 				col_number = p->rank;
+ 		}
+ 
+ 		/* Place value into cell */
+ 		if (col_number>=0 && row_number>=0)
+ 		{
+ 			int idx = 1 + col_number + row_number*(num_columns+1);
+ 			int src_col = 0;			/* column number in source result */
+ 			int k = 0;
+ 
+ 			do {
+ 				char *content;
+ 
+ 				if (PQnfields(results) == 2)
+ 				{
+ 					/*
+ 					  special case: when the source has only 2 columns, use a
+ 					  X (cross/checkmark) for the cell content, and set
+ 					  src_col to a virtual additional column.
+ 					*/
+ 					content = "X";
+ 					src_col = 3;
+ 				}
+ 				else if (src_col == field_for_rows || src_col == field_for_columns
+ 					    || src_col == field_for_ranks)
+ 				{
+ 					/*
+ 					  The source values that produce headers are not processed
+ 					  in this loop, only the values that end up inside the grid.
+ 					*/
+ 					src_col++;
+ 					continue;
+ 				}
+ 				else
+ 				{
+ 					content = (!PQgetisnull(results, rn, src_col)) ?
+ 						PQgetvalue(results, rn, src_col) :
+ 						(popt.nullPrint ? popt.nullPrint : "");
+ 				}
+ 
+ 				if (cont.cells[idx] != NULL && cont.cells[idx][0] != '\0')
+ 				{
+ 					/*
+ 					 * Multiple values for the same (row,col) are projected
+ 					 * into the same cell. When this happens, separate the
+ 					 * previous content of the cell from the new value by a
+ 					 * newline.
+ 					 */
+ 					int content_size =
+ 						strlen(cont.cells[idx])
+ 						+ 2 			/* room for [CR],LF or space */
+ 						+ strlen(content)
+ 						+ 1;			/* '\0' */
+ 					char *new_content;
+ 
+ 					/*
+ 					 * idx2 is an index into allocated_cells. It differs from
+ 					 * idx (index into cont.cells), because vertical and
+ 					 * horizontal headers are included in `cont.cells` but
+ 					 * excluded from allocated_cells.
+ 					 */
+ 					int idx2 = (row_number * num_columns) + col_number;
+ 
+ 					if (allocated_cells[idx2] != NULL)
+ 					{
+ 						new_content = pg_realloc(allocated_cells[idx2], content_size);
+ 					}
+ 					else
+ 					{
+ 						/*
+ 						 * At this point, cont.cells[idx] still contains a
+ 						 * PQgetvalue() pointer.  Just after, it will contain
+ 						 * a new pointer maintained in allocated_cells[], and
+ 						 * freed at the end of this function.
+ 						 */
+ 						new_content = pg_malloc(content_size);
+ 						strcpy(new_content, cont.cells[idx]);
+ 					}
+ 					cont.cells[idx] = new_content;
+ 					allocated_cells[idx2] = new_content;
+ 
+ 					/*
+ 					 * Contents that are on adjacent columns in the source results get
+ 					 * separated by one space in the target.
+ 					 * Contents that are on different rows in the source get
+ 					 * separated by newlines in the target.
+ 					 */
+ 					if (k==0)
+ 						strcat(new_content, "\n");
+ 					else
+ 						strcat(new_content, " ");
+ 					strcat(new_content, content);
+ 				}
+ 				else
+ 				{
+ 					cont.cells[idx] = content;
+ 				}
+ 				k++;
+ 				src_col++;
+ 			} while (src_col < PQnfields(results));
+ 		}
+ 	}
+ 
+ 	printTable(&cont, pset.queryFout, false, pset.logfile);
+ 	printTableCleanup(&cont);
+ 
+ 
+ 	for (i=0; i < num_rows * num_columns; i++)
+ 	{
+ 		if (allocated_cells[i] != NULL)
+ 			pg_free(allocated_cells[i]);
+ 	}
+ 
+ 	pg_free(allocated_cells);
+ }
+ 
+ /*
+  * Compare a user-supplied argument against a field name obtained by PQfname(),
+  * which is already case-folded.
+  * If arg is not enclosed in double quotes, pg_strcasecmp applies, otherwise
+  * do a case-sensitive comparison with these rules:
+  * - double quotes enclosing 'arg' are filtered out
+  * - double quotes inside 'arg' are expected to be doubled
+  */
+ static int
+ fieldnameCmp(const char* arg, const char* fieldname)
+ {
+ 	const unsigned char* p = (const unsigned char*) arg;
+ 	const unsigned char* f = (const unsigned char*) fieldname;
+ 	unsigned char c;
+ 
+ 	if (*p++ != '"')
+ 		return pg_strcasecmp(arg, fieldname);
+ 
+ 	while ((c=*p++))
+ 	{
+ 		if (c=='"')
+ 		{
+ 			if (*p=='"')
+ 				p++;			/* skip second quote and continue */
+ 			else if (*p=='\0')
+ 				return *p-*f;		/* p finishes before f or is identical */
+ 
+ 		}
+ 		if (*f=='\0')
+ 			return 1;			/* f finishes before p */
+ 		if (c!=*f)
+ 			return c-*f;
+ 		f++;
+ 	}
+ 	return (*f=='\0') ? 0 : 1;
+ }
+ 
+ 
+ /*
+  * arg can be a number or a column name, possibly quoted (like in an ORDER BY clause)
+  * Returns:
+  *  on success, the 0-based index of the column
+  *  or -1 if the column number or name is not found in the result's structure,
+  *        or if it's ambiguous (arg corresponding to several columns)
+  */
+ static int
+ indexOfColumn(const char* arg, PGresult* res)
+ {
+ 	int idx;
+ 
+ 	if (strspn(arg, "0123456789") == strlen(arg))
+ 	{
+ 		/* if arg contains only digits, it's a column number */
+ 		idx = atoi(arg) - 1;
+ 		if (idx < 0  || idx >= PQnfields(res))
+ 		{
+ 			psql_error(_("Invalid column number: %s\n"), arg);
+ 			return -1;
+ 		}
+ 	}
+ 	else
+ 	{
+ 		int i;
+ 		idx = -1;
+ 		for (i=0; i < PQnfields(res); i++)
+ 		{
+ 			if (fieldnameCmp(arg, PQfname(res, i)) == 0)
+ 			{
+ 				if (idx>=0)
+ 				{
+ 					/* if another idx was already found for the same name */
+ 					psql_error(_("Ambiguous column name: %s\n"), arg);
+ 					return -1;
+ 				}
+ 				idx = i;
+ 			}
+ 		}
+ 		if (idx == -1)
+ 		{
+ 			psql_error(_("Invalid column name: %s\n"), arg);
+ 			return -1;
+ 		}
+ 	}
+ 	return idx;
+ }
+ 
+ bool
+ PrintResultsInCrossTab(PGresult* res,
+ 					   const char* opt_field_for_rows,    /* COLV or null */
+ 					   const char* opt_field_for_columns, /* [-+]COLH or null */
+ 					   const char* opt_field_for_ranks)   /* COLL or NULL */
+ {
+ 	int		rn;
+ 	struct pivot_field	*piv_columns = NULL;
+ 	struct pivot_field	*piv_rows = NULL;
+ 	int		num_columns = 0;
+ 	int		num_rows = 0;
+ 	bool 	retval = false;
+ 	int		columns_sort_direction = 0; /* 1:ascending, 0:none, -1:descending */
+ 	int		field_for_ranks;
+ 
+ 	/* 0-based index of the field whose distinct values will become COLUMN headers */
+ 	int		field_for_columns;
+ 
+ 	/* 0-based index of the field whose distinct values will become ROW headers */
+ 	int		field_for_rows;
+ 
+ 	if (PQresultStatus(res) != PGRES_TUPLES_OK)
+ 		goto error_return;
+ 
+ 	if (PQnfields(res) < 2)
+ 	{
+ 		psql_error(_("The query must return at least two columns to be shown in crosstab\n"));
+ 		goto error_return;
+ 	}
+ 
+ 	if (PQnfields(res) < 3 && opt_field_for_ranks != NULL)
+ 	{
+ 		psql_error(_("The query must return at least three columns to be shown in crosstab\n"));
+ 		goto error_return;
+ 	}
+ 
+ 	field_for_rows = (opt_field_for_rows != NULL)
+ 		? indexOfColumn(opt_field_for_rows, res)
+ 		: 0;
+ 
+ 	if (field_for_rows < 0)
+ 		goto error_return;
+ 
+ 	if (opt_field_for_columns == NULL)
+ 		field_for_columns = 1;
+ 	else
+ 	{
+ 		/*
+ 		 * descending sort is requested if the column reference is
+ 		 * preceded with a minus sign
+ 		 */
+ 		if (*opt_field_for_columns == '-')
+ 		{
+ 			columns_sort_direction = -1;
+ 			opt_field_for_columns++;
+ 		}
+ 		else if (*opt_field_for_columns == '+')
+ 		{
+ 			columns_sort_direction = 1;
+ 			opt_field_for_columns++;
+ 		}
+ 		field_for_columns = indexOfColumn(opt_field_for_columns, res);
+ 		if (field_for_columns < 0)
+ 			goto error_return;
+ 	}
+ 
+ 	if (field_for_columns == field_for_rows)
+ 	{
+ 		psql_error(_("The same column cannot be used for both vertical and horizontal headers\n"));
+ 		goto error_return;
+ 	}
+ 
+ 	if (opt_field_for_ranks)
+ 	{
+ 		Oid		ftype;
+ 
+ 		field_for_ranks = indexOfColumn(opt_field_for_ranks, res);
+ 		if (field_for_ranks == field_for_columns || field_for_ranks == field_for_rows)
+ 		{
+ 			psql_error(_("The same column cannot be used for both vertical and horizontal headers or ranks\n"));
+ 			goto error_return;
+ 		}
+ 
+ 		/* the rank column should be integer */
+ 		ftype = PQftype(res, field_for_ranks);
+ 		switch (ftype)
+ 		{
+ 			case INT2OID:
+ 			case INT4OID:
+ 			case INT8OID:
+ 			case FLOAT4OID:
+ 			case FLOAT8OID:
+ 			case NUMERICOID:
+ 				break;
+ 			default:
+ 				psql_error(_("The rank value should be short int or int.\n"));
+ 				goto error_return;
+ 		}
+ 	}
+ 	else
+ 		field_for_ranks = -1;
+ 
+ 	/*
+ 	 * First pass: accumulate row names and column names, each into their
+ 	 * array. Use client-side sort but only to build the set of DISTINCT
+ 	 * values. The final order displayed depends only on server-side
+ 	 * sorts.
+ 	 */
+ 	for (rn = 0; rn < PQntuples(res); rn++)
+ 	{
+ 		if (!PQgetisnull(res, rn, field_for_rows))
+ 		{
+ 			accumHeader(PQgetvalue(res, rn, field_for_rows), 
+ 				    NULL,
+ 						&num_rows,
+ 						&piv_rows,
+ 						rn);
+ 		}
+ 
+ 		if (!PQgetisnull(res, rn, field_for_columns))
+ 		{
+ 			if (field_for_ranks >= 0)
+ 			{
+ 				/* ensure not null values */
+ 				if (PQgetisnull(res, rn, field_for_ranks))
+ 				{
+ 					psql_error(_("The rank value should be short int or int.\n"));
+ 					goto error_return;
+ 				}
+ 
+ 				accumHeader(PQgetvalue(res, rn, field_for_columns),
+ 					    PQgetvalue(res, rn, field_for_ranks),
+ 							&num_columns,
+ 							&piv_columns,
+ 							rn);
+ 			}
+ 			else
+ 				accumHeader(PQgetvalue(res, rn, field_for_columns),
+ 					    NULL,
+ 							&num_columns,
+ 							&piv_columns,
+ 							rn);
+ 			if (num_columns > 1600)
+ 			{
+ 				psql_error(_("Maximum number of columns (1600) exceeded\n"));
+ 				goto error_return;
+ 			}
+ 		}
+ 	}
+ 
+ 	if (field_for_ranks >= 0)
+ 	{
+ 		if (!sortColumnsByRank(piv_columns, num_columns,
+ 						 columns_sort_direction))
+ 			goto error_return;
+ 	}
+ 
+ 	/*
+ 	 * Second pass: sort the list of target columns on the server.
+ 	 */
+ 	else if (!sortColumns(PQftype(res, field_for_columns),
+ 					 piv_columns,
+ 					 num_columns,
+ 					 columns_sort_direction))
+ 		goto error_return;
+ 
+ 	/*
+ 	 * Third pass: print the crosstab'ed results.
+ 	 */
+ 	printCrosstab(res,
+ 				  num_columns,
+ 				  piv_columns,
+ 				  field_for_columns,
+ 				  num_rows,
+ 				  piv_rows,
+ 				  field_for_rows,
+ 				  field_for_ranks);
+ 
+ 	retval = true;
+ 
+ error_return:
+ 	pg_free(piv_columns);
+ 	pg_free(piv_rows);
+ 
+ 	return retval;
+ }
diff --git a/src/bin/psql/crosstabview.h b/src/bin/psql/crosstabview.h
new file mode 100644
index ...dd26322
*** a/src/bin/psql/crosstabview.h
--- b/src/bin/psql/crosstabview.h
***************
*** 0 ****
--- 1,36 ----
+ /*
+  * psql - the PostgreSQL interactive terminal
+  *
+  * Copyright (c) 2000-2015, PostgreSQL Global Development Group
+  *
+  * src/bin/psql/crosstabview.h
+  */
+ 
+ #ifndef CROSSTABVIEW_H
+ #define CROSSTABVIEW_H
+ 
+ struct pivot_field
+ {
+ 	/* Pointer obtained from PGgetvalue() for colV or colH */
+ 	char*	name;
+ 
+ 	/* Rank of the field in its list, starting at 0.
+ 	 * - For headers stacked vertically, rank=N means it's the
+ 	 *   Nth distinct field encountered when looping through rows
+ 	 *   in their initial order.
+ 	 * - For headers stacked horizontally, rank is obtained
+ 	 *   by server-side sorting in sortColumns(), or explicitly
+ 	 *   from rank column
+ 	 */
+ 	int		rank;
+ 	double		outer_rank;
+ };
+ 
+ /* prototypes */
+ extern bool
+ PrintResultsInCrossTab(PGresult* res,
+ 					   const char* opt_field_for_rows,
+ 					   const char* opt_field_for_columns,
+ 					   const char* opt_field_for_ranks);
+ 
+ #endif   /* CROSSTABVIEW_H */
diff --git a/src/bin/psql/help.c b/src/bin/psql/help.c
new file mode 100644
index 5b63e76..a893a64
*** a/src/bin/psql/help.c
--- b/src/bin/psql/help.c
*************** slashUsage(unsigned short int pager)
*** 175,180 ****
--- 175,181 ----
  	fprintf(output, _("  \\g [FILE] or ;         execute query (and send results to file or |pipe)\n"));
  	fprintf(output, _("  \\gset [PREFIX]         execute query and store results in psql variables\n"));
  	fprintf(output, _("  \\q                     quit psql\n"));
+ 	fprintf(output, _("  \\crosstabview [V H [R]] execute query and display results in crosstab\n"));
  	fprintf(output, _("  \\watch [SEC]           execute query every SEC seconds\n"));
  	fprintf(output, "\n");
  
diff --git a/src/bin/psql/print.c b/src/bin/psql/print.c
new file mode 100644
index 05d4b31..b2f8c2b
*** a/src/bin/psql/print.c
--- b/src/bin/psql/print.c
*************** printQuery(const PGresult *result, const
*** 3291,3320 ****
  
  	for (i = 0; i < cont.ncolumns; i++)
  	{
- 		char		align;
- 		Oid			ftype = PQftype(result, i);
- 
- 		switch (ftype)
- 		{
- 			case INT2OID:
- 			case INT4OID:
- 			case INT8OID:
- 			case FLOAT4OID:
- 			case FLOAT8OID:
- 			case NUMERICOID:
- 			case OIDOID:
- 			case XIDOID:
- 			case CIDOID:
- 			case CASHOID:
- 				align = 'r';
- 				break;
- 			default:
- 				align = 'l';
- 				break;
- 		}
- 
  		printTableAddHeader(&cont, PQfname(result, i),
! 							opt->translate_header, align);
  	}
  
  	/* set cells */
--- 3291,3299 ----
  
  	for (i = 0; i < cont.ncolumns; i++)
  	{
  		printTableAddHeader(&cont, PQfname(result, i),
! 							opt->translate_header,
! 							column_type_alignment(PQftype(result, i)));
  	}
  
  	/* set cells */
*************** printQuery(const PGresult *result, const
*** 3356,3361 ****
--- 3335,3365 ----
  	printTableCleanup(&cont);
  }
  
+ char
+ column_type_alignment(Oid ftype)
+ {
+ 	char		align;
+ 
+ 	switch (ftype)
+ 	{
+ 		case INT2OID:
+ 		case INT4OID:
+ 		case INT8OID:
+ 		case FLOAT4OID:
+ 		case FLOAT8OID:
+ 		case NUMERICOID:
+ 		case OIDOID:
+ 		case XIDOID:
+ 		case CIDOID:
+ 		case CASHOID:
+ 			align = 'r';
+ 			break;
+ 		default:
+ 			align = 'l';
+ 			break;
+ 	}
+ 	return align;
+ }
  
  void
  setDecimalLocale(void)
diff --git a/src/bin/psql/print.h b/src/bin/psql/print.h
new file mode 100644
index fd56598..218b185
*** a/src/bin/psql/print.h
--- b/src/bin/psql/print.h
*************** extern FILE *PageOutput(int lines, const
*** 175,181 ****
  extern void ClosePager(FILE *pagerpipe);
  
  extern void html_escaped_print(const char *in, FILE *fout);
! 
  extern void printTableInit(printTableContent *const content,
  			   const printTableOpt *opt, const char *title,
  			   const int ncolumns, const int nrows);
--- 175,181 ----
  extern void ClosePager(FILE *pagerpipe);
  
  extern void html_escaped_print(const char *in, FILE *fout);
! extern char column_type_alignment(Oid);
  extern void printTableInit(printTableContent *const content,
  			   const printTableOpt *opt, const char *title,
  			   const int ncolumns, const int nrows);
diff --git a/src/bin/psql/settings.h b/src/bin/psql/settings.h
new file mode 100644
index 1885bb1..5993c1d
*** a/src/bin/psql/settings.h
--- b/src/bin/psql/settings.h
*************** typedef struct _psqlSettings
*** 90,95 ****
--- 90,99 ----
  
  	char	   *gfname;			/* one-shot file output argument for \g */
  	char	   *gset_prefix;	/* one-shot prefix argument for \gset */
+ 	bool		crosstabview_output;  /* one-shot request to print results in crosstab */
+ 	char		*crosstabview_col_V;  /* one-shot \crosstabview 1st argument */
+ 	char		*crosstabview_col_H;  /* one-shot \crosstabview 2nd argument */
+ 	char		*crosstabview_col_O;  /* one-shot \crosstabview 3nd argument */
  
  	bool		notty;			/* stdin or stdout is not a tty (as determined
  								 * on startup) */
diff --git a/src/bin/psql/tab-complete.c b/src/bin/psql/tab-complete.c
new file mode 100644
index 8c48881..3337256
*** a/src/bin/psql/tab-complete.c
--- b/src/bin/psql/tab-complete.c
*************** psql_completion(const char *text, int st
*** 936,943 ****
  
  	static const char *const backslash_commands[] = {
  		"\\a", "\\connect", "\\conninfo", "\\C", "\\cd", "\\copy", "\\copyright",
! 		"\\d", "\\da", "\\db", "\\dc", "\\dC", "\\dd", "\\ddp", "\\dD",
! 		"\\des", "\\det", "\\deu", "\\dew", "\\dE", "\\df",
  		"\\dF", "\\dFd", "\\dFp", "\\dFt", "\\dg", "\\di", "\\dl", "\\dL",
  		"\\dm", "\\dn", "\\do", "\\dO", "\\dp", "\\drds", "\\ds", "\\dS",
  		"\\dt", "\\dT", "\\dv", "\\du", "\\dx", "\\dy",
--- 936,943 ----
  
  	static const char *const backslash_commands[] = {
  		"\\a", "\\connect", "\\conninfo", "\\C", "\\cd", "\\copy", "\\copyright",
! 		"\\crosstabview", "\\d", "\\da", "\\db", "\\dc", "\\dC", "\\dd", "\\ddp",
! 		"\\dD", "\\des", "\\det", "\\deu", "\\dew", "\\dE", "\\df",
  		"\\dF", "\\dFd", "\\dFp", "\\dFt", "\\dg", "\\di", "\\dl", "\\dL",
  		"\\dm", "\\dn", "\\do", "\\dO", "\\dp", "\\drds", "\\ds", "\\dS",
  		"\\dt", "\\dT", "\\dv", "\\du", "\\dx", "\\dy",

diff --git a/doc/src/sgml/ref/psql-ref.sgml b/doc/src/sgml/ref/psql-ref.sgml
new file mode 100644
index 47e9da2..a45f4b8
*** a/doc/src/sgml/ref/psql-ref.sgml
--- b/doc/src/sgml/ref/psql-ref.sgml
*************** lo_import 152801
*** 2461,2466 ****
--- 2461,2555 ----
          </listitem>
        </varlistentry>
  
+       <varlistentry>
+         <term><literal>\crosstabview [ <replaceable class="parameter">colV</replaceable>  [-|+]<replaceable class="parameter">colH</replaceable> ] </literal></term>
+         <listitem>
+         <para>
+         Execute the current query buffer (like <literal>\g</literal>) and shows the results
+         inside a crosstab grid. The output column <replaceable class="parameter">colV</replaceable>
+         becomes a vertical header and the output column
+         <replaceable class="parameter">colH</replaceable> becomes a horizontal header.
+         The results for the other output columns are projected inside the grid.
+         </para>
+ 
+         <para>
+         <replaceable class="parameter">colV</replaceable>
+         and <replaceable class="parameter">colH</replaceable> can indicate a
+         column position (starting at 1), or a column name. Normal case folding
+         and quoting rules apply on column names. By default,
+         <replaceable class="parameter">colV</replaceable> is column 1
+         and <replaceable class="parameter">colH</replaceable> is column 2.
+         A query having only one output column cannot be viewed in crosstab, and
+         <replaceable class="parameter">colH</replaceable> must differ from
+         <replaceable class="parameter">colV</replaceable>.
+         </para>
+ 
+         <para>
+         The vertical header, displayed as the leftmost column,
+         contains the set of all distinct values found in
+         column <replaceable class="parameter">colV</replaceable>, in the order
+         of their first appearance in the query results.
+         </para>
+         <para>
+         The horizontal header, displayed as the first row,
+         contains the set of all distinct non-null values found in
+         column <replaceable class="parameter">colH</replaceable>.  They come
+         by default in their order of appearance in the query results, or in ascending
+         order if a plus (+) sign precedes <replaceable class="parameter">colH</replaceable>,
+         or in descending order if it's a minus (-) sign.
+         </para>
+ 
+         <para>
+         The query results being tuples of <literal>N</literal> columns
+         (including <replaceable class="parameter">colV</replaceable> and
+         <replaceable class="parameter">colH</replaceable>),
+         for each distinct value <literal>x</literal> of
+         <replaceable class="parameter">colH</replaceable>
+         and each distinct value <literal>y</literal> of
+         <replaceable class="parameter">colV</replaceable>,
+         a cell located at the intersection <literal>(x,y)</literal> in the grid
+         has contents determined by these rules:
+         <itemizedlist>
+         <listitem>
+         <para>
+          if there is no corresponding row in the results such that the value
+          for <replaceable class="parameter">colH</replaceable>
+          is <literal>x</literal> and the value
+          for <replaceable class="parameter">colV</replaceable>
+          is <literal>y</literal>, the cell is empty.
+         </para>
+         </listitem>
+ 
+         <listitem>
+         <para>
+          if there is exactly one row such that the value
+          for <replaceable class="parameter">colH</replaceable>
+          is <literal>x</literal> and the value
+          for <replaceable class="parameter">colV</replaceable>
+          is <literal>y</literal>, then the <literal>N-2</literal> other
+          columns are displayed in the cell, separated between each other by
+          a space character if needed.
+ 
+          If <literal>N=2</literal>, the letter <literal>X</literal> is displayed in the cell as
+          if a virtual third column contained that character.
+         </para>
+         </listitem>
+ 
+         <listitem>
+         <para>
+          if there are several corresponding rows, the behavior is identical to one row
+          except that the values coming from different rows are stacked
+          vertically, rows being separated by newline characters inside
+          the same cell.
+         </para>
+         </listitem>
+ 
+         </itemizedlist>
+         </para>
+ 
+         </listitem>
+       </varlistentry>
+ 
  
        <varlistentry>
          <term><literal>\s [ <replaceable class="parameter">filename</replaceable> ]</literal></term>
diff --git a/src/bin/psql/Makefile b/src/bin/psql/Makefile
new file mode 100644
index f1336d5..9cb0c4a
*** a/src/bin/psql/Makefile
--- b/src/bin/psql/Makefile
*************** override CPPFLAGS := -I. -I$(srcdir) -I$
*** 23,29 ****
  OBJS=	command.o common.o help.o input.o stringutils.o mainloop.o copy.o \
  	startup.o prompt.o variables.o large_obj.o print.o describe.o \
  	tab-complete.o mbprint.o dumputils.o keywords.o kwlookup.o \
! 	sql_help.o \
  	$(WIN32RES)
  
  
--- 23,29 ----
  OBJS=	command.o common.o help.o input.o stringutils.o mainloop.o copy.o \
  	startup.o prompt.o variables.o large_obj.o print.o describe.o \
  	tab-complete.o mbprint.o dumputils.o keywords.o kwlookup.o \
! 	sql_help.o crosstabview.o \
  	$(WIN32RES)
  
  
diff --git a/src/bin/psql/command.c b/src/bin/psql/command.c
new file mode 100644
index cf6876b..c743f57
*** a/src/bin/psql/command.c
--- b/src/bin/psql/command.c
***************
*** 46,51 ****
--- 46,52 ----
  #include "mainloop.h"
  #include "print.h"
  #include "psqlscan.h"
+ #include "crosstabview.h"
  #include "settings.h"
  #include "variables.h"
  
*************** exec_command(const char *cmd,
*** 1081,1086 ****
--- 1082,1119 ----
  		free(pw2);
  	}
  
+ 	/* \crosstabview -- execute a query and display results in crosstab */
+ 	else if (strcmp(cmd, "crosstabview") == 0)
+ 	{
+ 		char	*opt1,
+ 				*opt2,
+ 				*opt3;
+ 
+ 		opt1 = psql_scan_slash_option(scan_state,
+ 									  OT_NORMAL, NULL, false);
+ 		opt2 = psql_scan_slash_option(scan_state,
+ 									  OT_NORMAL, NULL, false);
+ 		opt3 = psql_scan_slash_option(scan_state,
+ 									  OT_NORMAL, NULL, false);
+ 
+ 		if (opt1 && !opt2)
+ 		{
+ 			psql_error(_("\\%s: missing second argument\n"), cmd);
+ 			success = false;
+ 		}
+ 		else
+ 		{
+ 			pset.crosstabview_col_V = opt1 ? pg_strdup(opt1) : NULL;
+ 			pset.crosstabview_col_H = opt2 ? pg_strdup(opt2) : NULL;
+ 			pset.crosstabview_col_O = opt3 ? pg_strdup(opt3) : NULL;
+ 			pset.crosstabview_output = true;
+ 			status = PSQL_CMD_SEND;
+ 		}
+ 
+ 		free(opt1);
+ 		free(opt2);
+ 	}
+ 
  	/* \prompt -- prompt and set variable */
  	else if (strcmp(cmd, "prompt") == 0)
  	{
diff --git a/src/bin/psql/common.c b/src/bin/psql/common.c
new file mode 100644
index a287eee..26cd233
*** a/src/bin/psql/common.c
--- b/src/bin/psql/common.c
***************
*** 24,29 ****
--- 24,30 ----
  #include "command.h"
  #include "copy.h"
  #include "mbprint.h"
+ #include "crosstabview.h"
  
  
  static bool ExecQueryUsingCursor(const char *query, double *elapsed_msec);
*************** SendQuery(const char *query)
*** 1076,1085 ****
  
  		/* but printing results isn't: */
  		if (OK && results)
! 			OK = PrintQueryResults(results);
  	}
  	else
  	{
  		/* Fetch-in-segments mode */
  		OK = ExecQueryUsingCursor(query, &elapsed_msec);
  		ResetCancelConn();
--- 1077,1102 ----
  
  		/* but printing results isn't: */
  		if (OK && results)
! 		{
! 			if (pset.crosstabview_output)
! 				OK = PrintResultsInCrossTab(results,
! 											pset.crosstabview_col_V,
! 											pset.crosstabview_col_H,
! 											pset.crosstabview_col_O);
! 			else
! 				OK = PrintQueryResults(results);
! 		}
  	}
  	else
  	{
+ 		if (pset.crosstabview_output)
+ 		{
+ 			psql_error("\\crosstabview cannot be executed since active FETCH_COUNT = %d\n",
+ 					pset.fetch_count);
+ 			OK = false;
+ 			goto sendquery_cleanup;
+ 		}
+ 
  		/* Fetch-in-segments mode */
  		OK = ExecQueryUsingCursor(query, &elapsed_msec);
  		ResetCancelConn();
*************** sendquery_cleanup:
*** 1192,1197 ****
--- 1209,1231 ----
  		pset.gset_prefix = NULL;
  	}
  
+ 	pset.crosstabview_output = false;
+ 	if (pset.crosstabview_col_V)
+ 	{
+ 		free(pset.crosstabview_col_V);
+ 		pset.crosstabview_col_V = NULL;
+ 	}
+ 	if (pset.crosstabview_col_H)
+ 	{
+ 		free(pset.crosstabview_col_H);
+ 		pset.crosstabview_col_H = NULL;
+ 	}
+ 	if (pset.crosstabview_col_O)
+ 	{
+ 		free(pset.crosstabview_col_O);
+ 		pset.crosstabview_col_O = NULL;
+ 	}
+ 
  	return OK;
  }
  
diff --git a/src/bin/psql/crosstabview.c b/src/bin/psql/crosstabview.c
new file mode 100644
index ...ac6c6f8
*** a/src/bin/psql/crosstabview.c
--- b/src/bin/psql/crosstabview.c
***************
*** 0 ****
--- 1,750 ----
+ /*
+  * psql - the PostgreSQL interactive terminal
+  *
+  * Copyright (c) 2000-2015, PostgreSQL Global Development Group
+  *
+  * src/bin/psql/crosstabview.c
+  */
+ 
+ 
+ #include "common.h"
+ #include "pqexpbuffer.h"
+ #include "crosstabview.h"
+ #include "settings.h"
+ 
+ #include "catalog/pg_type.h"
+ 
+ #include <string.h>
+ 
+ static int
+ headerCompare(const void *a, const void *b)
+ {
+ 	return strcmp( ((struct pivot_field*)a)->name,
+ 				   ((struct pivot_field*)b)->name);
+ }
+ 
+ static void
+ accumHeader(char* name, char* outer_rank, int* count, struct pivot_field **sorted_tab, int row_number)
+ {
+ 	struct pivot_field *p;
+ 
+ 	/*
+ 	 * Search for name in sorted_tab. If it doesn't exist, insert it,
+ 	 * otherwise do nothing.
+ 	 */
+ 
+ 	if (*count >= 1)
+ 	{
+ 		p = (struct pivot_field*) bsearch(&name,
+ 										  *sorted_tab,
+ 										  *count,
+ 										  sizeof(struct pivot_field),
+ 										  headerCompare);
+ 	}
+ 	else
+ 		p=NULL;
+ 
+ 	if (!p)
+ 	{
+ 		*sorted_tab = pg_realloc(*sorted_tab, sizeof(struct pivot_field) * (1+*count));
+ 		(*sorted_tab)[*count].name = name;
+ 		(*sorted_tab)[*count].outer_rank = outer_rank ? strtod(outer_rank, NULL) : -1.0;
+ 		(*sorted_tab)[*count].rank = *count;
+ 		(*count)++;
+ 
+ 		qsort(*sorted_tab,
+ 			  *count,
+ 			  sizeof(struct pivot_field),
+ 			  headerCompare);
+ 	}
+ }
+ 
+ /*
+  * Auxilary structure using for sorting only
+  */
+ struct p_rank
+ {
+ 	double		outer_rank;
+ 	int	old_pos;
+ };
+ 
+ static int
+ RankCompare(const void *a, const void *b)
+ {
+ 	return ((struct p_rank*)a)->outer_rank - ((struct p_rank*)b)->outer_rank ;
+ }
+ 
+ static int
+ RankCompareDesc(const void *a, const void *b)
+ {
+ 	return ((struct p_rank*) b)->outer_rank - ((struct p_rank*) a)->outer_rank;
+ }
+ 
+ 
+ /*
+  * Resort header by rank, ensure uniq outer ranks
+  */
+ static bool
+ sortColumnsByRank(struct pivot_field *columns, int nb_cols, int direction)
+ {
+ 	int		i;
+ 	struct p_rank	*p_ranks;
+ 	bool		retval = true;
+ 
+ 	p_ranks = (struct p_rank *) pg_malloc(nb_cols * sizeof(struct p_rank));
+ 
+ 	for (i = 0; i < nb_cols; i++)
+ 	{
+ 		p_ranks[i].outer_rank = columns[i].outer_rank;
+ 		p_ranks[i].old_pos = i;
+ 	}
+ 
+ 	if (direction >= 0)
+ 		qsort(p_ranks,
+ 			  nb_cols,
+ 			  sizeof(struct p_rank),
+ 			  RankCompare);
+ 	else
+ 		qsort(p_ranks,
+ 			  nb_cols,
+ 			  sizeof(struct p_rank),
+ 			  RankCompareDesc);
+ 
+ 	for (i = 0; i < nb_cols; i++)
+ 	{
+ 		/* two adjecent outer sorted ranks should be different */
+ 		if (i > 0 && p_ranks[i].outer_rank == p_ranks[i - 1].outer_rank)
+ 		{
+ 			psql_error("Outer ranks are not unique.");
+ 			goto cleanup;
+ 		}
+ 
+ 		columns[p_ranks[i].old_pos].rank = i;
+ 	}
+ 
+ 	retval = true;
+ 
+ cleanup:
+ 
+ 	pg_free(p_ranks);
+ 
+ 	return retval;
+ }
+ 
+ /*
+  * Send a query to sort all column values cast to the Oid passed in a VALUES clause
+  */
+ static bool
+ sortColumns(Oid coltype, struct pivot_field *columns, int nb_cols, int direction)
+ {
+ 	bool retval = false;
+ 	PGresult *res = NULL;
+ 	PQExpBufferData query;
+ 	int i;
+ 	Oid *param_types;
+ 	const char** param_values;
+ 	int* param_lengths;
+ 	int* param_formats;
+ 
+ 	if (nb_cols < 2 || direction==0)
+ 		return true;					/* nothing to sort */
+ 
+ 	param_types = (Oid*) pg_malloc(nb_cols*sizeof(Oid));
+ 	param_values = (const char**) pg_malloc(nb_cols*sizeof(char*));
+ 	param_lengths = (int*) pg_malloc(nb_cols*sizeof(int));
+ 	param_formats = (int*) pg_malloc(nb_cols*sizeof(int));
+ 
+ 	initPQExpBuffer(&query);
+ 
+ 	/*
+ 	 * The query returns the original position of each value in our list,
+ 	 * ordered by its new position. The value itself is not returned.
+ 	 */
+ 	appendPQExpBuffer(&query, "SELECT n FROM (VALUES");
+ 
+ 	for (i=1; i <= nb_cols; i++)
+ 	{
+ 		if (i < nb_cols)
+ 			appendPQExpBuffer(&query, "($%d,%d),", i, i);
+ 		else
+ 		{
+ 			appendPQExpBuffer(&query, "($%d,%d)) AS l(x,n) ORDER BY x", i, i);
+ 			if (direction < 0)
+ 				appendPQExpBuffer(&query, " DESC");
+ 		}
+ 
+ 		param_types[i-1] = coltype;
+ 		param_values[i-1] = columns[i-1].name;
+ 		param_lengths[i-1] = strlen(columns[i-1].name);
+ 		param_formats[i-1] = 0;
+ 	}
+ 
+ 	res = PQexecParams(pset.db,
+ 					   query.data,
+ 					   nb_cols,
+ 					   param_types,
+ 					   param_values,
+ 					   param_lengths,
+ 					   param_formats,
+ 					   0);
+ 
+ 	if (res)
+ 	{
+ 		ExecStatusType status = PQresultStatus(res);
+ 		if (status == PGRES_TUPLES_OK)
+ 		{
+ 			for (i=0; i < PQntuples(res); i++)
+ 			{
+ 				int old_pos = atoi(PQgetvalue(res, i, 0));
+ 
+ 				if (old_pos < 1 || old_pos > nb_cols || i >= nb_cols)
+ 				{
+ 					/*
+ 					 * A position outside of the range is normally impossible.
+ 					 * If this happens, we're facing a malfunctioning or hostile
+ 					 * server or middleware.
+ 					 */
+ 					psql_error(_("Unexpected value when sorting horizontal headers"));
+ 					goto cleanup;
+ 				}
+ 				else
+ 				{
+ 					columns[old_pos-1].rank = i;
+ 				}
+ 			}
+ 		}
+ 		else
+ 		{
+ 			psql_error(_("Query error when sorting horizontal headers: %s"),
+ 					   PQerrorMessage(pset.db));
+ 			goto cleanup;
+ 		}
+ 	}
+ 
+ 	retval = true;
+ 
+ cleanup:
+ 	termPQExpBuffer(&query);
+ 	if (res)
+ 		PQclear(res);
+ 	pg_free(param_types);
+ 	pg_free(param_values);
+ 	pg_free(param_lengths);
+ 	pg_free(param_formats);
+ 	return retval;
+ }
+ 
+ static void
+ printCrosstab(const PGresult *results,
+ 			  int num_columns,
+ 			  struct pivot_field *piv_columns,
+ 			  int field_for_columns,
+ 			  int num_rows,
+ 			  struct pivot_field *piv_rows,
+ 			  int field_for_rows,
+ 			  int field_for_ranks)
+ {
+ 	printQueryOpt popt = pset.popt;
+ 	printTableContent cont;
+ 	int	i, j, rn;
+ 	char col_align = 'l';		/* alignment for values inside the grid */
+ 	int* horiz_map;			 	/* map indices from sorted horizontal headers to piv_columns */
+ 	char** allocated_cells; 	/*  Pointers for cell contents that are allocated
+ 								 *  in this function, when cells cannot simply point to
+ 								 *  PQgetvalue(results, ...) */
+ 
+ 	printTableInit(&cont, &popt.topt, popt.title, num_columns+1, num_rows);
+ 
+ 	/* Step 1: set target column names (horizontal header) */
+ 
+ 	/* The name of the first column is kept unchanged by the pivoting */
+ 	printTableAddHeader(&cont,
+ 						PQfname(results, field_for_rows),
+ 						false,
+ 						column_type_alignment(PQftype(results, field_for_rows)));
+ 
+ 	/*
+ 	 * To iterate over piv_columns[] by piv_columns[].rank, create a reverse map
+ 	 *  associating each piv_columns[].rank to its index in piv_columns.
+ 	 *  This avoids an O(N^2) loop later
+ 	 */
+ 	horiz_map = (int*) pg_malloc(sizeof(int) * num_columns);
+ 	for (i = 0; i < num_columns; i++)
+ 	{
+ 		horiz_map[piv_columns[i].rank] = i;
+ 	}
+ 
+ 	/*
+ 	 * In the case of 3 output columns, the contents in the cells are exactly
+ 	 * the contents of the "value" column (3rd column by default), so their
+ 	 * alignment is determined by PQftype(). Otherwise the contents are
+ 	 * made-up strings, so the alignment is 'l'
+ 	 */
+ 	if (PQnfields(results) == 3)
+ 	{
+ 		int colnum;				/* column placed inside the grid */
+ 		/*
+ 		 * find colnum in the permutations of (0,1,2) where colnum is
+ 		 * neither field_for_rows nor field_for_columns
+ 		 */
+ 		switch (field_for_rows)
+ 		{
+ 		case 0:
+ 			colnum = (field_for_columns == 1) ? 2 : 1;
+ 			break;
+ 		case 1:
+ 			colnum = (field_for_columns == 0) ? 2: 0;
+ 			break;
+ 		default:				/* should be always 2 */
+ 			colnum = (field_for_columns == 0) ? 1: 0;
+ 			break;
+ 		}
+ 		col_align = column_type_alignment(PQftype(results, colnum));
+ 	}
+ 	else
+ 		col_align = 'l';
+ 
+ 	for (i = 0; i < num_columns; i++)
+ 	{
+ 		printTableAddHeader(&cont,
+ 							piv_columns[horiz_map[i]].name,
+ 							false,
+ 							col_align);
+ 	}
+ 	pg_free(horiz_map);
+ 
+ 	/* Step 2: set row names in the first output column (vertical header) */
+ 	for (i = 0; i < num_rows; i++)
+ 	{
+ 		int k = piv_rows[i].rank;
+ 		cont.cells[k*(num_columns+1)] = piv_rows[i].name;
+ 		/* Initialize all cells inside the grid to an empty value */
+ 		for (j = 0; j < num_columns; j++)
+ 			cont.cells[k*(num_columns+1)+j+1] = "";
+ 	}
+ 	cont.cellsadded = num_rows * (num_columns+1);
+ 
+ 	allocated_cells = (char**) pg_malloc0(num_rows * num_columns * sizeof(char*));
+ 
+ 	/* Step 3: set all the cells "inside the grid" */
+ 	for (rn = 0; rn < PQntuples(results); rn++)
+ 	{
+ 		char* row_name;
+ 		char* col_name;
+ 		int row_number;
+ 		int col_number;
+ 		struct pivot_field *p;
+ 
+ 		row_number = col_number = -1;
+ 		/* Find target row */
+ 		if (!PQgetisnull(results, rn, field_for_rows))
+ 		{
+ 			row_name = PQgetvalue(results, rn, field_for_rows);
+ 			p = (struct pivot_field*) bsearch(&row_name,
+ 											  piv_rows,
+ 											  num_rows,
+ 											  sizeof(struct pivot_field),
+ 											  headerCompare);
+ 			if (p)
+ 				row_number = p->rank;
+ 		}
+ 
+ 		/* Find target column */
+ 		if (!PQgetisnull(results, rn, field_for_columns))
+ 		{
+ 			col_name = PQgetvalue(results, rn, field_for_columns);
+ 			p = (struct pivot_field*) bsearch(&col_name,
+ 											  piv_columns,
+ 											  num_columns,
+ 											  sizeof(struct pivot_field),
+ 											  headerCompare);
+ 			if (p)
+ 				col_number = p->rank;
+ 		}
+ 
+ 		/* Place value into cell */
+ 		if (col_number>=0 && row_number>=0)
+ 		{
+ 			int idx = 1 + col_number + row_number*(num_columns+1);
+ 			int src_col = 0;			/* column number in source result */
+ 			int k = 0;
+ 
+ 			do {
+ 				char *content;
+ 
+ 				if (PQnfields(results) == 2)
+ 				{
+ 					/*
+ 					  special case: when the source has only 2 columns, use a
+ 					  X (cross/checkmark) for the cell content, and set
+ 					  src_col to a virtual additional column.
+ 					*/
+ 					content = "X";
+ 					src_col = 3;
+ 				}
+ 				else if (src_col == field_for_rows || src_col == field_for_columns
+ 					    || src_col == field_for_ranks)
+ 				{
+ 					/*
+ 					  The source values that produce headers are not processed
+ 					  in this loop, only the values that end up inside the grid.
+ 					*/
+ 					src_col++;
+ 					continue;
+ 				}
+ 				else
+ 				{
+ 					content = (!PQgetisnull(results, rn, src_col)) ?
+ 						PQgetvalue(results, rn, src_col) :
+ 						(popt.nullPrint ? popt.nullPrint : "");
+ 				}
+ 
+ 				if (cont.cells[idx] != NULL && cont.cells[idx][0] != '\0')
+ 				{
+ 					/*
+ 					 * Multiple values for the same (row,col) are projected
+ 					 * into the same cell. When this happens, separate the
+ 					 * previous content of the cell from the new value by a
+ 					 * newline.
+ 					 */
+ 					int content_size =
+ 						strlen(cont.cells[idx])
+ 						+ 2 			/* room for [CR],LF or space */
+ 						+ strlen(content)
+ 						+ 1;			/* '\0' */
+ 					char *new_content;
+ 
+ 					/*
+ 					 * idx2 is an index into allocated_cells. It differs from
+ 					 * idx (index into cont.cells), because vertical and
+ 					 * horizontal headers are included in `cont.cells` but
+ 					 * excluded from allocated_cells.
+ 					 */
+ 					int idx2 = (row_number * num_columns) + col_number;
+ 
+ 					if (allocated_cells[idx2] != NULL)
+ 					{
+ 						new_content = pg_realloc(allocated_cells[idx2], content_size);
+ 					}
+ 					else
+ 					{
+ 						/*
+ 						 * At this point, cont.cells[idx] still contains a
+ 						 * PQgetvalue() pointer.  Just after, it will contain
+ 						 * a new pointer maintained in allocated_cells[], and
+ 						 * freed at the end of this function.
+ 						 */
+ 						new_content = pg_malloc(content_size);
+ 						strcpy(new_content, cont.cells[idx]);
+ 					}
+ 					cont.cells[idx] = new_content;
+ 					allocated_cells[idx2] = new_content;
+ 
+ 					/*
+ 					 * Contents that are on adjacent columns in the source results get
+ 					 * separated by one space in the target.
+ 					 * Contents that are on different rows in the source get
+ 					 * separated by newlines in the target.
+ 					 */
+ 					if (k==0)
+ 						strcat(new_content, "\n");
+ 					else
+ 						strcat(new_content, " ");
+ 					strcat(new_content, content);
+ 				}
+ 				else
+ 				{
+ 					cont.cells[idx] = content;
+ 				}
+ 				k++;
+ 				src_col++;
+ 			} while (src_col < PQnfields(results));
+ 		}
+ 	}
+ 
+ 	printTable(&cont, pset.queryFout, false, pset.logfile);
+ 	printTableCleanup(&cont);
+ 
+ 
+ 	for (i=0; i < num_rows * num_columns; i++)
+ 	{
+ 		if (allocated_cells[i] != NULL)
+ 			pg_free(allocated_cells[i]);
+ 	}
+ 
+ 	pg_free(allocated_cells);
+ }
+ 
+ /*
+  * Compare a user-supplied argument against a field name obtained by PQfname(),
+  * which is already case-folded.
+  * If arg is not enclosed in double quotes, pg_strcasecmp applies, otherwise
+  * do a case-sensitive comparison with these rules:
+  * - double quotes enclosing 'arg' are filtered out
+  * - double quotes inside 'arg' are expected to be doubled
+  */
+ static int
+ fieldnameCmp(const char* arg, const char* fieldname)
+ {
+ 	const unsigned char* p = (const unsigned char*) arg;
+ 	const unsigned char* f = (const unsigned char*) fieldname;
+ 	unsigned char c;
+ 
+ 	if (*p++ != '"')
+ 		return pg_strcasecmp(arg, fieldname);
+ 
+ 	while ((c=*p++))
+ 	{
+ 		if (c=='"')
+ 		{
+ 			if (*p=='"')
+ 				p++;			/* skip second quote and continue */
+ 			else if (*p=='\0')
+ 				return *p-*f;		/* p finishes before f or is identical */
+ 
+ 		}
+ 		if (*f=='\0')
+ 			return 1;			/* f finishes before p */
+ 		if (c!=*f)
+ 			return c-*f;
+ 		f++;
+ 	}
+ 	return (*f=='\0') ? 0 : 1;
+ }
+ 
+ 
+ /*
+  * arg can be a number or a column name, possibly quoted (like in an ORDER BY clause)
+  * Returns:
+  *  on success, the 0-based index of the column
+  *  or -1 if the column number or name is not found in the result's structure,
+  *        or if it's ambiguous (arg corresponding to several columns)
+  */
+ static int
+ indexOfColumn(const char* arg, PGresult* res)
+ {
+ 	int idx;
+ 
+ 	if (strspn(arg, "0123456789") == strlen(arg))
+ 	{
+ 		/* if arg contains only digits, it's a column number */
+ 		idx = atoi(arg) - 1;
+ 		if (idx < 0  || idx >= PQnfields(res))
+ 		{
+ 			psql_error(_("Invalid column number: %s\n"), arg);
+ 			return -1;
+ 		}
+ 	}
+ 	else
+ 	{
+ 		int i;
+ 		idx = -1;
+ 		for (i=0; i < PQnfields(res); i++)
+ 		{
+ 			if (fieldnameCmp(arg, PQfname(res, i)) == 0)
+ 			{
+ 				if (idx>=0)
+ 				{
+ 					/* if another idx was already found for the same name */
+ 					psql_error(_("Ambiguous column name: %s\n"), arg);
+ 					return -1;
+ 				}
+ 				idx = i;
+ 			}
+ 		}
+ 		if (idx == -1)
+ 		{
+ 			psql_error(_("Invalid column name: %s\n"), arg);
+ 			return -1;
+ 		}
+ 	}
+ 	return idx;
+ }
+ 
+ bool
+ PrintResultsInCrossTab(PGresult* res,
+ 					   const char* opt_field_for_rows,    /* COLV or null */
+ 					   const char* opt_field_for_columns, /* [-+]COLH or null */
+ 					   const char* opt_field_for_ranks)   /* COLL or NULL */
+ {
+ 	int		rn;
+ 	struct pivot_field	*piv_columns = NULL;
+ 	struct pivot_field	*piv_rows = NULL;
+ 	int		num_columns = 0;
+ 	int		num_rows = 0;
+ 	bool 	retval = false;
+ 	int		columns_sort_direction = 0; /* 1:ascending, 0:none, -1:descending */
+ 	int		field_for_ranks;
+ 
+ 	/* 0-based index of the field whose distinct values will become COLUMN headers */
+ 	int		field_for_columns;
+ 
+ 	/* 0-based index of the field whose distinct values will become ROW headers */
+ 	int		field_for_rows;
+ 
+ 	if (PQresultStatus(res) != PGRES_TUPLES_OK)
+ 		goto error_return;
+ 
+ 	if (PQnfields(res) < 2)
+ 	{
+ 		psql_error(_("The query must return at least two columns to be shown in crosstab\n"));
+ 		goto error_return;
+ 	}
+ 
+ 	if (PQnfields(res) < 3 && opt_field_for_ranks != NULL)
+ 	{
+ 		psql_error(_("The query must return at least three columns to be shown in crosstab\n"));
+ 		goto error_return;
+ 	}
+ 
+ 	field_for_rows = (opt_field_for_rows != NULL)
+ 		? indexOfColumn(opt_field_for_rows, res)
+ 		: 0;
+ 
+ 	if (field_for_rows < 0)
+ 		goto error_return;
+ 
+ 	if (opt_field_for_columns == NULL)
+ 		field_for_columns = 1;
+ 	else
+ 	{
+ 		/*
+ 		 * descending sort is requested if the column reference is
+ 		 * preceded with a minus sign
+ 		 */
+ 		if (*opt_field_for_columns == '-')
+ 		{
+ 			columns_sort_direction = -1;
+ 			opt_field_for_columns++;
+ 		}
+ 		else if (*opt_field_for_columns == '+')
+ 		{
+ 			columns_sort_direction = 1;
+ 			opt_field_for_columns++;
+ 		}
+ 		field_for_columns = indexOfColumn(opt_field_for_columns, res);
+ 		if (field_for_columns < 0)
+ 			goto error_return;
+ 	}
+ 
+ 	if (field_for_columns == field_for_rows)
+ 	{
+ 		psql_error(_("The same column cannot be used for both vertical and horizontal headers\n"));
+ 		goto error_return;
+ 	}
+ 
+ 	if (opt_field_for_ranks)
+ 	{
+ 		Oid		ftype;
+ 
+ 		field_for_ranks = indexOfColumn(opt_field_for_ranks, res);
+ 		if (field_for_ranks == field_for_columns || field_for_ranks == field_for_rows)
+ 		{
+ 			psql_error(_("The same column cannot be used for both vertical and horizontal headers or ranks\n"));
+ 			goto error_return;
+ 		}
+ 
+ 		/* the rank column should be integer */
+ 		ftype = PQftype(res, field_for_ranks);
+ 		switch (ftype)
+ 		{
+ 			case INT2OID:
+ 			case INT4OID:
+ 			case INT8OID:
+ 			case FLOAT4OID:
+ 			case FLOAT8OID:
+ 			case NUMERICOID:
+ 				break;
+ 			default:
+ 				psql_error(_("The rank value should be numeric value.\n"));
+ 				goto error_return;
+ 		}
+ 	}
+ 	else
+ 		field_for_ranks = -1;
+ 
+ 	/*
+ 	 * First pass: accumulate row names and column names, each into their
+ 	 * array. Use client-side sort but only to build the set of DISTINCT
+ 	 * values. The final order displayed depends only on server-side
+ 	 * sorts.
+ 	 */
+ 	for (rn = 0; rn < PQntuples(res); rn++)
+ 	{
+ 		if (!PQgetisnull(res, rn, field_for_rows))
+ 		{
+ 			accumHeader(PQgetvalue(res, rn, field_for_rows), 
+ 				    NULL,
+ 						&num_rows,
+ 						&piv_rows,
+ 						rn);
+ 		}
+ 
+ 		if (!PQgetisnull(res, rn, field_for_columns))
+ 		{
+ 			if (field_for_ranks >= 0)
+ 			{
+ 				/* ensure not null values */
+ 				if (PQgetisnull(res, rn, field_for_ranks))
+ 				{
+ 					psql_error(_("The rank value should not be null.\n"));
+ 					goto error_return;
+ 				}
+ 
+ 				accumHeader(PQgetvalue(res, rn, field_for_columns),
+ 					    PQgetvalue(res, rn, field_for_ranks),
+ 							&num_columns,
+ 							&piv_columns,
+ 							rn);
+ 			}
+ 			else
+ 				accumHeader(PQgetvalue(res, rn, field_for_columns),
+ 					    NULL,
+ 							&num_columns,
+ 							&piv_columns,
+ 							rn);
+ 			if (num_columns > 1600)
+ 			{
+ 				psql_error(_("Maximum number of columns (1600) exceeded\n"));
+ 				goto error_return;
+ 			}
+ 		}
+ 	}
+ 
+ 	/*
+ 	 * Second pass: sort the list of target columns (on the client).
+ 	 */
+ 	if (field_for_ranks >= 0 && !sortColumnsByRank(piv_columns,
+ 							num_columns,
+ 								columns_sort_direction))
+ 			goto error_return;
+ 
+ 	/*
+ 	 * Second pass: sort the list of target columns (on the server).
+ 	 */
+ 	else if (!sortColumns(PQftype(res, field_for_columns),
+ 					 piv_columns,
+ 					 num_columns,
+ 					 columns_sort_direction))
+ 		goto error_return;
+ 
+ 	/*
+ 	 * Third pass: print the crosstab'ed results.
+ 	 */
+ 	printCrosstab(res,
+ 				  num_columns,
+ 				  piv_columns,
+ 				  field_for_columns,
+ 				  num_rows,
+ 				  piv_rows,
+ 				  field_for_rows,
+ 				  field_for_ranks);
+ 
+ 	retval = true;
+ 
+ error_return:
+ 	pg_free(piv_columns);
+ 	pg_free(piv_rows);
+ 
+ 	return retval;
+ }
diff --git a/src/bin/psql/crosstabview.h b/src/bin/psql/crosstabview.h
new file mode 100644
index ...dd26322
*** a/src/bin/psql/crosstabview.h
--- b/src/bin/psql/crosstabview.h
***************
*** 0 ****
--- 1,36 ----
+ /*
+  * psql - the PostgreSQL interactive terminal
+  *
+  * Copyright (c) 2000-2015, PostgreSQL Global Development Group
+  *
+  * src/bin/psql/crosstabview.h
+  */
+ 
+ #ifndef CROSSTABVIEW_H
+ #define CROSSTABVIEW_H
+ 
+ struct pivot_field
+ {
+ 	/* Pointer obtained from PGgetvalue() for colV or colH */
+ 	char*	name;
+ 
+ 	/* Rank of the field in its list, starting at 0.
+ 	 * - For headers stacked vertically, rank=N means it's the
+ 	 *   Nth distinct field encountered when looping through rows
+ 	 *   in their initial order.
+ 	 * - For headers stacked horizontally, rank is obtained
+ 	 *   by server-side sorting in sortColumns(), or explicitly
+ 	 *   from rank column
+ 	 */
+ 	int		rank;
+ 	double		outer_rank;
+ };
+ 
+ /* prototypes */
+ extern bool
+ PrintResultsInCrossTab(PGresult* res,
+ 					   const char* opt_field_for_rows,
+ 					   const char* opt_field_for_columns,
+ 					   const char* opt_field_for_ranks);
+ 
+ #endif   /* CROSSTABVIEW_H */
diff --git a/src/bin/psql/help.c b/src/bin/psql/help.c
new file mode 100644
index 5b63e76..a893a64
*** a/src/bin/psql/help.c
--- b/src/bin/psql/help.c
*************** slashUsage(unsigned short int pager)
*** 175,180 ****
--- 175,181 ----
  	fprintf(output, _("  \\g [FILE] or ;         execute query (and send results to file or |pipe)\n"));
  	fprintf(output, _("  \\gset [PREFIX]         execute query and store results in psql variables\n"));
  	fprintf(output, _("  \\q                     quit psql\n"));
+ 	fprintf(output, _("  \\crosstabview [V H [R]] execute query and display results in crosstab\n"));
  	fprintf(output, _("  \\watch [SEC]           execute query every SEC seconds\n"));
  	fprintf(output, "\n");
  
diff --git a/src/bin/psql/print.c b/src/bin/psql/print.c
new file mode 100644
index 05d4b31..b2f8c2b
*** a/src/bin/psql/print.c
--- b/src/bin/psql/print.c
*************** printQuery(const PGresult *result, const
*** 3291,3320 ****
  
  	for (i = 0; i < cont.ncolumns; i++)
  	{
- 		char		align;
- 		Oid			ftype = PQftype(result, i);
- 
- 		switch (ftype)
- 		{
- 			case INT2OID:
- 			case INT4OID:
- 			case INT8OID:
- 			case FLOAT4OID:
- 			case FLOAT8OID:
- 			case NUMERICOID:
- 			case OIDOID:
- 			case XIDOID:
- 			case CIDOID:
- 			case CASHOID:
- 				align = 'r';
- 				break;
- 			default:
- 				align = 'l';
- 				break;
- 		}
- 
  		printTableAddHeader(&cont, PQfname(result, i),
! 							opt->translate_header, align);
  	}
  
  	/* set cells */
--- 3291,3299 ----
  
  	for (i = 0; i < cont.ncolumns; i++)
  	{
  		printTableAddHeader(&cont, PQfname(result, i),
! 							opt->translate_header,
! 							column_type_alignment(PQftype(result, i)));
  	}
  
  	/* set cells */
*************** printQuery(const PGresult *result, const
*** 3356,3361 ****
--- 3335,3365 ----
  	printTableCleanup(&cont);
  }
  
+ char
+ column_type_alignment(Oid ftype)
+ {
+ 	char		align;
+ 
+ 	switch (ftype)
+ 	{
+ 		case INT2OID:
+ 		case INT4OID:
+ 		case INT8OID:
+ 		case FLOAT4OID:
+ 		case FLOAT8OID:
+ 		case NUMERICOID:
+ 		case OIDOID:
+ 		case XIDOID:
+ 		case CIDOID:
+ 		case CASHOID:
+ 			align = 'r';
+ 			break;
+ 		default:
+ 			align = 'l';
+ 			break;
+ 	}
+ 	return align;
+ }
  
  void
  setDecimalLocale(void)
diff --git a/src/bin/psql/print.h b/src/bin/psql/print.h
new file mode 100644
index fd56598..218b185
*** a/src/bin/psql/print.h
--- b/src/bin/psql/print.h
*************** extern FILE *PageOutput(int lines, const
*** 175,181 ****
  extern void ClosePager(FILE *pagerpipe);
  
  extern void html_escaped_print(const char *in, FILE *fout);
! 
  extern void printTableInit(printTableContent *const content,
  			   const printTableOpt *opt, const char *title,
  			   const int ncolumns, const int nrows);
--- 175,181 ----
  extern void ClosePager(FILE *pagerpipe);
  
  extern void html_escaped_print(const char *in, FILE *fout);
! extern char column_type_alignment(Oid);
  extern void printTableInit(printTableContent *const content,
  			   const printTableOpt *opt, const char *title,
  			   const int ncolumns, const int nrows);
diff --git a/src/bin/psql/settings.h b/src/bin/psql/settings.h
new file mode 100644
index 1885bb1..5993c1d
*** a/src/bin/psql/settings.h
--- b/src/bin/psql/settings.h
*************** typedef struct _psqlSettings
*** 90,95 ****
--- 90,99 ----
  
  	char	   *gfname;			/* one-shot file output argument for \g */
  	char	   *gset_prefix;	/* one-shot prefix argument for \gset */
+ 	bool		crosstabview_output;  /* one-shot request to print results in crosstab */
+ 	char		*crosstabview_col_V;  /* one-shot \crosstabview 1st argument */
+ 	char		*crosstabview_col_H;  /* one-shot \crosstabview 2nd argument */
+ 	char		*crosstabview_col_O;  /* one-shot \crosstabview 3nd argument */
  
  	bool		notty;			/* stdin or stdout is not a tty (as determined
  								 * on startup) */
diff --git a/src/bin/psql/tab-complete.c b/src/bin/psql/tab-complete.c
new file mode 100644
index 8c48881..3337256
*** a/src/bin/psql/tab-complete.c
--- b/src/bin/psql/tab-complete.c
*************** psql_completion(const char *text, int st
*** 936,943 ****
  
  	static const char *const backslash_commands[] = {
  		"\\a", "\\connect", "\\conninfo", "\\C", "\\cd", "\\copy", "\\copyright",
! 		"\\d", "\\da", "\\db", "\\dc", "\\dC", "\\dd", "\\ddp", "\\dD",
! 		"\\des", "\\det", "\\deu", "\\dew", "\\dE", "\\df",
  		"\\dF", "\\dFd", "\\dFp", "\\dFt", "\\dg", "\\di", "\\dl", "\\dL",
  		"\\dm", "\\dn", "\\do", "\\dO", "\\dp", "\\drds", "\\ds", "\\dS",
  		"\\dt", "\\dT", "\\dv", "\\du", "\\dx", "\\dy",
--- 936,943 ----
  
  	static const char *const backslash_commands[] = {
  		"\\a", "\\connect", "\\conninfo", "\\C", "\\cd", "\\copy", "\\copyright",
! 		"\\crosstabview", "\\d", "\\da", "\\db", "\\dc", "\\dC", "\\dd", "\\ddp",
! 		"\\dD", "\\des", "\\det", "\\deu", "\\dew", "\\dE", "\\df",
  		"\\dF", "\\dFd", "\\dFp", "\\dFt", "\\dg", "\\di", "\\dl", "\\dL",
  		"\\dm", "\\dn", "\\do", "\\dO", "\\dp", "\\drds", "\\ds", "\\dS",
  		"\\dt", "\\dT", "\\dv", "\\du", "\\dx", "\\dy",

diff --git a/doc/src/sgml/ref/psql-ref.sgml b/doc/src/sgml/ref/psql-ref.sgml
index e4f72a8..2a998b2 100644
--- a/doc/src/sgml/ref/psql-ref.sgml
+++ b/doc/src/sgml/ref/psql-ref.sgml
@@ -2449,6 +2449,95 @@ lo_import 152801
         </listitem>
       </varlistentry>
 
+      <varlistentry>
+        <term><literal>\crosstabview [ [-|+]<replaceable class="parameter">colV</replaceable>  [-|+]<replaceable class="parameter">colH</replaceable> ] </literal></term>
+        <listitem>
+        <para>
+        Execute the current query buffer (like <literal>\g</literal>) and shows the results
+        inside a crosstab grid. The output column <replaceable class="parameter">colV</replaceable>
+        becomes a vertical header and the output column
+        <replaceable class="parameter">colH</replaceable> becomes a horizontal header.
+        The results for the other output columns are projected inside the grid.
+        </para>
+
+        <para>
+        <replaceable class="parameter">colV</replaceable>
+        and <replaceable class="parameter">colH</replaceable> can indicate a
+        column position (starting at 1), or a column name. Normal case folding
+        and quoting rules apply on column names. By default,
+        <replaceable class="parameter">colV</replaceable> is column 1
+        and <replaceable class="parameter">colH</replaceable> is column 2.
+        A query having only one output column cannot be viewed in crosstab, and
+        <replaceable class="parameter">colH</replaceable> must differ from
+        <replaceable class="parameter">colV</replaceable>.
+        </para>
+
+        <para>
+        The vertical header, displayed as the leftmost column,
+        contains the set of all distinct values found in
+        column <replaceable class="parameter">colV</replaceable>, in the order
+        of their first appearance in the query results.
+        </para>
+        <para>
+        The horizontal header, displayed as the first row,
+        contains the set of all distinct non-null values found in
+        column <replaceable class="parameter">colH</replaceable>.  They come
+        by default in their order of appearance in the query results, or in ascending
+        order if a plus (+) sign precedes <replaceable class="parameter">colH</replaceable>,
+        or in descending order if it's a minus (-) sign.
+        </para>
+
+        <para>
+        The query results being tuples of <literal>N</literal> columns
+        (including <replaceable class="parameter">colV</replaceable> and
+        <replaceable class="parameter">colH</replaceable>),
+        for each distinct value <literal>x</literal> of
+        <replaceable class="parameter">colH</replaceable>
+        and each distinct value <literal>y</literal> of
+        <replaceable class="parameter">colV</replaceable>,
+        a cell located at the intersection <literal>(x,y)</literal> in the grid
+        has contents determined by these rules:
+        <itemizedlist>
+        <listitem>
+        <para>
+         if there is no corresponding row in the results such that the value
+         for <replaceable class="parameter">colH</replaceable>
+         is <literal>x</literal> and the value
+         for <replaceable class="parameter">colV</replaceable>
+         is <literal>y</literal>, the cell is empty.
+        </para>
+        </listitem>
+
+        <listitem>
+        <para>
+         if there is exactly one row such that the value
+         for <replaceable class="parameter">colH</replaceable>
+         is <literal>x</literal> and the value
+         for <replaceable class="parameter">colV</replaceable>
+         is <literal>y</literal>, then the <literal>N-2</literal> other
+         columns are displayed in the cell, separated between each other by
+         a space character if needed.
+
+         If <literal>N=2</literal>, the letter <literal>X</literal> is displayed in the cell as
+         if a virtual third column contained that character.
+        </para>
+        </listitem>
+
+        <listitem>
+        <para>
+         if there are several corresponding rows, the behavior is identical to one row
+         except that the values coming from different rows are stacked
+         vertically, rows being separated by newline characters inside
+         the same cell.
+        </para>
+        </listitem>
+
+        </itemizedlist>
+        </para>
+
+        </listitem>
+      </varlistentry>
+
 
       <varlistentry>
         <term><literal>\s [ <replaceable class="parameter">filename</replaceable> ]</literal></term>
diff --git a/src/bin/psql/Makefile b/src/bin/psql/Makefile
index f1336d5..9cb0c4a 100644
--- a/src/bin/psql/Makefile
+++ b/src/bin/psql/Makefile
@@ -23,7 +23,7 @@ override CPPFLAGS := -I. -I$(srcdir) -I$(libpq_srcdir) -I$(top_srcdir)/src/bin/p
 OBJS=	command.o common.o help.o input.o stringutils.o mainloop.o copy.o \
 	startup.o prompt.o variables.o large_obj.o print.o describe.o \
 	tab-complete.o mbprint.o dumputils.o keywords.o kwlookup.o \
-	sql_help.o \
+	sql_help.o crosstabview.o \
 	$(WIN32RES)
 
 
diff --git a/src/bin/psql/command.c b/src/bin/psql/command.c
index 6e8c623..6ba5efa 100644
--- a/src/bin/psql/command.c
+++ b/src/bin/psql/command.c
@@ -46,6 +46,7 @@
 #include "mainloop.h"
 #include "print.h"
 #include "psqlscan.h"
+#include "crosstabview.h"
 #include "settings.h"
 #include "variables.h"
 
@@ -1081,6 +1082,34 @@ exec_command(const char *cmd,
 		free(pw2);
 	}
 
+	/* \crosstabview -- execute a query and display results in crosstab */
+	else if (strcmp(cmd, "crosstabview") == 0)
+	{
+		char	*opt1,
+				*opt2;
+
+		opt1 = psql_scan_slash_option(scan_state,
+									  OT_NORMAL, NULL, false);
+		opt2 = psql_scan_slash_option(scan_state,
+									  OT_NORMAL, NULL, false);
+
+		if (opt1 && !opt2)
+		{
+			psql_error(_("\\%s: missing second argument\n"), cmd);
+			success = false;
+		}
+		else
+		{
+			pset.crosstabview_col_V = opt1 ? pg_strdup(opt1): NULL;
+			pset.crosstabview_col_H = opt2 ? pg_strdup(opt2): NULL;
+			pset.crosstabview_output = true;
+			status = PSQL_CMD_SEND;
+		}
+
+		free(opt1);
+		free(opt2);
+	}
+
 	/* \prompt -- prompt and set variable */
 	else if (strcmp(cmd, "prompt") == 0)
 	{
diff --git a/src/bin/psql/common.c b/src/bin/psql/common.c
index a287eee..d8c0f70 100644
--- a/src/bin/psql/common.c
+++ b/src/bin/psql/common.c
@@ -24,6 +24,7 @@
 #include "command.h"
 #include "copy.h"
 #include "mbprint.h"
+#include "crosstabview.h"
 
 
 static bool ExecQueryUsingCursor(const char *query, double *elapsed_msec);
@@ -906,6 +907,8 @@ PrintQueryResults(PGresult *results)
 			/* store or print the data ... */
 			if (pset.gset_prefix)
 				success = StoreQueryTuple(results);
+			else if (pset.crosstabview_output)
+				success = PrintResultsInCrossTab(results);
 			else
 				success = PrintQueryTuples(results);
 			/* if it's INSERT/UPDATE/DELETE RETURNING, also print status */
@@ -1076,7 +1079,9 @@ SendQuery(const char *query)
 
 		/* but printing results isn't: */
 		if (OK && results)
+		{
 			OK = PrintQueryResults(results);
+		}
 	}
 	else
 	{
@@ -1192,6 +1197,18 @@ sendquery_cleanup:
 		pset.gset_prefix = NULL;
 	}
 
+	/* reset \crosstabview settings */
+	pset.crosstabview_output = false;
+	if (pset.crosstabview_col_V)
+	{
+		free(pset.crosstabview_col_V);
+		pset.crosstabview_col_V = NULL;
+	}
+	if (pset.crosstabview_col_H)
+	{
+		free(pset.crosstabview_col_H);
+		pset.crosstabview_col_H = NULL;
+	}
 	return OK;
 }
 
@@ -1354,7 +1371,25 @@ ExecQueryUsingCursor(const char *query, double *elapsed_msec)
 			is_pager = true;
 		}
 
-		printQuery(results, &my_popt, fout, is_pager, pset.logfile);
+		if (pset.crosstabview_output)
+		{
+			if (ntuples < fetch_count)
+				PrintResultsInCrossTab(results);
+			else
+			{
+				/*
+				  crosstabview is denied if the whole set of rows is not
+				  guaranteed to be fetched in the first iteration, because
+				  it's expected in memory as a single PGresult structure.
+				*/
+				psql_error("\\crosstabview must be used with less than FETCH_COUNT (%d) rows\n",
+					fetch_count);
+				PQclear(results);
+				break;
+			}
+		}
+		else
+			printQuery(results, &my_popt, fout, is_pager, pset.logfile);
 
 		PQclear(results);
 
diff --git a/src/bin/psql/crosstabview.c b/src/bin/psql/crosstabview.c
new file mode 100644
index 0000000..6d13b57
--- /dev/null
+++ b/src/bin/psql/crosstabview.c
@@ -0,0 +1,644 @@
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright (c) 2000-2015, PostgreSQL Global Development Group
+ *
+ * src/bin/psql/crosstabview.c
+ */
+
+#include "common.h"
+#include "pqexpbuffer.h"
+#include "crosstabview.h"
+#include "settings.h"
+
+#include <string.h>
+
+static int
+headerCompare(const void *a, const void *b)
+{
+	return strcmp( ((struct pivot_field*)a)->name,
+				   ((struct pivot_field*)b)->name);
+}
+
+static void
+accumHeader(char* name, int* count, struct pivot_field **sorted_tab, int row_number)
+{
+	struct pivot_field *p;
+
+	/*
+	 * Search for name in sorted_tab. If it doesn't exist, insert it,
+	 * otherwise do nothing.
+	 */
+
+	if (*count >= 1)
+	{
+		p = (struct pivot_field*) bsearch(&name,
+										  *sorted_tab,
+										  *count,
+										  sizeof(struct pivot_field),
+										  headerCompare);
+	}
+	else
+		p=NULL;
+
+	if (!p)
+	{
+		*sorted_tab = pg_realloc(*sorted_tab, sizeof(struct pivot_field) * (1+*count));
+		(*sorted_tab)[*count].name = name;
+		(*sorted_tab)[*count].rank = *count;
+		(*count)++;
+
+		qsort(*sorted_tab,
+			  *count,
+			  sizeof(struct pivot_field),
+			  headerCompare);
+	}
+}
+
+/*
+ * Send a query to sort all column values cast to the Oid passed in a VALUES clause
+ */
+static bool
+sortColumns(Oid coltype, struct pivot_field *columns, int nb_cols, int direction)
+{
+	bool retval = false;
+	PGresult *res = NULL;
+	PQExpBufferData query;
+	int i;
+	Oid *param_types;
+	const char** param_values;
+	int* param_lengths;
+	int* param_formats;
+
+	if (nb_cols < 2 || direction==0)
+		return true;					/* nothing to sort */
+
+	param_types = (Oid*) pg_malloc(nb_cols*sizeof(Oid));
+	param_values = (const char**) pg_malloc(nb_cols*sizeof(char*));
+	param_lengths = (int*) pg_malloc(nb_cols*sizeof(int));
+	param_formats = (int*) pg_malloc(nb_cols*sizeof(int));
+
+	initPQExpBuffer(&query);
+
+	/*
+	 * The query returns the original position of each value in our list,
+	 * ordered by its new position. The value itself is not returned.
+	 */
+	appendPQExpBuffer(&query, "SELECT n FROM (VALUES");
+
+	for (i=1; i <= nb_cols; i++)
+	{
+		if (i < nb_cols)
+			appendPQExpBuffer(&query, "($%d,%d),", i, i);
+		else
+		{
+			appendPQExpBuffer(&query, "($%d,%d)) AS l(x,n) ORDER BY x", i, i);
+			if (direction < 0)
+				appendPQExpBuffer(&query, " DESC");
+		}
+
+		param_types[i-1] = coltype;
+		param_values[i-1] = columns[i-1].name;
+		param_lengths[i-1] = strlen(columns[i-1].name);
+		param_formats[i-1] = 0;
+	}
+
+	res = PQexecParams(pset.db,
+					   query.data,
+					   nb_cols,
+					   param_types,
+					   param_values,
+					   param_lengths,
+					   param_formats,
+					   0);
+
+	if (res)
+	{
+		ExecStatusType status = PQresultStatus(res);
+		if (status == PGRES_TUPLES_OK)
+		{
+			for (i=0; i < PQntuples(res); i++)
+			{
+				int old_pos = atoi(PQgetvalue(res, i, 0));
+
+				if (old_pos < 1 || old_pos > nb_cols || i >= nb_cols)
+				{
+					/*
+					 * A position outside of the range is normally impossible.
+					 * If this happens, we're facing a malfunctioning or hostile
+					 * server or middleware.
+					 */
+					psql_error(_("Unexpected value when sorting horizontal headers"));
+					goto cleanup;
+				}
+				else
+				{
+					columns[old_pos-1].rank = i;
+				}
+			}
+		}
+		else
+		{
+			psql_error(_("Query error when sorting horizontal headers: %s"),
+					   PQerrorMessage(pset.db));
+			goto cleanup;
+		}
+	}
+
+	retval = true;
+
+cleanup:
+	termPQExpBuffer(&query);
+	if (res)
+		PQclear(res);
+	pg_free(param_types);
+	pg_free(param_values);
+	pg_free(param_lengths);
+	pg_free(param_formats);
+	return retval;
+}
+
+static void
+printCrosstab(const PGresult *results,
+			  int num_columns,
+			  struct pivot_field *piv_columns,
+			  int field_for_columns,
+			  int num_rows,
+			  struct pivot_field *piv_rows,
+			  int field_for_rows)
+{
+	printQueryOpt popt = pset.popt;
+	printTableContent cont;
+	int	i, j, rn;
+	char col_align = 'l';		/* alignment for values inside the grid */
+	int* horiz_map;			 	/* map indices from sorted horizontal headers to piv_columns */
+	char** allocated_cells; 	/*  Pointers for cell contents that are allocated
+								 *  in this function, when cells cannot simply point to
+								 *  PQgetvalue(results, ...) */
+
+	printTableInit(&cont, &popt.topt, popt.title, num_columns+1, num_rows);
+
+	/* Step 1: set target column names (horizontal header) */
+
+	/* The name of the first column is kept unchanged by the pivoting */
+	printTableAddHeader(&cont,
+						PQfname(results, field_for_rows),
+						false,
+						column_type_alignment(PQftype(results, field_for_rows)));
+
+	/*
+	 * To iterate over piv_columns[] by piv_columns[].rank, create a reverse map
+	 *  associating each piv_columns[].rank to its index in piv_columns.
+	 *  This avoids an O(N^2) loop later
+	 */
+	horiz_map = (int*) pg_malloc(sizeof(int) * num_columns);
+	for (i = 0; i < num_columns; i++)
+	{
+		horiz_map[piv_columns[i].rank] = i;
+	}
+
+	/*
+	 * In the case of 3 output columns, the contents in the cells are exactly
+	 * the contents of the "value" column (3rd column by default), so their
+	 * alignment is determined by PQftype(). Otherwise the contents are
+	 * made-up strings, so the alignment is 'l'
+	 */
+	if (PQnfields(results) == 3)
+	{
+		int colnum;				/* column placed inside the grid */
+		/*
+		 * find colnum in the permutations of (0,1,2) where colnum is
+		 * neither field_for_rows nor field_for_columns
+		 */
+		switch (field_for_rows)
+		{
+		case 0:
+			colnum = (field_for_columns == 1) ? 2 : 1;
+			break;
+		case 1:
+			colnum = (field_for_columns == 0) ? 2: 0;
+			break;
+		default:				/* should be always 2 */
+			colnum = (field_for_columns == 0) ? 1: 0;
+			break;
+		}
+		col_align = column_type_alignment(PQftype(results, colnum));
+	}
+	else
+		col_align = 'l';
+
+	for (i = 0; i < num_columns; i++)
+	{
+		printTableAddHeader(&cont,
+							piv_columns[horiz_map[i]].name,
+							false,
+							col_align);
+	}
+	pg_free(horiz_map);
+
+	/* Step 2: set row names in the first output column (vertical header) */
+	for (i = 0; i < num_rows; i++)
+	{
+		int k = piv_rows[i].rank;
+		cont.cells[k*(num_columns+1)] = piv_rows[i].name;
+		/* Initialize all cells inside the grid to an empty value */
+		for (j = 0; j < num_columns; j++)
+			cont.cells[k*(num_columns+1)+j+1] = "";
+	}
+	cont.cellsadded = num_rows * (num_columns+1);
+
+	allocated_cells = (char**) pg_malloc0(num_rows * num_columns * sizeof(char*));
+
+	/* Step 3: set all the cells "inside the grid" */
+	for (rn = 0; rn < PQntuples(results); rn++)
+	{
+		char* row_name;
+		char* col_name;
+		int row_number;
+		int col_number;
+		struct pivot_field *p;
+
+		row_number = col_number = -1;
+		/* Find target row */
+		if (!PQgetisnull(results, rn, field_for_rows))
+		{
+			row_name = PQgetvalue(results, rn, field_for_rows);
+			p = (struct pivot_field*) bsearch(&row_name,
+											  piv_rows,
+											  num_rows,
+											  sizeof(struct pivot_field),
+											  headerCompare);
+			if (p)
+				row_number = p->rank;
+		}
+
+		/* Find target column */
+		if (!PQgetisnull(results, rn, field_for_columns))
+		{
+			col_name = PQgetvalue(results, rn, field_for_columns);
+			p = (struct pivot_field*) bsearch(&col_name,
+											  piv_columns,
+											  num_columns,
+											  sizeof(struct pivot_field),
+											  headerCompare);
+			if (p)
+				col_number = p->rank;
+		}
+
+		/* Place value into cell */
+		if (col_number>=0 && row_number>=0)
+		{
+			int idx = 1 + col_number + row_number*(num_columns+1);
+			int src_col = 0;			/* column number in source result */
+			int k = 0;
+
+			do {
+				char *content;
+
+				if (PQnfields(results) == 2)
+				{
+					/*
+					  special case: when the source has only 2 columns, use a
+					  X (cross/checkmark) for the cell content, and set
+					  src_col to a virtual additional column.
+					*/
+					content = "X";
+					src_col = 3;
+				}
+				else if (src_col == field_for_rows || src_col == field_for_columns)
+				{
+					/*
+					  The source values that produce headers are not processed
+					  in this loop, only the values that end up inside the grid.
+					*/
+					src_col++;
+					continue;
+				}
+				else
+				{
+					content = (!PQgetisnull(results, rn, src_col)) ?
+						PQgetvalue(results, rn, src_col) :
+						(popt.nullPrint ? popt.nullPrint : "");
+				}
+
+				if (cont.cells[idx] != NULL && cont.cells[idx][0] != '\0')
+				{
+					/*
+					 * Multiple values for the same (row,col) are projected
+					 * into the same cell. When this happens, separate the
+					 * previous content of the cell from the new value by a
+					 * newline.
+					 */
+					int content_size =
+						strlen(cont.cells[idx])
+						+ 2 			/* room for [CR],LF or space */
+						+ strlen(content)
+						+ 1;			/* '\0' */
+					char *new_content;
+
+					/*
+					 * idx2 is an index into allocated_cells. It differs from
+					 * idx (index into cont.cells), because vertical and
+					 * horizontal headers are included in `cont.cells` but
+					 * excluded from allocated_cells.
+					 */
+					int idx2 = (row_number * num_columns) + col_number;
+
+					if (allocated_cells[idx2] != NULL)
+					{
+						new_content = pg_realloc(allocated_cells[idx2], content_size);
+					}
+					else
+					{
+						/*
+						 * At this point, cont.cells[idx] still contains a
+						 * PQgetvalue() pointer.  Just after, it will contain
+						 * a new pointer maintained in allocated_cells[], and
+						 * freed at the end of this function.
+						 */
+						new_content = pg_malloc(content_size);
+						strcpy(new_content, cont.cells[idx]);
+					}
+					cont.cells[idx] = new_content;
+					allocated_cells[idx2] = new_content;
+
+					/*
+					 * Contents that are on adjacent columns in the source results get
+					 * separated by one space in the target.
+					 * Contents that are on different rows in the source get
+					 * separated by newlines in the target.
+					 */
+					if (k==0)
+						strcat(new_content, "\n");
+					else
+						strcat(new_content, " ");
+					strcat(new_content, content);
+				}
+				else
+				{
+					cont.cells[idx] = content;
+				}
+				k++;
+				src_col++;
+			} while (src_col < PQnfields(results));
+		}
+	}
+
+	printTable(&cont, pset.queryFout, false, pset.logfile);
+	printTableCleanup(&cont);
+
+
+	for (i=0; i < num_rows * num_columns; i++)
+	{
+		if (allocated_cells[i] != NULL)
+			pg_free(allocated_cells[i]);
+	}
+
+	pg_free(allocated_cells);
+}
+
+/*
+ * Compare a user-supplied argument against a field name obtained by PQfname(),
+ * which is already case-folded.
+ * If arg is not enclosed in double quotes, pg_strcasecmp applies, otherwise
+ * do a case-sensitive comparison with these rules:
+ * - double quotes enclosing 'arg' are filtered out
+ * - double quotes inside 'arg' are expected to be doubled
+ */
+static int
+fieldnameCmp(const char* arg, const char* fieldname)
+{
+	const unsigned char* p = (const unsigned char*) arg;
+	const unsigned char* f = (const unsigned char*) fieldname;
+	unsigned char c;
+
+	if (*p++ != '"')
+		return pg_strcasecmp(arg, fieldname);
+
+	while ((c=*p++))
+	{
+		if (c=='"')
+		{
+			if (*p=='"')
+				p++;			/* skip second quote and continue */
+			else if (*p=='\0')
+				return *p-*f;		/* p finishes before f or is identical */
+
+		}
+		if (*f=='\0')
+			return 1;			/* f finishes before p */
+		if (c!=*f)
+			return c-*f;
+		f++;
+	}
+	return (*f=='\0') ? 0 : 1;
+}
+
+
+/*
+ * arg can be a number or a column name, possibly quoted (like in an ORDER BY clause)
+ * Returns:
+ *  on success, the 0-based index of the column
+ *  or -1 if the column number or name is not found in the result's structure,
+ *        or if it's ambiguous (arg corresponding to several columns)
+ */
+static int
+indexOfColumn(const char* arg, PGresult* res)
+{
+	int idx;
+
+	if (strspn(arg, "0123456789") == strlen(arg))
+	{
+		/* if arg contains only digits, it's a column number */
+		idx = atoi(arg) - 1;
+		if (idx < 0  || idx >= PQnfields(res))
+		{
+			psql_error(_("Invalid column number: %s\n"), arg);
+			return -1;
+		}
+	}
+	else
+	{
+		int i;
+		idx = -1;
+		for (i=0; i < PQnfields(res); i++)
+		{
+			if (fieldnameCmp(arg, PQfname(res, i)) == 0)
+			{
+				if (idx>=0)
+				{
+					/* if another idx was already found for the same name */
+					psql_error(_("Ambiguous column name: %s\n"), arg);
+					return -1;
+				}
+				idx = i;
+			}
+		}
+		if (idx == -1)
+		{
+			psql_error(_("Invalid column name: %s\n"), arg);
+			return -1;
+		}
+	}
+	return idx;
+}
+
+bool
+PrintResultsInCrossTab(PGresult* res)
+{
+	/* [-|+]COLV or null */
+	const char* opt_field_for_rows = pset.crosstabview_col_V;
+	/* [-|+]COLH or null */
+	const char* opt_field_for_columns = pset.crosstabview_col_H;
+	int		rn;
+	struct pivot_field	*piv_columns = NULL;
+	struct pivot_field	*piv_rows = NULL;
+	int		num_columns = 0;
+	int		num_rows = 0;
+	bool 	retval = false;
+	int		columns_sort_direction = 0; /* 1:ascending, 0:none, -1:descending */
+	int		rows_sort_direction = 0; /* 1:ascending, 0:none, -1:descending */
+
+	/* 0-based index of the field whose distinct values will become COLUMN headers */
+	int		field_for_columns;
+
+	/* 0-based index of the field whose distinct values will become ROW headers */
+	int		field_for_rows;
+
+	if (PQresultStatus(res) != PGRES_TUPLES_OK)
+		goto error_return;
+
+	if (PQnfields(res) < 2)
+	{
+		psql_error(_("The query must return at least two columns to be shown in crosstab\n"));
+		goto error_return;
+	}
+
+	/* field for rows in crosstab */
+	if (opt_field_for_rows == NULL)
+		field_for_rows = 0;
+	else
+	{
+		if (*opt_field_for_rows == '-')
+		{
+			rows_sort_direction = -1;
+			opt_field_for_rows++;
+		}
+		else if (*opt_field_for_rows == '+')
+		{
+			rows_sort_direction = 1;
+			opt_field_for_rows++;
+		}
+		field_for_rows = indexOfColumn(opt_field_for_rows, res);
+		if (field_for_rows < 0)
+			goto error_return;
+	}
+
+	if (field_for_rows < 0)
+		goto error_return;
+
+	/* field for columns in crosstab */
+	if (opt_field_for_columns == NULL)
+		field_for_columns = 1;
+	else
+	{
+		/*
+		 * descending sort is requested if the column reference is
+		 * preceded with a minus sign
+		 */
+		if (*opt_field_for_columns == '-')
+		{
+			columns_sort_direction = -1;
+			opt_field_for_columns++;
+		}
+		else if (*opt_field_for_columns == '+')
+		{
+			columns_sort_direction = 1;
+			opt_field_for_columns++;
+		}
+		field_for_columns = indexOfColumn(opt_field_for_columns, res);
+		if (field_for_columns < 0)
+			goto error_return;
+	}
+
+
+	if (field_for_columns == field_for_rows)
+	{
+		psql_error(_("The same column cannot be used for both vertical and horizontal headers\n"));
+		goto error_return;
+	}
+
+	/*
+	 * First part: accumulate row names and column names, each into their
+	 * array. Use client-side sort but only to build the set of DISTINCT
+	 * values. The final order displayed depends only on server-side
+	 * sorts.
+	 */
+	for (rn = 0; rn < PQntuples(res); rn++)
+	{
+		if (!PQgetisnull(res, rn, field_for_rows))
+		{
+			accumHeader(PQgetvalue(res, rn, field_for_rows),
+						&num_rows,
+						&piv_rows,
+						rn);
+		}
+
+		if (!PQgetisnull(res, rn, field_for_columns))
+		{
+			accumHeader(PQgetvalue(res, rn, field_for_columns),
+						&num_columns,
+						&piv_columns,
+						rn);
+			if (num_columns > 1600)
+			{
+				psql_error(_("Maximum number of columns (1600) exceeded\n"));
+				goto error_return;
+			}
+		}
+	}
+
+	/*
+	 * Second part: sort the list of target columns on the server.
+	 */
+	if (columns_sort_direction != 0)
+	{
+		if (!sortColumns(PQftype(res, field_for_columns),
+						 piv_columns,
+						 num_columns,
+						 columns_sort_direction))
+			goto error_return;
+	}
+
+
+	/*
+	 * Third part: sort the list of target columns on the server.
+	 */
+	if (rows_sort_direction != 0)
+	{
+		if (!sortColumns(PQftype(res, field_for_rows),
+						 piv_rows,
+						 num_rows,
+						 rows_sort_direction))
+			goto error_return;
+	}
+
+	/*
+	 * Fourth part: print the crosstab'ed results.
+	 */
+	printCrosstab(res,
+				  num_columns,
+				  piv_columns,
+				  field_for_columns,
+				  num_rows,
+				  piv_rows,
+				  field_for_rows);
+
+	retval = true;
+
+error_return:
+	pg_free(piv_columns);
+	pg_free(piv_rows);
+
+	return retval;
+}
diff --git a/src/bin/psql/crosstabview.h b/src/bin/psql/crosstabview.h
new file mode 100644
index 0000000..e8a0e01
--- /dev/null
+++ b/src/bin/psql/crosstabview.h
@@ -0,0 +1,30 @@
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright (c) 2000-2015, PostgreSQL Global Development Group
+ *
+ * src/bin/psql/crosstabview.h
+ */
+
+#ifndef CROSSTABVIEW_H
+#define CROSSTABVIEW_H
+
+struct pivot_field
+{
+	/* Pointer obtained from PGgetvalue() for colV or colH */
+	char*	name;
+
+	/* Rank of the field in its list, starting at 0.
+	 * - For headers stacked vertically, rank=N means it's the
+	 *   Nth distinct field encountered when looping through rows
+	 *   in their initial order.
+	 * - For headers stacked horizontally, rank is obtained
+	 *   by server-side sorting in sortColumns()
+	 */
+	int		rank;
+};
+
+/* prototypes */
+extern bool
+PrintResultsInCrossTab(PGresult* res);
+#endif   /* CROSSTABVIEW_H */
diff --git a/src/bin/psql/help.c b/src/bin/psql/help.c
index 5b63e76..c38d51d 100644
--- a/src/bin/psql/help.c
+++ b/src/bin/psql/help.c
@@ -175,6 +175,7 @@ slashUsage(unsigned short int pager)
 	fprintf(output, _("  \\g [FILE] or ;         execute query (and send results to file or |pipe)\n"));
 	fprintf(output, _("  \\gset [PREFIX]         execute query and store results in psql variables\n"));
 	fprintf(output, _("  \\q                     quit psql\n"));
+	fprintf(output, _("  \\crosstabview [V H]    execute query and display results in crosstab\n"));
 	fprintf(output, _("  \\watch [SEC]           execute query every SEC seconds\n"));
 	fprintf(output, "\n");
 
diff --git a/src/bin/psql/print.c b/src/bin/psql/print.c
index 05d4b31..b2f8c2b 100644
--- a/src/bin/psql/print.c
+++ b/src/bin/psql/print.c
@@ -3291,30 +3291,9 @@ printQuery(const PGresult *result, const printQueryOpt *opt,
 
 	for (i = 0; i < cont.ncolumns; i++)
 	{
-		char		align;
-		Oid			ftype = PQftype(result, i);
-
-		switch (ftype)
-		{
-			case INT2OID:
-			case INT4OID:
-			case INT8OID:
-			case FLOAT4OID:
-			case FLOAT8OID:
-			case NUMERICOID:
-			case OIDOID:
-			case XIDOID:
-			case CIDOID:
-			case CASHOID:
-				align = 'r';
-				break;
-			default:
-				align = 'l';
-				break;
-		}
-
 		printTableAddHeader(&cont, PQfname(result, i),
-							opt->translate_header, align);
+							opt->translate_header,
+							column_type_alignment(PQftype(result, i)));
 	}
 
 	/* set cells */
@@ -3356,6 +3335,31 @@ printQuery(const PGresult *result, const printQueryOpt *opt,
 	printTableCleanup(&cont);
 }
 
+char
+column_type_alignment(Oid ftype)
+{
+	char		align;
+
+	switch (ftype)
+	{
+		case INT2OID:
+		case INT4OID:
+		case INT8OID:
+		case FLOAT4OID:
+		case FLOAT8OID:
+		case NUMERICOID:
+		case OIDOID:
+		case XIDOID:
+		case CIDOID:
+		case CASHOID:
+			align = 'r';
+			break;
+		default:
+			align = 'l';
+			break;
+	}
+	return align;
+}
 
 void
 setDecimalLocale(void)
diff --git a/src/bin/psql/print.h b/src/bin/psql/print.h
index fd565984..218b185 100644
--- a/src/bin/psql/print.h
+++ b/src/bin/psql/print.h
@@ -175,7 +175,7 @@ extern FILE *PageOutput(int lines, const printTableOpt *topt);
 extern void ClosePager(FILE *pagerpipe);
 
 extern void html_escaped_print(const char *in, FILE *fout);
-
+extern char column_type_alignment(Oid);
 extern void printTableInit(printTableContent *const content,
 			   const printTableOpt *opt, const char *title,
 			   const int ncolumns, const int nrows);
diff --git a/src/bin/psql/settings.h b/src/bin/psql/settings.h
index 1885bb1..6069024 100644
--- a/src/bin/psql/settings.h
+++ b/src/bin/psql/settings.h
@@ -90,6 +90,9 @@ typedef struct _psqlSettings
 
 	char	   *gfname;			/* one-shot file output argument for \g */
 	char	   *gset_prefix;	/* one-shot prefix argument for \gset */
+	bool		crosstabview_output;  /* one-shot request to print results in crosstab */
+	char		*crosstabview_col_V;  /* one-shot \crosstabview 1st argument */
+	char		*crosstabview_col_H;  /* one-shot \crosstabview 2nd argument */
 
 	bool		notty;			/* stdin or stdout is not a tty (as determined
 								 * on startup) */
diff --git a/src/bin/psql/tab-complete.c b/src/bin/psql/tab-complete.c
index b58ec14..07ba26c 100644
--- a/src/bin/psql/tab-complete.c
+++ b/src/bin/psql/tab-complete.c
@@ -935,7 +935,8 @@ psql_completion(const char *text, int start, int end)
 	};
 
 	static const char *const backslash_commands[] = {
-		"\\a", "\\connect", "\\conninfo", "\\C", "\\cd", "\\copy", "\\copyright",
+		"\\a", "\\connect", "\\conninfo", "\\C", "\\cd", "\\copy",
+		"\\copyright", "\\crosstabview",
 		"\\d", "\\da", "\\db", "\\dc", "\\dC", "\\dd", "\\ddp", "\\dD",
 		"\\des", "\\det", "\\deu", "\\dew", "\\dE", "\\df",
 		"\\dF", "\\dFd", "\\dFp", "\\dFt", "\\dg", "\\di", "\\dl", "\\dL",

diff --git a/src/bin/psql/crosstabview.c b/src/bin/psql/crosstabview.c
new file mode 100644
index 6d13b57..c9e11c2
*** a/src/bin/psql/crosstabview.c
--- b/src/bin/psql/crosstabview.c
*************** printCrosstab(const PGresult *results,
*** 203,209 ****
  	 * alignment is determined by PQftype(). Otherwise the contents are
  	 * made-up strings, so the alignment is 'l'
  	 */
! 	if (PQnfields(results) == 3)
  	{
  		int colnum;				/* column placed inside the grid */
  		/*
--- 203,213 ----
  	 * alignment is determined by PQftype(). Otherwise the contents are
  	 * made-up strings, so the alignment is 'l'
  	 */
! 	if (PQnfields(results) == 2)
! 	{
! 		col_align = 'c';
! 	}
! 	else if (PQnfields(results) == 3)
  	{
  		int colnum;				/* column placed inside the grid */
  		/*
diff --git a/src/bin/psql/print.c b/src/bin/psql/print.c
new file mode 100644
index b2f8c2b..6e2cc6e
*** a/src/bin/psql/print.c
--- b/src/bin/psql/print.c
*************** print_aligned_text(const printTableConte
*** 1042,1059 ****
  					{
  						/* spaces first */
  						fprintf(fout, "%*s", width_wrap[j] - chars_to_output, "");
- 						fputnbytes(fout,
- 								 (char *) (this_line->ptr + bytes_output[j]),
- 								   bytes_to_output);
  					}
! 					else	/* Left aligned cell */
  					{
! 						/* spaces second */
! 						fputnbytes(fout,
! 								 (char *) (this_line->ptr + bytes_output[j]),
! 								   bytes_to_output);
  					}
  
  					bytes_output[j] += bytes_to_output;
  
  					/* Do we have more text to wrap? */
--- 1042,1059 ----
  					{
  						/* spaces first */
  						fprintf(fout, "%*s", width_wrap[j] - chars_to_output, "");
  					}
! 					else if (cont->aligns[j] == 'c') /* Center aligned cell */
  					{
! 						/* spaces first */
! 						fprintf(fout, "%*s",
! 							 (width_wrap[j] - chars_to_output) / 2, "");
  					}
  
+ 					fputnbytes(fout,
+ 							 (char *) (this_line->ptr + bytes_output[j]),
+ 							   bytes_to_output);
+ 
  					bytes_output[j] += bytes_to_output;
  
  					/* Do we have more text to wrap? */
*************** print_aligned_text(const printTableConte
*** 1083,1095 ****
  				 * If left-aligned, pad out remaining space if needed (not
  				 * last column, and/or wrap marks required).
  				 */
! 				if (cont->aligns[j] != 'r')		/* Left aligned cell */
  				{
! 					if (finalspaces ||
! 						wrap[j] == PRINT_LINE_WRAP_WRAP ||
! 						wrap[j] == PRINT_LINE_WRAP_NEWLINE)
  						fprintf(fout, "%*s",
! 								width_wrap[j] - chars_to_output, "");
  				}
  
  				/* Print right-hand wrap or newline mark */
--- 1083,1104 ----
  				 * If left-aligned, pad out remaining space if needed (not
  				 * last column, and/or wrap marks required).
  				 */
! 				if (finalspaces ||
! 					wrap[j] == PRINT_LINE_WRAP_WRAP ||
! 					wrap[j] == PRINT_LINE_WRAP_NEWLINE)
  				{
! 					if (cont->aligns[j] == 'c')
! 					{
! 						/* last spaces */
  						fprintf(fout, "%*s",
! 								    width_wrap[j] - chars_to_output 
! 								 - ((width_wrap[j] - chars_to_output) / 2 ), "");
! 					}
! 					else if (cont->aligns[j] == 'l')
! 					{
! 						/* last spaces */
! 						fprintf(fout, "%*s", width_wrap[j] - chars_to_output, "");
! 					}
  				}
  
  				/* Print right-hand wrap or newline mark */
*************** html_escaped_print(const char *in, FILE
*** 1778,1783 ****
--- 1787,1805 ----
  	}
  }
  
+ /*
+  * Returns align value in html format
+  */
+ static const char *
+ format_html_align_attr(char align)
+ {
+ 	if (align == 'r')
+ 		return "right";
+ 	else if (align == 'c')
+ 		return "center";
+ 	else
+ 		return "left";
+ }
  
  static void
  print_html_text(const printTableContent *cont, FILE *fout)
*************** print_html_text(const printTableContent
*** 1830,1836 ****
  			fputs("  <tr valign=\"top\">\n", fout);
  		}
  
! 		fprintf(fout, "    <td align=\"%s\">", cont->aligns[(i) % cont->ncolumns] == 'r' ? "right" : "left");
  		/* is string only whitespace? */
  		if ((*ptr)[strspn(*ptr, " \t")] == '\0')
  			fputs("&nbsp; ", fout);
--- 1852,1860 ----
  			fputs("  <tr valign=\"top\">\n", fout);
  		}
  
! 		fprintf(fout, "    <td align=\"%s\">",
! 			    format_html_align_attr(cont->aligns[(i) % cont->ncolumns]));
! 
  		/* is string only whitespace? */
  		if ((*ptr)[strspn(*ptr, " \t")] == '\0')
  			fputs("&nbsp; ", fout);
*************** print_html_vertical(const printTableCont
*** 1916,1922 ****
  		html_escaped_print(cont->headers[i % cont->ncolumns], fout);
  		fputs("</th>\n", fout);
  
! 		fprintf(fout, "    <td align=\"%s\">", cont->aligns[i % cont->ncolumns] == 'r' ? "right" : "left");
  		/* is string only whitespace? */
  		if ((*ptr)[strspn(*ptr, " \t")] == '\0')
  			fputs("&nbsp; ", fout);
--- 1940,1950 ----
  		html_escaped_print(cont->headers[i % cont->ncolumns], fout);
  		fputs("</th>\n", fout);
  
! 
! 
! 		fprintf(fout, "    <td align=\"%s\">", 
! 			    format_html_align_attr(cont->aligns[i % cont->ncolumns]));
! 
  		/* is string only whitespace? */
  		if ((*ptr)[strspn(*ptr, " \t")] == '\0')
  			fputs("&nbsp; ", fout);
*************** asciidoc_escaped_print(const char *in, F
*** 1971,1976 ****
--- 1999,2015 ----
  	}
  }
  
+ static const char *
+ format_asciidoc_align_attr(char align)
+ {
+ 	if (align == 'r')
+ 		return ">l";
+ 	else if (align == 'c')
+ 		return "^l";
+ 	else
+ 		return "<l";
+ }
+ 
  static void
  print_asciidoc_text(const printTableContent *cont, FILE *fout)
  {
*************** print_asciidoc_text(const printTableCont
*** 2001,2007 ****
  		{
  			if (i != 0)
  				fputs(",", fout);
! 			fprintf(fout, "%s", cont->aligns[(i) % cont->ncolumns] == 'r' ? ">l" : "<l");
  		}
  		fputs("\"", fout);
  		switch (opt_border)
--- 2040,2047 ----
  		{
  			if (i != 0)
  				fputs(",", fout);
! 			fprintf(fout, "%s",
! 				    format_asciidoc_align_attr(cont->aligns[(i) % cont->ncolumns]));
  		}
  		fputs("\"", fout);
  		switch (opt_border)
*************** print_asciidoc_vertical(const printTable
*** 2142,2148 ****
  		fputs("<l|", fout);
  		asciidoc_escaped_print(cont->headers[i % cont->ncolumns], fout);
  
! 		fprintf(fout, " %s|", cont->aligns[i % cont->ncolumns] == 'r' ? ">l" : "<l");
  		/* is string only whitespace? */
  		if ((*ptr)[strspn(*ptr, " \t")] == '\0')
  			fputs(" ", fout);
--- 2182,2190 ----
  		fputs("<l|", fout);
  		asciidoc_escaped_print(cont->headers[i % cont->ncolumns], fout);
  
! 		fprintf(fout, " %s|",
! 				    format_asciidoc_align_attr(cont->aligns[(i) % cont->ncolumns]));
! 
  		/* is string only whitespace? */
  		if ((*ptr)[strspn(*ptr, " \t")] == '\0')
  			fputs(" ", fout);
*************** print_latex_longtable_text(const printTa
*** 2343,2349 ****
  
  		for (i = 0; i < cont->ncolumns; i++)
  		{
! 			/* longtable supports either a width (p) or an alignment (l/r) */
  			/* Are we left-justified and was a proportional width specified? */
  			if (*(cont->aligns + i) == 'l' && opt_table_attr)
  			{
--- 2385,2391 ----
  
  		for (i = 0; i < cont->ncolumns; i++)
  		{
! 			/* longtable supports either a width (p) or an alignment (l/c/r) */
  			/* Are we left-justified and was a proportional width specified? */
  			if (*(cont->aligns + i) == 'l' && opt_table_attr)
  			{
*************** printTableInit(printTableContent *const
*** 2950,2957 ****
   * If translate is true, the function will pass the header through gettext.
   * Otherwise, the header will not be translated.
   *
!  * align is either 'l' or 'r', and specifies the alignment for cells in this
!  * column.
   */
  void
  printTableAddHeader(printTableContent *const content, char *header,
--- 2992,2999 ----
   * If translate is true, the function will pass the header through gettext.
   * Otherwise, the header will not be translated.
   *
!  * align is either 'l' or 'c' or'r', and specifies the alignment for cells
!  * in this column.
   */
  void
  printTableAddHeader(printTableContent *const content, char *header,

diff --git a/doc/src/sgml/ref/psql-ref.sgml b/doc/src/sgml/ref/psql-ref.sgml
index 6d0cb3d..563324d 100644
--- a/doc/src/sgml/ref/psql-ref.sgml
+++ b/doc/src/sgml/ref/psql-ref.sgml
@@ -2485,6 +2485,95 @@ lo_import 152801
         </listitem>
       </varlistentry>
 
+      <varlistentry>
+        <term><literal>\crosstabview [ [-|+]<replaceable class="parameter">colV</replaceable>  [-|+]<replaceable class="parameter">colH</replaceable> ] </literal></term>
+        <listitem>
+        <para>
+        Execute the current query buffer (like <literal>\g</literal>) and shows the results
+        inside a crosstab grid. The output column <replaceable class="parameter">colV</replaceable>
+        becomes a vertical header and the output column
+        <replaceable class="parameter">colH</replaceable> becomes a horizontal header.
+        The results for the other output columns are projected inside the grid.
+        </para>
+
+        <para>
+        <replaceable class="parameter">colV</replaceable>
+        and <replaceable class="parameter">colH</replaceable> can indicate a
+        column position (starting at 1), or a column name. Normal case folding
+        and quoting rules apply on column names. By default,
+        <replaceable class="parameter">colV</replaceable> is column 1
+        and <replaceable class="parameter">colH</replaceable> is column 2.
+        A query having only one output column cannot be viewed in crosstab, and
+        <replaceable class="parameter">colH</replaceable> must differ from
+        <replaceable class="parameter">colV</replaceable>.
+        </para>
+
+        <para>
+        The vertical header, displayed as the leftmost column,
+        contains the set of all distinct values found in
+        column <replaceable class="parameter">colV</replaceable>, in the order
+        of their first appearance in the query results.
+        </para>
+        <para>
+        The horizontal header, displayed as the first row,
+        contains the set of all distinct non-null values found in
+        column <replaceable class="parameter">colH</replaceable>.  They come
+        by default in their order of appearance in the query results, or in ascending
+        order if a plus (+) sign precedes <replaceable class="parameter">colH</replaceable>,
+        or in descending order if it's a minus (-) sign.
+        </para>
+
+        <para>
+        The query results being tuples of <literal>N</literal> columns
+        (including <replaceable class="parameter">colV</replaceable> and
+        <replaceable class="parameter">colH</replaceable>),
+        for each distinct value <literal>x</literal> of
+        <replaceable class="parameter">colH</replaceable>
+        and each distinct value <literal>y</literal> of
+        <replaceable class="parameter">colV</replaceable>,
+        a cell located at the intersection <literal>(x,y)</literal> in the grid
+        has contents determined by these rules:
+        <itemizedlist>
+        <listitem>
+        <para>
+         if there is no corresponding row in the results such that the value
+         for <replaceable class="parameter">colH</replaceable>
+         is <literal>x</literal> and the value
+         for <replaceable class="parameter">colV</replaceable>
+         is <literal>y</literal>, the cell is empty.
+        </para>
+        </listitem>
+
+        <listitem>
+        <para>
+         if there is exactly one row such that the value
+         for <replaceable class="parameter">colH</replaceable>
+         is <literal>x</literal> and the value
+         for <replaceable class="parameter">colV</replaceable>
+         is <literal>y</literal>, then the <literal>N-2</literal> other
+         columns are displayed in the cell, separated between each other by
+         a space character if needed.
+
+         If <literal>N=2</literal>, the letter <literal>X</literal> is displayed in the cell as
+         if a virtual third column contained that character.
+        </para>
+        </listitem>
+
+        <listitem>
+        <para>
+         if there are several corresponding rows, the behavior is identical to one row
+         except that the values coming from different rows are stacked
+         vertically, rows being separated by newline characters inside
+         the same cell.
+        </para>
+        </listitem>
+
+        </itemizedlist>
+        </para>
+
+        </listitem>
+      </varlistentry>
+
 
       <varlistentry>
         <term><literal>\s [ <replaceable class="parameter">filename</replaceable> ]</literal></term>
diff --git a/src/bin/psql/Makefile b/src/bin/psql/Makefile
index f1336d5..9cb0c4a 100644
--- a/src/bin/psql/Makefile
+++ b/src/bin/psql/Makefile
@@ -23,7 +23,7 @@ override CPPFLAGS := -I. -I$(srcdir) -I$(libpq_srcdir) -I$(top_srcdir)/src/bin/p
 OBJS=	command.o common.o help.o input.o stringutils.o mainloop.o copy.o \
 	startup.o prompt.o variables.o large_obj.o print.o describe.o \
 	tab-complete.o mbprint.o dumputils.o keywords.o kwlookup.o \
-	sql_help.o \
+	sql_help.o crosstabview.o \
 	$(WIN32RES)
 
 
diff --git a/src/bin/psql/command.c b/src/bin/psql/command.c
index cf6876b..b5ec8af 100644
--- a/src/bin/psql/command.c
+++ b/src/bin/psql/command.c
@@ -39,6 +39,7 @@
 
 #include "common.h"
 #include "copy.h"
+#include "crosstabview.h"
 #include "describe.h"
 #include "help.h"
 #include "input.h"
@@ -364,6 +365,34 @@ exec_command(const char *cmd,
 	else if (strcmp(cmd, "copyright") == 0)
 		print_copyright();
 
+	/* \crosstabview -- execute a query and display results in crosstab */
+	else if (strcmp(cmd, "crosstabview") == 0)
+	{
+		char	*opt1,
+				*opt2;
+
+		opt1 = psql_scan_slash_option(scan_state,
+									  OT_NORMAL, NULL, false);
+		opt2 = psql_scan_slash_option(scan_state,
+									  OT_NORMAL, NULL, false);
+
+		if (opt1 && !opt2)
+		{
+			psql_error(_("\\%s: missing second argument\n"), cmd);
+			success = false;
+		}
+		else
+		{
+			pset.crosstabview_col_V = opt1 ? pg_strdup(opt1): NULL;
+			pset.crosstabview_col_H = opt2 ? pg_strdup(opt2): NULL;
+			pset.crosstabview_output = true;
+			status = PSQL_CMD_SEND;
+		}
+
+		free(opt1);
+		free(opt2);
+	}
+
 	/* \d* commands */
 	else if (cmd[0] == 'd')
 	{
diff --git a/src/bin/psql/common.c b/src/bin/psql/common.c
index a287eee..f5db53d 100644
--- a/src/bin/psql/common.c
+++ b/src/bin/psql/common.c
@@ -24,6 +24,7 @@
 #include "command.h"
 #include "copy.h"
 #include "mbprint.h"
+#include "crosstabview.h"
 
 
 static bool ExecQueryUsingCursor(const char *query, double *elapsed_msec);
@@ -906,6 +907,8 @@ PrintQueryResults(PGresult *results)
 			/* store or print the data ... */
 			if (pset.gset_prefix)
 				success = StoreQueryTuple(results);
+			else if (pset.crosstabview_output)
+				success = PrintResultsInCrossTab(results);
 			else
 				success = PrintQueryTuples(results);
 			/* if it's INSERT/UPDATE/DELETE RETURNING, also print status */
@@ -1192,6 +1195,18 @@ sendquery_cleanup:
 		pset.gset_prefix = NULL;
 	}
 
+	/* reset \crosstabview settings */
+	pset.crosstabview_output = false;
+	if (pset.crosstabview_col_V)
+	{
+		free(pset.crosstabview_col_V);
+		pset.crosstabview_col_V = NULL;
+	}
+	if (pset.crosstabview_col_H)
+	{
+		free(pset.crosstabview_col_H);
+		pset.crosstabview_col_H = NULL;
+	}
 	return OK;
 }
 
@@ -1354,7 +1369,25 @@ ExecQueryUsingCursor(const char *query, double *elapsed_msec)
 			is_pager = true;
 		}
 
-		printQuery(results, &my_popt, fout, is_pager, pset.logfile);
+		if (pset.crosstabview_output)
+		{
+			if (ntuples < fetch_count)
+				PrintResultsInCrossTab(results);
+			else
+			{
+				/*
+				  crosstabview is denied if the whole set of rows is not
+				  guaranteed to be fetched in the first iteration, because
+				  it's expected in memory as a single PGresult structure.
+				*/
+				psql_error("\\crosstabview must be used with less than FETCH_COUNT (%d) rows\n",
+					fetch_count);
+				PQclear(results);
+				break;
+			}
+		}
+		else
+			printQuery(results, &my_popt, fout, is_pager, pset.logfile);
 
 		PQclear(results);
 
diff --git a/src/bin/psql/crosstabview.c b/src/bin/psql/crosstabview.c
new file mode 100644
index 0000000..82f3e2e
--- /dev/null
+++ b/src/bin/psql/crosstabview.c
@@ -0,0 +1,845 @@
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright (c) 2000-2015, PostgreSQL Global Development Group
+ *
+ * src/bin/psql/crosstabview.c
+ */
+
+#include "common.h"
+#include "crosstabview.h"
+#include "pqexpbuffer.h"
+#include "settings.h"
+#include <string.h>
+
+/*
+ * Value/position from the resultset that goes into the horizontal or vertical
+ * crosstabview header.
+ */
+struct pivot_field
+{
+	/*
+	 * Pointer obtained from PQgetvalue() for colV or colH. Each distinct
+	 * value becomes an entry in the vertical header (colV), or horizontal
+	 * header (colH)
+	 */
+	char	   *name;
+
+	/*
+	 * Rank of this value, starting at 0. Initially, it's the relative position
+	 * of the first appearance of this value in the resultset.
+	 * For example, if successive rows contain B,A,C,A,D then it's B:0,A:1,C:2,D:3
+	 * After all values have been gathered, ranks may be updated by serverSort()
+	 */
+	int			rank;
+};
+
+/* Node in avl_tree */
+struct avl_node
+{
+	/* Node contents */
+	struct pivot_field field;
+
+	/*
+	 * Height of this node in the tree (number of nodes on the longest
+	 * path to a leaf).
+	 */
+	int			height;
+
+	/*
+	 * Child nodes. [0] points to left subtree, [1] to right subtree.
+	 * Never NULL, points to the empty node avl_tree.end when no left
+	 * or right value.
+	 */
+	struct avl_node *childs[2];
+};
+
+/*
+ * Control structure for the AVL tree (binary search tree kept
+ * balanced with the AVL algorithm)
+ */
+struct avl_tree
+{
+	int			count;			/* Total number of nodes */
+	int freecnt;
+	struct avl_node *root;		/* root of the tree */
+	struct avl_node *end;		/* Immutable dereferenceable empty tree */
+};
+
+/*
+ * The avl* functions below provide a minimalistic implementation of AVL binary
+ * trees, to efficiently collect the distinct values that will form the horizontal
+ * and vertical headers. It only supports adding new values, no removal or even
+ * search.
+ */
+static void
+avlInit(struct avl_tree *tree)
+{
+	tree->end = (struct avl_node*) pg_malloc0(sizeof(struct avl_node));
+	tree->end->childs[0] = tree->end->childs[1] = tree->end;
+	tree->count = 0;
+	tree->root = tree->end;
+	tree->freecnt=0;
+}
+
+/* Deallocate recursively an AVL tree, starting from node */
+static void
+avlFree(struct avl_tree* tree, struct avl_node* node)
+{
+	if (node->childs[0] != tree->end)
+	{
+		avlFree(tree, node->childs[0]);
+		pg_free(node->childs[0]);
+	}
+	if (node->childs[1] != tree->end)
+	{
+		avlFree(tree, node->childs[1]);
+		pg_free(node->childs[1]);
+	}
+	if (node == tree->root) {
+		/* free the root separately as it's not child of anything */
+		if (node != tree->end)
+			pg_free(node);
+		/* free the tree->end struct only once and when all else is freed */
+		pg_free(tree->end);
+	}
+}
+
+/* Set the height to 1 plus the greatest of left and right heights */
+static void
+avlUpdateHeight(struct avl_node *n)
+{
+	n->height = 1 + (n->childs[0]->height > n->childs[1]->height ?
+					 n->childs[0]->height:
+					 n->childs[1]->height);
+}
+
+/* Rotate a subtree left (dir=0) or right (dir=1). Not recursive */
+static struct avl_node*
+avlRotate(struct avl_node **current, int dir)
+{
+	struct avl_node *before = *current;
+	struct avl_node *after = (*current)->childs[dir];
+
+	*current = after;
+	before->childs[dir] = after->childs[!dir];
+	avlUpdateHeight(before);
+	after->childs[!dir] = before;
+
+	return after;
+}
+
+static int
+avlBalance(struct avl_node *n)
+{
+	return n->childs[0]->height - n->childs[1]->height;
+}
+
+/*
+ * After an insertion, possibly rebalance the tree so that the left and right
+ * node heights don't differ by more than 1.
+ * May update *node.
+ */
+static void
+avlAdjustBalance(struct avl_tree *tree, struct avl_node **node)
+{
+	struct avl_node *current = *node;
+	int b = avlBalance(current)/2;
+	if (b != 0)
+	{
+		int dir = (1 - b)/2;
+		if (avlBalance(current->childs[dir]) == -b)
+		  avlRotate(&current->childs[dir], !dir);
+		current = avlRotate(node, dir);
+	}
+	if (current != tree->end)
+	  avlUpdateHeight(current);
+}
+
+/*
+ * Insert a new value/field, starting from *node, reaching the
+ * correct position in the tree by recursion.
+ * Possibly rebalance the tree and possibly update *node.
+ * Do nothing if the value is already present in the tree.
+ */
+static void
+avlInsertNode(struct avl_tree* tree,
+			  struct avl_node **node,
+			  struct pivot_field field)
+{
+	struct avl_node *current = *node;
+
+	if (current == tree->end)
+	{
+		struct avl_node * new_node = (struct avl_node*)
+			pg_malloc(sizeof(struct avl_node));
+		new_node->height = 1;
+		new_node->field = field;
+		new_node->childs[0] = new_node->childs[1] = tree->end;
+		tree->count++;
+		*node = new_node;
+	}
+	else
+	{
+		int cmp = strcmp(field.name, current->field.name);
+		if (cmp != 0)
+		{
+			avlInsertNode(tree,
+						  cmp > 0 ? &current->childs[1] : &current->childs[0],
+						  field);
+			avlAdjustBalance(tree, node);
+		}
+	}
+}
+
+/* Insert the value into the AVL tree, if it does not preexist */
+static void
+avlMergeValue(struct avl_tree* tree, char* name)
+{
+	struct pivot_field field;
+	field.name = name;
+	field.rank = tree->count;
+	avlInsertNode(tree, &tree->root, field);
+}
+
+/*
+ * Recursively extract node values into the names array, in sorted order with a
+ * left-to-right tree traversal.
+ * Return the next candidate offset to write into the names array.
+ * fields[] must be preallocated to hold tree->count entries
+ */
+static int
+avlCollectFields(struct avl_tree* tree,
+				 struct avl_node* node,
+				 struct pivot_field* fields,
+				 int idx)
+{
+	if (node == tree->end)
+		return idx;
+	idx = avlCollectFields(tree, node->childs[0], fields, idx);
+	fields[idx] = node->field;
+	return avlCollectFields(tree, node->childs[1], fields,  idx+1);
+}
+
+/*
+ * Send a query to sort the list of values in a horizontal or vertical
+ * crosstabview header, and update every source[].rank field with the 
+ * new relative position of each value.
+ * coltype is the type's OID for the column from which the values come.
+ * direction is -1 for descending, 1 for ascending, 0 for no sort.
+ */
+static bool
+serverSort(Oid coltype, struct pivot_field *source, int nb_values, int direction)
+{
+	bool retval = false;
+	PGresult *res = NULL;
+	PQExpBufferData query;
+	int i;
+	Oid *param_types;
+	const char** param_values;
+	int* param_lengths;
+	int* param_formats;
+
+	if (nb_values < 2 || direction==0)
+		return true;					/* nothing to sort */
+
+	param_types = (Oid*) pg_malloc(nb_values*sizeof(Oid));
+	param_values = (const char**) pg_malloc(nb_values*sizeof(char*));
+	param_lengths = (int*) pg_malloc(nb_values*sizeof(int));
+	param_formats = (int*) pg_malloc(nb_values*sizeof(int));
+
+	initPQExpBuffer(&query);
+
+	/*
+	 * The query returns the original position of each value in our list,
+	 * ordered by its new position. The value itself is not returned.
+	 */
+	appendPQExpBufferStr(&query, "SELECT n FROM (VALUES");
+
+	for (i=1; i <= nb_values; i++)
+	{
+		if (i < nb_values)
+			appendPQExpBuffer(&query, "($%d,%d),", i, i);
+		else
+		{
+			appendPQExpBuffer(&query, "($%d,%d)) AS l(x,n) ORDER BY x", i, i);
+			if (direction < 0)
+				appendPQExpBufferStr(&query, " DESC");
+		}
+
+		param_types[i-1] = coltype;
+		param_values[i-1] = source[i-1].name;
+		param_lengths[i-1] = strlen(source[i-1].name);
+		param_formats[i-1] = 0;
+	}
+
+	res = PQexecParams(pset.db,
+					   query.data,
+					   nb_values,
+					   param_types,
+					   param_values,
+					   param_lengths,
+					   param_formats,
+					   0);
+
+	if (res && PQresultStatus(res) == PGRES_TUPLES_OK)
+	{
+		for (i=0; i < PQntuples(res); i++)
+		{
+			int old_pos = atoi(PQgetvalue(res, i, 0));
+
+			if (old_pos < 1 || old_pos > nb_values || i >= nb_values)
+			{
+				/*
+				 * A position outside of the range is normally impossible.
+				 * If this happens, we're facing a malfunctioning or hostile
+				 * server or middleware.
+				 */
+				psql_error(_("Unexpected rank when sorting crosstabview headers"));
+				goto cleanup;
+			}
+			else
+			{
+				source[old_pos-1].rank = i;
+			}
+		}
+	}
+	else
+	{
+		psql_error(_("Query error when sorting crosstabview header: %s"),
+				   PQerrorMessage(pset.db));
+		goto cleanup;
+	}
+
+	retval = true;
+
+cleanup:
+	termPQExpBuffer(&query);
+	if (res)
+		PQclear(res);
+	pg_free(param_types);
+	pg_free(param_values);
+	pg_free(param_lengths);
+	pg_free(param_formats);
+	return retval;
+}
+
+/* for bsearch() inside a sorted array of struct pivot_field */
+static int
+headerCompare(const void *a, const void *b)
+{
+	return strcmp( ((struct pivot_field*)a)->name,
+				   ((struct pivot_field*)b)->name);
+}
+
+
+static void
+printCrosstab(const PGresult *results,
+			  int num_columns,
+			  struct pivot_field *piv_columns,
+			  int field_for_columns,
+			  int num_rows,
+			  struct pivot_field *piv_rows,
+			  int field_for_rows)
+{
+	printQueryOpt popt = pset.popt;
+	printTableContent cont;
+	int	i, j, rn;
+	char col_align = 'l';		/* alignment for values inside the grid */
+	int* horiz_map;			 	/* map indices from sorted horizontal headers to piv_columns */
+	char** allocated_cells; 	/*  Pointers for cell contents that are allocated
+								 *  in this function, when cells cannot simply point to
+								 *  PQgetvalue(results, ...) */
+
+	printTableInit(&cont, &popt.topt, popt.title, num_columns+1, num_rows);
+
+	/* Step 1: set target column names (horizontal header) */
+
+	/* The name of the first column is kept unchanged by the pivoting */
+	printTableAddHeader(&cont,
+						PQfname(results, field_for_rows),
+						false,
+						column_type_alignment(PQftype(results, field_for_rows)));
+
+	/*
+	 * To iterate over piv_columns[] by piv_columns[].rank, create a reverse map
+	 *  associating each piv_columns[].rank to its index in piv_columns.
+	 *  This avoids an O(N^2) loop later
+	 */
+	horiz_map = (int*) pg_malloc(sizeof(int) * num_columns);
+	for (i = 0; i < num_columns; i++)
+	{
+		horiz_map[piv_columns[i].rank] = i;
+	}
+
+	/*
+	 * In the case of 3 output columns, the contents in the cells are exactly
+	 * the contents of the "value" column (3rd column by default), so their
+	 * alignment is determined by PQftype(). Otherwise the contents are
+	 * made-up strings, so the alignment is 'l'
+	 */
+	if (PQnfields(results) == 3)
+	{
+		int colnum;				/* column placed inside the grid */
+		/*
+		 * find colnum in the permutations of (0,1,2) where colnum is
+		 * neither field_for_rows nor field_for_columns
+		 */
+		switch (field_for_rows)
+		{
+		case 0:
+			colnum = (field_for_columns == 1) ? 2 : 1;
+			break;
+		case 1:
+			colnum = (field_for_columns == 0) ? 2: 0;
+			break;
+		default:				/* should be always 2 */
+			colnum = (field_for_columns == 0) ? 1: 0;
+			break;
+		}
+		col_align = column_type_alignment(PQftype(results, colnum));
+	}
+	else
+		col_align = 'l';
+
+	for (i = 0; i < num_columns; i++)
+	{
+		printTableAddHeader(&cont,
+							piv_columns[horiz_map[i]].name,
+							false,
+							col_align);
+	}
+	pg_free(horiz_map);
+
+	/* Step 2: set row names in the first output column (vertical header) */
+	for (i = 0; i < num_rows; i++)
+	{
+		int k = piv_rows[i].rank;
+		cont.cells[k*(num_columns+1)] = piv_rows[i].name;
+		/* Initialize all cells inside the grid to an empty value */
+		for (j = 0; j < num_columns; j++)
+			cont.cells[k*(num_columns+1)+j+1] = "";
+	}
+	cont.cellsadded = num_rows * (num_columns+1);
+
+	allocated_cells = (char**) pg_malloc0(num_rows * num_columns * sizeof(char*));
+
+	/* Step 3: set all the cells "inside the grid" */
+	for (rn = 0; rn < PQntuples(results); rn++)
+	{
+		char* row_name;
+		char* col_name;
+		int row_number;
+		int col_number;
+		struct pivot_field *p;
+
+		row_number = col_number = -1;
+		/* Find target row */
+		if (!PQgetisnull(results, rn, field_for_rows))
+		{
+			row_name = PQgetvalue(results, rn, field_for_rows);
+			p = (struct pivot_field*) bsearch(&row_name,
+											  piv_rows,
+											  num_rows,
+											  sizeof(struct pivot_field),
+											  headerCompare);
+			if (p)
+				row_number = p->rank;
+		}
+
+		/* Find target column */
+		if (!PQgetisnull(results, rn, field_for_columns))
+		{
+			col_name = PQgetvalue(results, rn, field_for_columns);
+			p = (struct pivot_field*) bsearch(&col_name,
+											  piv_columns,
+											  num_columns,
+											  sizeof(struct pivot_field),
+											  headerCompare);
+			if (p)
+				col_number = p->rank;
+		}
+
+		/* Place value into cell */
+		if (col_number>=0 && row_number>=0)
+		{
+			int idx = 1 + col_number + row_number*(num_columns+1);
+			int src_col = 0;			/* column number in source result */
+			int k = 0;
+
+			do {
+				char *content;
+
+				if (PQnfields(results) == 2)
+				{
+					/*
+					  special case: when the source has only 2 columns, use a
+					  X (cross/checkmark) for the cell content, and set
+					  src_col to a virtual additional column.
+					*/
+					content = "X";
+					src_col = 3;
+				}
+				else if (src_col == field_for_rows || src_col == field_for_columns)
+				{
+					/*
+					  The source values that produce headers are not processed
+					  in this loop, only the values that end up inside the grid.
+					*/
+					src_col++;
+					continue;
+				}
+				else
+				{
+					content = (!PQgetisnull(results, rn, src_col)) ?
+						PQgetvalue(results, rn, src_col) :
+						(popt.nullPrint ? popt.nullPrint : "");
+				}
+
+				if (cont.cells[idx] != NULL && cont.cells[idx][0] != '\0')
+				{
+					/*
+					 * Multiple values for the same (row,col) are projected
+					 * into the same cell. When this happens, separate the
+					 * previous content of the cell from the new value by a
+					 * newline.
+					 */
+					int content_size =
+						strlen(cont.cells[idx])
+						+ 2 			/* room for [CR],LF or space */
+						+ strlen(content)
+						+ 1;			/* '\0' */
+					char *new_content;
+
+					/*
+					 * idx2 is an index into allocated_cells. It differs from
+					 * idx (index into cont.cells), because vertical and
+					 * horizontal headers are included in `cont.cells` but
+					 * excluded from allocated_cells.
+					 */
+					int idx2 = (row_number * num_columns) + col_number;
+
+					if (allocated_cells[idx2] != NULL)
+					{
+						new_content = pg_realloc(allocated_cells[idx2], content_size);
+					}
+					else
+					{
+						/*
+						 * At this point, cont.cells[idx] still contains a
+						 * PQgetvalue() pointer.  Just after, it will contain
+						 * a new pointer maintained in allocated_cells[], and
+						 * freed at the end of this function.
+						 */
+						new_content = pg_malloc(content_size);
+						strcpy(new_content, cont.cells[idx]);
+					}
+					cont.cells[idx] = new_content;
+					allocated_cells[idx2] = new_content;
+
+					/*
+					 * Contents that are on adjacent columns in the source results get
+					 * separated by one space in the target.
+					 * Contents that are on different rows in the source get
+					 * separated by newlines in the target.
+					 */
+					if (k==0)
+						strcat(new_content, "\n");
+					else
+						strcat(new_content, " ");
+					strcat(new_content, content);
+				}
+				else
+				{
+					cont.cells[idx] = content;
+				}
+				k++;
+				src_col++;
+			} while (src_col < PQnfields(results));
+		}
+	}
+
+	printTable(&cont, pset.queryFout, false, pset.logfile);
+	printTableCleanup(&cont);
+
+
+	for (i=0; i < num_rows * num_columns; i++)
+	{
+		if (allocated_cells[i] != NULL)
+			pg_free(allocated_cells[i]);
+	}
+
+	pg_free(allocated_cells);
+}
+
+
+/*
+ * Compare a user-supplied argument against a field name obtained by PQfname(),
+ * which is already case-folded.
+ * If arg is not enclosed in double quotes, pg_strcasecmp applies, otherwise
+ * do a case-sensitive comparison with these rules:
+ * - double quotes enclosing 'arg' are filtered out
+ * - double quotes inside 'arg' are expected to be doubled
+ */
+static int
+fieldNameCmp(const char* arg, const char* fieldname)
+{
+	const unsigned char* p = (const unsigned char*) arg;
+	const unsigned char* f = (const unsigned char*) fieldname;
+	unsigned char c;
+
+	if (*p++ != '"')
+		return pg_strcasecmp(arg, fieldname);
+
+	while ((c=*p++))
+	{
+		if (c=='"')
+		{
+			if (*p=='"')
+				p++;			/* skip second quote and continue */
+			else if (*p=='\0')
+				return *p-*f;		/* p finishes before f or is identical */
+
+		}
+		if (*f=='\0')
+			return 1;			/* f finishes before p */
+		if (c!=*f)
+			return c-*f;
+		f++;
+	}
+	return (*f=='\0') ? 0 : 1;
+}
+
+
+/*
+ * arg can be a number or a column name, possibly quoted (like in an ORDER BY clause)
+ * Returns:
+ *  on success, the 0-based index of the column
+ *  or -1 if the column number or name is not found in the result's structure,
+ *        or if it's ambiguous (arg corresponding to several columns)
+ */
+static int
+indexOfColumn(const char* arg, PGresult* res)
+{
+	int idx;
+
+	if (strspn(arg, "0123456789") == strlen(arg))
+	{
+		/* if arg contains only digits, it's a column number */
+		idx = atoi(arg) - 1;
+		if (idx < 0  || idx >= PQnfields(res))
+		{
+			psql_error(_("Invalid column number: %s\n"), arg);
+			return -1;
+		}
+	}
+	else
+	{
+		int i;
+		idx = -1;
+		for (i=0; i < PQnfields(res); i++)
+		{
+			if (fieldNameCmp(arg, PQfname(res, i)) == 0)
+			{
+				if (idx>=0)
+				{
+					/* if another idx was already found for the same name */
+					psql_error(_("Ambiguous column name: %s\n"), arg);
+					return -1;
+				}
+				idx = i;
+			}
+		}
+		if (idx == -1)
+		{
+			psql_error(_("Invalid column name: %s\n"), arg);
+			return -1;
+		}
+	}
+	return idx;
+}
+
+/*
+ * Main function.
+ * Process the data from *res according the display options in pset (global),
+ * to generate the horizontal and vertical headers contents,
+ * then call printCrosstab() for the actual output.
+ */
+bool
+PrintResultsInCrossTab(PGresult* res)
+{
+	/* [-|+]COLV or null */
+	const char* opt_field_for_rows = pset.crosstabview_col_V;
+	/* [-|+]COLH or null */
+	const char* opt_field_for_columns = pset.crosstabview_col_H;
+	int		rn;
+	struct avl_tree	piv_columns;
+	struct avl_tree	piv_rows;
+	struct pivot_field* array_columns = NULL;
+	struct pivot_field* array_rows = NULL;
+	int		num_columns = 0;
+	int		num_rows = 0;
+	bool 	retval = false;
+	int		columns_sort_direction = 0; /* 1:ascending, 0:none, -1:descending */
+	int		rows_sort_direction = 0; /* 1:ascending, 0:none, -1:descending */
+
+	/* 0-based index of the field whose distinct values will become COLUMN headers */
+	int		field_for_columns;
+
+	/* 0-based index of the field whose distinct values will become ROW headers */
+	int		field_for_rows;
+
+	avlInit(&piv_rows);
+	avlInit(&piv_columns);
+
+	if (PQresultStatus(res) != PGRES_TUPLES_OK)
+		goto error_return;
+
+	if (PQnfields(res) < 2)
+	{
+		psql_error(_("The query must return at least two columns to be shown in crosstab\n"));
+		goto error_return;
+	}
+
+	/* field for rows in crosstab */
+	if (opt_field_for_rows == NULL)
+		field_for_rows = 0;
+	else
+	{
+		if (*opt_field_for_rows == '-')
+		{
+			rows_sort_direction = -1;
+			opt_field_for_rows++;
+		}
+		else if (*opt_field_for_rows == '+')
+		{
+			rows_sort_direction = 1;
+			opt_field_for_rows++;
+		}
+		field_for_rows = indexOfColumn(opt_field_for_rows, res);
+		if (field_for_rows < 0)
+			goto error_return;
+	}
+
+	if (field_for_rows < 0)
+		goto error_return;
+
+	/* field for columns in crosstab */
+	if (opt_field_for_columns == NULL)
+		field_for_columns = 1;
+	else
+	{
+		/*
+		 * descending sort is requested if the column reference is
+		 * preceded with a minus sign
+		 */
+		if (*opt_field_for_columns == '-')
+		{
+			columns_sort_direction = -1;
+			opt_field_for_columns++;
+		}
+		else if (*opt_field_for_columns == '+')
+		{
+			columns_sort_direction = 1;
+			opt_field_for_columns++;
+		}
+		field_for_columns = indexOfColumn(opt_field_for_columns, res);
+		if (field_for_columns < 0)
+			goto error_return;
+	}
+
+
+	if (field_for_columns == field_for_rows)
+	{
+		psql_error(_("The same column cannot be used for both vertical and horizontal headers\n"));
+		goto error_return;
+	}
+
+	/*
+	 * First part: accumulate the names that go into the vertical and
+	 * horizontal headers, each into an AVL binary tree to build the set of
+	 * DISTINCT values.
+	 */
+
+	for (rn = 0; rn < PQntuples(res); rn++)
+	{
+		if (!PQgetisnull(res, rn, field_for_rows))
+		{
+			avlMergeValue(&piv_rows,
+						  PQgetvalue(res, rn, field_for_rows));
+			if (rows_sort_direction!=0 && piv_rows.count > 65535)
+			{
+				psql_error(_("Maximum number of rows to sort (65535) exceeded for the vertical header\n"));
+				goto error_return;
+			}
+		}
+
+		if (!PQgetisnull(res, rn, field_for_columns))
+		{
+			avlMergeValue(&piv_columns,
+						  PQgetvalue(res, rn, field_for_columns));
+			if (piv_columns.count > 1600)
+			{
+				psql_error(_("Maximum number of columns (1600) exceeded\n"));
+				goto error_return;
+			}
+		}
+	}
+
+
+	/*
+	 * Second part: Generate sorted arrays from the AVL trees.
+	 */
+
+	num_columns = piv_columns.count;
+	num_rows = piv_rows.count;
+
+	array_columns = (struct pivot_field*) pg_malloc(sizeof(struct pivot_field) * num_columns);
+	array_rows = (struct pivot_field*) pg_malloc(sizeof(struct pivot_field) * num_rows);
+
+	avlCollectFields(&piv_columns, piv_columns.root, array_columns, 0);
+	avlCollectFields(&piv_rows, piv_rows.root, array_rows, 0);
+
+	/*
+	 * Third part: sort (by server-side query) the horizontal and/or vertical
+	 * header when applicable.
+	 */
+	if (columns_sort_direction != 0)
+	{
+		if (!serverSort(PQftype(res, field_for_columns),
+						array_columns,
+						num_columns,
+						columns_sort_direction))
+			goto error_return;
+	}
+
+	if (rows_sort_direction != 0)
+	{
+		if (!serverSort(PQftype(res, field_for_rows),
+						array_rows,
+						num_rows,
+						rows_sort_direction))
+			goto error_return;
+	}
+
+	/*
+	 * Fourth part: print the crosstab'ed results.
+	 */
+	printCrosstab(res,
+				  num_columns,
+				  array_columns,
+				  field_for_columns,
+				  num_rows,
+				  array_rows,
+				  field_for_rows);
+
+	retval = true;
+
+error_return:
+	avlFree(&piv_columns, piv_columns.root);
+	avlFree(&piv_rows, piv_rows.root);
+	pg_free(array_columns);
+	pg_free(array_rows);
+
+	return retval;
+}
diff --git a/src/bin/psql/crosstabview.h b/src/bin/psql/crosstabview.h
new file mode 100644
index 0000000..ccbfa02
--- /dev/null
+++ b/src/bin/psql/crosstabview.h
@@ -0,0 +1,14 @@
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright (c) 2000-2015, PostgreSQL Global Development Group
+ *
+ * src/bin/psql/crosstabview.h
+ */
+
+#ifndef CROSSTABVIEW_H
+#define CROSSTABVIEW_H
+
+/* prototypes */
+extern bool	PrintResultsInCrossTab(PGresult *res);
+#endif   /* CROSSTABVIEW_H */
diff --git a/src/bin/psql/help.c b/src/bin/psql/help.c
index 5f240be..3924046 100644
--- a/src/bin/psql/help.c
+++ b/src/bin/psql/help.c
@@ -175,6 +175,7 @@ slashUsage(unsigned short int pager)
 	fprintf(output, _("  \\g [FILE] or ;         execute query (and send results to file or |pipe)\n"));
 	fprintf(output, _("  \\gset [PREFIX]         execute query and store results in psql variables\n"));
 	fprintf(output, _("  \\q                     quit psql\n"));
+	fprintf(output, _("  \\crosstabview [V H]    execute query and display results in crosstab\n"));
 	fprintf(output, _("  \\watch [SEC]           execute query every SEC seconds\n"));
 	fprintf(output, "\n");
 
diff --git a/src/bin/psql/print.c b/src/bin/psql/print.c
index 05d4b31..b2f8c2b 100644
--- a/src/bin/psql/print.c
+++ b/src/bin/psql/print.c
@@ -3291,30 +3291,9 @@ printQuery(const PGresult *result, const printQueryOpt *opt,
 
 	for (i = 0; i < cont.ncolumns; i++)
 	{
-		char		align;
-		Oid			ftype = PQftype(result, i);
-
-		switch (ftype)
-		{
-			case INT2OID:
-			case INT4OID:
-			case INT8OID:
-			case FLOAT4OID:
-			case FLOAT8OID:
-			case NUMERICOID:
-			case OIDOID:
-			case XIDOID:
-			case CIDOID:
-			case CASHOID:
-				align = 'r';
-				break;
-			default:
-				align = 'l';
-				break;
-		}
-
 		printTableAddHeader(&cont, PQfname(result, i),
-							opt->translate_header, align);
+							opt->translate_header,
+							column_type_alignment(PQftype(result, i)));
 	}
 
 	/* set cells */
@@ -3356,6 +3335,31 @@ printQuery(const PGresult *result, const printQueryOpt *opt,
 	printTableCleanup(&cont);
 }
 
+char
+column_type_alignment(Oid ftype)
+{
+	char		align;
+
+	switch (ftype)
+	{
+		case INT2OID:
+		case INT4OID:
+		case INT8OID:
+		case FLOAT4OID:
+		case FLOAT8OID:
+		case NUMERICOID:
+		case OIDOID:
+		case XIDOID:
+		case CIDOID:
+		case CASHOID:
+			align = 'r';
+			break;
+		default:
+			align = 'l';
+			break;
+	}
+	return align;
+}
 
 void
 setDecimalLocale(void)
diff --git a/src/bin/psql/print.h b/src/bin/psql/print.h
index fd565984..218b185 100644
--- a/src/bin/psql/print.h
+++ b/src/bin/psql/print.h
@@ -175,7 +175,7 @@ extern FILE *PageOutput(int lines, const printTableOpt *topt);
 extern void ClosePager(FILE *pagerpipe);
 
 extern void html_escaped_print(const char *in, FILE *fout);
-
+extern char column_type_alignment(Oid);
 extern void printTableInit(printTableContent *const content,
 			   const printTableOpt *opt, const char *title,
 			   const int ncolumns, const int nrows);
diff --git a/src/bin/psql/settings.h b/src/bin/psql/settings.h
index 1885bb1..6069024 100644
--- a/src/bin/psql/settings.h
+++ b/src/bin/psql/settings.h
@@ -90,6 +90,9 @@ typedef struct _psqlSettings
 
 	char	   *gfname;			/* one-shot file output argument for \g */
 	char	   *gset_prefix;	/* one-shot prefix argument for \gset */
+	bool		crosstabview_output;  /* one-shot request to print results in crosstab */
+	char		*crosstabview_col_V;  /* one-shot \crosstabview 1st argument */
+	char		*crosstabview_col_H;  /* one-shot \crosstabview 2nd argument */
 
 	bool		notty;			/* stdin or stdout is not a tty (as determined
 								 * on startup) */
diff --git a/src/bin/psql/tab-complete.c b/src/bin/psql/tab-complete.c
index df678d5..bdaa92b 100644
--- a/src/bin/psql/tab-complete.c
+++ b/src/bin/psql/tab-complete.c
@@ -1172,7 +1172,8 @@ psql_completion(const char *text, int start, int end)
 
 	/* psql's backslash commands. */
 	static const char *const backslash_commands[] = {
-		"\\a", "\\connect", "\\conninfo", "\\C", "\\cd", "\\copy", "\\copyright",
+		"\\a", "\\connect", "\\conninfo", "\\C", "\\cd", "\\copy",
+		"\\copyright", "\\crosstabview",
 		"\\d", "\\da", "\\db", "\\dc", "\\dC", "\\dd", "\\ddp", "\\dD",
 		"\\des", "\\det", "\\deu", "\\dew", "\\dE", "\\df",
 		"\\dF", "\\dFd", "\\dFp", "\\dFt", "\\dg", "\\di", "\\dl", "\\dL",

diff --git a/doc/src/sgml/ref/psql-ref.sgml b/doc/src/sgml/ref/psql-ref.sgml
index 6d0cb3d..a242ec4 100644
--- a/doc/src/sgml/ref/psql-ref.sgml
+++ b/doc/src/sgml/ref/psql-ref.sgml
@@ -990,6 +990,123 @@ testdb=>
       </varlistentry>
 
       <varlistentry>
+        <term><literal>\crosstabview [
+            [-|+]<replaceable class="parameter">colV</replaceable>
+            [:<replaceable class="parameter">scolV</replaceable>]
+            [-|+]<replaceable class="parameter">colH</replaceable>
+            [:<replaceable class="parameter">scolH</replaceable>]
+            [<replaceable class="parameter">colG1[,colG2...]</replaceable>]
+            ] </literal></term>
+        <listitem>
+        <para>
+        Execute the current query buffer (like <literal>\g</literal>) and shows
+        the results inside a crosstab grid.
+        The output column <replaceable class="parameter">colV</replaceable>
+        becomes a vertical header, optionally sorted by <replaceable class="parameter">scolV</replaceable>,
+        and the output column <replaceable class="parameter">colH</replaceable>
+        becomes a horizontal header, optionally sorted by
+        <replaceable class="parameter">scolH</replaceable>.
+
+        <replaceable class="parameter">colG1[,colG2...]</replaceable>
+        is the list of output columns to project into the grid.
+        By default, all output columns of the query except 
+        <replaceable class="parameter">colV</replaceable> and
+        <replaceable class="parameter">colH</replaceable>
+        are included in this list.
+        </para>
+
+        <para>
+        All columns can be refered to by their position (starting at 1), or by
+        their name. Normal case folding and quoting rules apply on column
+        names. By default,
+        <replaceable class="parameter">colV</replaceable> corresponds to column 1
+        and <replaceable class="parameter">colH</replaceable> to column 2.
+        A query having only one output column cannot be viewed in crosstab, and
+        <replaceable class="parameter">colH</replaceable> must differ from
+        <replaceable class="parameter">colV</replaceable>.
+        </para>
+
+        <para>
+        The vertical header, displayed as the leftmost column,
+        contains the set of all distinct values found in
+        column <replaceable class="parameter">colV</replaceable>, in the order
+        of their first appearance in the query results,
+        or in ascending order if a plus (+) sign precedes
+        <replaceable class="parameter">colV</replaceable>,
+        or in descending order if it's a minus (-) sign.
+        </para>
+        <para>
+        The horizontal header, displayed as the first row,
+        contains the set of all distinct non-null values found in
+        column <replaceable class="parameter">colH</replaceable>.  They come
+        by default in their order of appearance in the query results,
+        or in ascending order if a plus (+) sign precedes
+        <replaceable class="parameter">colH</replaceable>,
+        or in descending order if it's a minus (-) sign.
+
+        Also, they can optionally be sorted by another column, if
+        <replaceable class="parameter">colV</replaceable>
+        (respectively <replaceable class="parameter">colH</replaceable>) is
+        immediately followed by a colon and a reference to another column
+        <replaceable class="parameter">scolV</replaceable>
+        (respectively <replaceable class="parameter">scolH</replaceable>).
+        </para>
+
+        <para>
+        Inside the crosstab grid,
+        given a query output with <literal>N</literal> columns
+        (including <replaceable class="parameter">colV</replaceable> and
+        <replaceable class="parameter">colH</replaceable>),
+        for each distinct value <literal>x</literal> of
+        <replaceable class="parameter">colH</replaceable>
+        and each distinct value <literal>y</literal> of
+        <replaceable class="parameter">colV</replaceable>,
+        the contents of a cell located at the intersection
+        <literal>(x,y)</literal> is determined by these rules:
+        <itemizedlist>
+        <listitem>
+        <para>
+         if there is no corresponding row in the query results such that the
+         value for <replaceable class="parameter">colH</replaceable>
+         is <literal>x</literal> and the value
+         for <replaceable class="parameter">colV</replaceable>
+         is <literal>y</literal>, the cell is empty.
+        </para>
+        </listitem>
+
+        <listitem>
+        <para>
+         if there is exactly one row such that the value
+         for <replaceable class="parameter">colH</replaceable>
+         is <literal>x</literal> and the value
+         for <replaceable class="parameter">colV</replaceable>
+         is <literal>y</literal>, then the <literal>N-2</literal> other
+         columns or the columns listed in
+         <replaceable class="parameter">colG1[,colG2...]</replaceable>
+         are displayed in the cell, separated between each other by
+         a space character if needed.
+
+         If <literal>N=2</literal>, the letter <literal>X</literal> is displayed
+         in the cell as if a virtual third column contained that character.
+        </para>
+        </listitem>
+
+        <listitem>
+        <para>
+         if there are several corresponding rows, the behavior is identical to
+         the case of one row except that the values coming from different rows
+         are stacked vertically, the different source rows being separated by
+         newline characters inside the cell.
+        </para>
+        </listitem>
+
+        </itemizedlist>
+        </para>
+
+        </listitem>
+      </varlistentry>
+
+      <varlistentry>
         <term><literal>\d[S+] [ <link linkend="APP-PSQL-patterns"><replaceable class="parameter">pattern</replaceable></link> ]</literal></term>
 
         <listitem>
diff --git a/src/bin/psql/Makefile b/src/bin/psql/Makefile
index 66e14fb..9d29fe1 100644
--- a/src/bin/psql/Makefile
+++ b/src/bin/psql/Makefile
@@ -23,7 +23,7 @@ override CPPFLAGS := -I. -I$(srcdir) -I$(libpq_srcdir) -I$(top_srcdir)/src/bin/p
 OBJS=	command.o common.o help.o input.o stringutils.o mainloop.o copy.o \
 	startup.o prompt.o variables.o large_obj.o print.o describe.o \
 	tab-complete.o mbprint.o dumputils.o keywords.o kwlookup.o \
-	sql_help.o \
+	sql_help.o crosstabview.o \
 	$(WIN32RES)
 
 
diff --git a/src/bin/psql/command.c b/src/bin/psql/command.c
index 9750a5b..e4db76e 100644
--- a/src/bin/psql/command.c
+++ b/src/bin/psql/command.c
@@ -39,6 +39,7 @@
 
 #include "common.h"
 #include "copy.h"
+#include "crosstabview.h"
 #include "describe.h"
 #include "help.h"
 #include "input.h"
@@ -364,6 +365,39 @@ exec_command(const char *cmd,
 	else if (strcmp(cmd, "copyright") == 0)
 		print_copyright();
 
+	/* \crosstabview -- execute a query and display results in crosstab */
+	else if (strcmp(cmd, "crosstabview") == 0)
+	{
+		char	*opt1,
+			*opt2,
+			*opt3;
+
+		opt1 = psql_scan_slash_option(scan_state,
+									  OT_NORMAL, NULL, false);
+		opt2 = psql_scan_slash_option(scan_state,
+									  OT_NORMAL, NULL, false);
+		opt3 = psql_scan_slash_option(scan_state,
+									  OT_NORMAL, NULL, false);
+
+		if (opt1 && !opt2)
+		{
+			psql_error(_("\\%s: missing second argument\n"), cmd);
+			success = false;
+		}
+		else
+		{
+			pset.crosstabview_col_V = opt1 ? pg_strdup(opt1): NULL;
+			pset.crosstabview_col_H = opt2 ? pg_strdup(opt2): NULL;
+			pset.crosstabview_cols_grid = opt3 ? pg_strdup(opt3): NULL;
+			pset.crosstabview_output = true;
+			status = PSQL_CMD_SEND;
+		}
+
+		free(opt1);
+		free(opt2);
+		free(opt3);
+	}
+
 	/* \d* commands */
 	else if (cmd[0] == 'd')
 	{
diff --git a/src/bin/psql/common.c b/src/bin/psql/common.c
index 2cb2e9b..b368883 100644
--- a/src/bin/psql/common.c
+++ b/src/bin/psql/common.c
@@ -24,6 +24,7 @@
 #include "command.h"
 #include "copy.h"
 #include "mbprint.h"
+#include "crosstabview.h"
 
 
 static bool ExecQueryUsingCursor(const char *query, double *elapsed_msec);
@@ -906,6 +907,8 @@ PrintQueryResults(PGresult *results)
 			/* store or print the data ... */
 			if (pset.gset_prefix)
 				success = StoreQueryTuple(results);
+			else if (pset.crosstabview_output)
+				success = PrintResultsInCrossTab(results);
 			else
 				success = PrintQueryTuples(results);
 			/* if it's INSERT/UPDATE/DELETE RETURNING, also print status */
@@ -1192,6 +1195,23 @@ sendquery_cleanup:
 		pset.gset_prefix = NULL;
 	}
 
+	/* reset \crosstabview settings */
+	pset.crosstabview_output = false;
+	if (pset.crosstabview_col_V)
+	{
+		free(pset.crosstabview_col_V);
+		pset.crosstabview_col_V = NULL;
+	}
+	if (pset.crosstabview_col_H)
+	{
+		free(pset.crosstabview_col_H);
+		pset.crosstabview_col_H = NULL;
+	}
+	if (pset.crosstabview_cols_grid)
+	{
+		free(pset.crosstabview_cols_grid);
+		pset.crosstabview_cols_grid = NULL;
+	}
 	return OK;
 }
 
@@ -1354,7 +1374,25 @@ ExecQueryUsingCursor(const char *query, double *elapsed_msec)
 			is_pager = true;
 		}
 
-		printQuery(results, &my_popt, fout, is_pager, pset.logfile);
+		if (pset.crosstabview_output)
+		{
+			if (ntuples < fetch_count)
+				PrintResultsInCrossTab(results);
+			else
+			{
+				/*
+				  crosstabview is denied if the whole set of rows is not
+				  guaranteed to be fetched in the first iteration, because
+				  it's expected in memory as a single PGresult structure.
+				*/
+				psql_error("\\crosstabview must be used with less than FETCH_COUNT (%d) rows\n",
+					fetch_count);
+				PQclear(results);
+				break;
+			}
+		}
+		else
+			printQuery(results, &my_popt, fout, is_pager, pset.logfile);
 
 		PQclear(results);
 
diff --git a/src/bin/psql/crosstabview.c b/src/bin/psql/crosstabview.c
new file mode 100644
index 0000000..65b10ff
--- /dev/null
+++ b/src/bin/psql/crosstabview.c
@@ -0,0 +1,1038 @@
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright (c) 2000-2016, PostgreSQL Global Development Group
+ *
+ * src/bin/psql/crosstabview.c
+ */
+
+#include "common.h"
+#include "crosstabview.h"
+#include "pqexpbuffer.h"
+#include "settings.h"
+#include <string.h>
+
+/*
+ * Value/position from the resultset that goes into the horizontal or vertical
+ * crosstabview header.
+ */
+struct pivot_field
+{
+	/*
+	 * Pointer obtained from PQgetvalue() for colV or colH. Each distinct
+	 * value becomes an entry in the vertical header (colV), or horizontal
+	 * header (colH)
+	 */
+	char	   *name;
+
+	/*
+	 * When a sort is requested on an alternative column, this holds
+	 * PQgetvalue() for the sort column and the first row
+	 * from which <name> is obtained
+	 */
+	char	   *sort_value;
+
+	/*
+	 * Rank of this value, starting at 0. Initially, it's the relative position
+	 * of the first appearance of this value in the resultset.
+	 * For example, if successive rows contain B,A,C,A,D then it's B:0,A:1,C:2,D:3
+	 * After all values have been gathered, ranks may be updated by serverSort()
+	 */
+	int			rank;
+};
+
+/* Node in avl_tree */
+struct avl_node
+{
+	/* Node contents */
+	struct pivot_field field;
+
+	/*
+	 * Height of this node in the tree (number of nodes on the longest
+	 * path to a leaf).
+	 */
+	int			height;
+
+	/*
+	 * Child nodes. [0] points to left subtree, [1] to right subtree.
+	 * Never NULL, points to the empty node avl_tree.end when no left
+	 * or right value.
+	 */
+	struct avl_node *childs[2];
+};
+
+/*
+ * Control structure for the AVL tree (binary search tree kept
+ * balanced with the AVL algorithm)
+ */
+struct avl_tree
+{
+	int			count;			/* Total number of nodes */
+	struct avl_node *root;		/* root of the tree */
+	struct avl_node *end;		/* Immutable dereferenceable empty tree */
+};
+
+/*
+ * The avl* functions below provide a minimalistic implementation of AVL binary
+ * trees, to efficiently collect the distinct values that will form the horizontal
+ * and vertical headers. It only supports adding new values, no removal or even
+ * search.
+ */
+static void
+avlInit(struct avl_tree *tree)
+{
+	tree->end = (struct avl_node*) pg_malloc0(sizeof(struct avl_node));
+	tree->end->childs[0] = tree->end->childs[1] = tree->end;
+	tree->count = 0;
+	tree->root = tree->end;
+}
+
+/* Deallocate recursively an AVL tree, starting from node */
+static void
+avlFree(struct avl_tree* tree, struct avl_node* node)
+{
+	if (node->childs[0] != tree->end)
+	{
+		avlFree(tree, node->childs[0]);
+		pg_free(node->childs[0]);
+	}
+	if (node->childs[1] != tree->end)
+	{
+		avlFree(tree, node->childs[1]);
+		pg_free(node->childs[1]);
+	}
+	if (node == tree->root) {
+		/* free the root separately as it's not child of anything */
+		if (node != tree->end)
+			pg_free(node);
+		/* free the tree->end struct only once and when all else is freed */
+		pg_free(tree->end);
+	}
+}
+
+/* Set the height to 1 plus the greatest of left and right heights */
+static void
+avlUpdateHeight(struct avl_node *n)
+{
+	n->height = 1 + (n->childs[0]->height > n->childs[1]->height ?
+					 n->childs[0]->height:
+					 n->childs[1]->height);
+}
+
+/* Rotate a subtree left (dir=0) or right (dir=1). Not recursive */
+static struct avl_node*
+avlRotate(struct avl_node **current, int dir)
+{
+	struct avl_node *before = *current;
+	struct avl_node *after = (*current)->childs[dir];
+
+	*current = after;
+	before->childs[dir] = after->childs[!dir];
+	avlUpdateHeight(before);
+	after->childs[!dir] = before;
+
+	return after;
+}
+
+static int
+avlBalance(struct avl_node *n)
+{
+	return n->childs[0]->height - n->childs[1]->height;
+}
+
+/*
+ * After an insertion, possibly rebalance the tree so that the left and right
+ * node heights don't differ by more than 1.
+ * May update *node.
+ */
+static void
+avlAdjustBalance(struct avl_tree *tree, struct avl_node **node)
+{
+	struct avl_node *current = *node;
+	int b = avlBalance(current)/2;
+	if (b != 0)
+	{
+		int dir = (1 - b)/2;
+		if (avlBalance(current->childs[dir]) == -b)
+		  avlRotate(&current->childs[dir], !dir);
+		current = avlRotate(node, dir);
+	}
+	if (current != tree->end)
+	  avlUpdateHeight(current);
+}
+
+/*
+ * Insert a new value/field, starting from *node, reaching the
+ * correct position in the tree by recursion.
+ * Possibly rebalance the tree and possibly update *node.
+ * Do nothing if the value is already present in the tree.
+ */
+static void
+avlInsertNode(struct avl_tree* tree,
+			  struct avl_node **node,
+			  struct pivot_field field)
+{
+	struct avl_node *current = *node;
+
+	if (current == tree->end)
+	{
+		struct avl_node * new_node = (struct avl_node*)
+			pg_malloc(sizeof(struct avl_node));
+		new_node->height = 1;
+		new_node->field = field;
+		new_node->childs[0] = new_node->childs[1] = tree->end;
+		tree->count++;
+		*node = new_node;
+	}
+	else
+	{
+		int cmp = strcmp(field.name, current->field.name);
+		if (cmp != 0)
+		{
+			avlInsertNode(tree,
+						  cmp > 0 ? &current->childs[1] : &current->childs[0],
+						  field);
+			avlAdjustBalance(tree, node);
+		}
+	}
+}
+
+/* Insert the value into the AVL tree, if it does not preexist */
+static void
+avlMergeValue(struct avl_tree* tree, char* name, char* sort_value)
+{
+	struct pivot_field field;
+	field.name = name;
+	field.rank = tree->count;
+	field.sort_value = sort_value;
+	avlInsertNode(tree, &tree->root, field);
+}
+
+/*
+ * Recursively extract node values into the names array, in sorted order with a
+ * left-to-right tree traversal.
+ * Return the next candidate offset to write into the names array.
+ * fields[] must be preallocated to hold tree->count entries
+ */
+static int
+avlCollectFields(struct avl_tree* tree,
+				 struct avl_node* node,
+				 struct pivot_field* fields,
+				 int idx)
+{
+	if (node == tree->end)
+		return idx;
+	idx = avlCollectFields(tree, node->childs[0], fields, idx);
+	fields[idx] = node->field;
+	return avlCollectFields(tree, node->childs[1], fields,  idx+1);
+}
+
+/*
+ * Send a query to sort the list of values in a horizontal or vertical
+ * crosstabview header, and update every source[].rank field with the
+ * new relative position of each value.
+ * coltype is the type's OID for the column from which the values come.
+ * direction is -1 for descending, 1 for ascending, 0 for no sort.
+ */
+static bool
+serverSort(Oid coltype, struct pivot_field *source, int nb_values, int direction)
+{
+	bool retval = false;
+	PGresult *res = NULL;
+	PQExpBufferData query;
+	int i;
+	Oid *param_types;
+	const char** param_values;
+	int* param_formats;
+
+	if (nb_values < 2 || direction==0)
+		return true;					/* nothing to sort */
+
+	param_types = (Oid*) pg_malloc(nb_values*sizeof(Oid));
+	param_values = (const char**) pg_malloc(nb_values*sizeof(char*));
+	param_formats = (int*) pg_malloc(nb_values*sizeof(int));
+
+	initPQExpBuffer(&query);
+
+	/*
+	 * The query returns the original position of each value in our list,
+	 * ordered by its new position. The value itself is not returned.
+	 */
+	appendPQExpBufferStr(&query, "SELECT n FROM (VALUES");
+
+	for (i=0; i < nb_values; i++)
+	{
+		appendPQExpBuffer(&query, "($%d,%d)", i+1, i+1);
+		if (i < nb_values-1)
+			appendPQExpBufferChar(&query, ',');
+		param_types[i] = coltype;
+		param_values[i] = source[i].sort_value;
+		param_formats[i] = 0;
+	}
+
+	appendPQExpBuffer(&query, ") AS l(x,n) ORDER BY x %s",
+					  direction < 0 ? "DESC" : "ASC");
+
+	res = PQexecParams(pset.db,
+					   query.data,
+					   nb_values,
+					   param_types,
+					   param_values,
+					   NULL,	/* lengths not necessary for text format */
+					   param_formats,
+					   0);
+
+	if (res && PQresultStatus(res) == PGRES_TUPLES_OK)
+	{
+		for (i=0; i < PQntuples(res); i++)
+		{
+			int old_pos = atoi(PQgetvalue(res, i, 0));
+
+			if (old_pos < 1 || old_pos > nb_values || i >= nb_values)
+			{
+				/*
+				 * A position outside of the range is normally impossible.
+				 * If this happens, we're facing a malfunctioning or hostile
+				 * server or middleware.
+				 */
+				psql_error(_("Unexpected rank when sorting crosstabview headers\n"));
+				goto cleanup;
+			}
+			else
+			{
+				source[old_pos-1].rank = i;
+			}
+		}
+	}
+	else
+	{
+		psql_error(_("Query error when sorting crosstabview header: %s"),
+				   PQerrorMessage(pset.db));
+		goto cleanup;
+	}
+
+	retval = true;
+
+cleanup:
+	termPQExpBuffer(&query);
+	if (res)
+		PQclear(res);
+	pg_free(param_types);
+	pg_free(param_values);
+	pg_free(param_formats);
+	return retval;
+}
+
+/* for bsearch() inside a sorted array of struct pivot_field */
+static int
+headerCompare(const void *a, const void *b)
+{
+	return strcmp( ((struct pivot_field*)a)->name,
+				   ((struct pivot_field*)b)->name);
+}
+
+
+/*
+ * Output the pivoted resultset with the printTable* functions
+ */
+static void
+printCrosstab(const PGresult *results,
+			  int num_columns,
+			  struct pivot_field *piv_columns,
+			  int field_for_columns,
+			  int num_rows,
+			  struct pivot_field *piv_rows,
+			  int field_for_rows,
+			  int *colsG,
+			  int colsG_num)
+{
+	printQueryOpt popt = pset.popt;
+	printTableContent cont;
+	int	i, j, rn;
+	char col_align = 'l';		/* alignment for values inside the grid */
+	int* horiz_map;			 	/* map indices from sorted horizontal headers to piv_columns */
+	char** allocated_cells; 	/*  Pointers for cell contents that are allocated
+								 *  in this function, when cells cannot simply point to
+								 *  PQgetvalue(results, ...) */
+
+	printTableInit(&cont, &popt.topt, popt.title, num_columns+1, num_rows);
+
+	/* Step 1: set target column names (horizontal header) */
+
+	/* The name of the first column is kept unchanged by the pivoting */
+	printTableAddHeader(&cont,
+						PQfname(results, field_for_rows),
+						false,
+						column_type_alignment(PQftype(results, field_for_rows)));
+
+	/*
+	 * To iterate over piv_columns[] by piv_columns[].rank, create a reverse map
+	 *  associating each piv_columns[].rank to its index in piv_columns.
+	 *  This avoids an O(N^2) loop later
+	 */
+	horiz_map = (int*) pg_malloc(sizeof(int) * num_columns);
+	for (i = 0; i < num_columns; i++)
+	{
+		horiz_map[piv_columns[i].rank] = i;
+	}
+
+
+	/*
+	 * In the common case of only one field projected into the cells, the
+	 * display alignment depends on its PQftype(). Otherwise the contents are
+	 * made-up strings, so the alignment is 'l'
+	 */
+	if (colsG_num == 1)
+		col_align = column_type_alignment(PQftype(results, colsG[0]));
+	else
+		col_align = 'l';
+
+	for (i = 0; i < num_columns; i++)
+	{
+		printTableAddHeader(&cont,
+							piv_columns[horiz_map[i]].name,
+							false,
+							col_align);
+	}
+	pg_free(horiz_map);
+
+	/* Step 2: set row names in the first output column (vertical header) */
+	for (i = 0; i < num_rows; i++)
+	{
+		int k = piv_rows[i].rank;
+		cont.cells[k*(num_columns+1)] = piv_rows[i].name;
+		/* Initialize all cells inside the grid to an empty value */
+		for (j = 0; j < num_columns; j++)
+			cont.cells[k*(num_columns+1)+j+1] = "";
+	}
+	cont.cellsadded = num_rows * (num_columns+1);
+
+	allocated_cells = (char**) pg_malloc0(num_rows * num_columns * sizeof(char*));
+
+	/* Step 3: set all the cells "inside the grid" */
+	for (rn = 0; rn < PQntuples(results); rn++)
+	{
+		char* row_name;
+		char* col_name;
+		int row_number;
+		int col_number;
+		struct pivot_field *p;
+
+		row_number = col_number = -1;
+		/* Find target row */
+		if (!PQgetisnull(results, rn, field_for_rows))
+		{
+			row_name = PQgetvalue(results, rn, field_for_rows);
+			p = (struct pivot_field*) bsearch(&row_name,
+											  piv_rows,
+											  num_rows,
+											  sizeof(struct pivot_field),
+											  headerCompare);
+			if (p)
+				row_number = p->rank;
+		}
+
+		/* Find target column */
+		if (!PQgetisnull(results, rn, field_for_columns))
+		{
+			col_name = PQgetvalue(results, rn, field_for_columns);
+			p = (struct pivot_field*) bsearch(&col_name,
+											  piv_columns,
+											  num_columns,
+											  sizeof(struct pivot_field),
+											  headerCompare);
+			if (p)
+				col_number = p->rank;
+		}
+
+		/* Place value into cell */
+		if (col_number>=0 && row_number>=0)
+		{
+			int idx = 1 + col_number + row_number*(num_columns+1);
+			int src_col = 0;			/* column number in source result */
+
+			/*
+			 * special case: when the source has only 2 columns, use a
+			 * X (cross/checkmark) for the cell content, and set
+			 * src_col to a virtual additional column.
+			 */
+			if (PQnfields(results) == 2)
+				src_col = -1;
+
+			for (i=0; i<colsG_num || src_col==-1; i++)
+			{
+				char *content;
+
+				if (src_col == -1)
+				{
+					content = "X";
+				}
+				else
+				{
+					src_col = colsG[i];
+
+					content = (!PQgetisnull(results, rn, src_col)) ?
+						PQgetvalue(results, rn, src_col) :
+						(popt.nullPrint ? popt.nullPrint : "");
+				}
+
+				if (cont.cells[idx] != NULL && cont.cells[idx][0] != '\0')
+				{
+					/*
+					 * Multiple values for the same (row,col) are projected
+					 * into the same cell. When this happens, separate the
+					 * previous content of the cell from the new value by a
+					 * newline.
+					 */
+					int content_size =
+						strlen(cont.cells[idx])
+						+ 2 			/* room for [CR],LF or space */
+						+ strlen(content)
+						+ 1;			/* '\0' */
+					char *new_content;
+
+					/*
+					 * idx2 is an index into allocated_cells. It differs from
+					 * idx (index into cont.cells), because vertical and
+					 * horizontal headers are included in `cont.cells` but
+					 * excluded from allocated_cells.
+					 */
+					int idx2 = (row_number * num_columns) + col_number;
+
+					if (allocated_cells[idx2] != NULL)
+					{
+						new_content = pg_realloc(allocated_cells[idx2], content_size);
+					}
+					else
+					{
+						/*
+						 * At this point, cont.cells[idx] still contains a
+						 * PQgetvalue() pointer.  Just after, it will contain
+						 * a new pointer maintained in allocated_cells[], and
+						 * freed at the end of this function.
+						 */
+						new_content = pg_malloc(content_size);
+						strcpy(new_content, cont.cells[idx]);
+					}
+					cont.cells[idx] = new_content;
+					allocated_cells[idx2] = new_content;
+
+					/*
+					 * Contents that are on adjacent columns in the source results get
+					 * separated by one space in the target.
+					 * Contents that are on different rows in the source get
+					 * separated by newlines in the target.
+					 */
+					if (i==0)
+						strcat(new_content, "\n");
+					else
+						strcat(new_content, " ");
+					strcat(new_content, content);
+				}
+				else
+				{
+					cont.cells[idx] = content;
+				}
+
+				/* special case of the "virtual column" for checkmark */
+				if (src_col == -1)
+					break;
+			}
+		}
+	}
+
+	printTable(&cont, pset.queryFout, false, pset.logfile);
+	printTableCleanup(&cont);
+
+
+	for (i=0; i < num_rows * num_columns; i++)
+	{
+		if (allocated_cells[i] != NULL)
+			pg_free(allocated_cells[i]);
+	}
+
+	pg_free(allocated_cells);
+}
+
+
+/*
+ * Compare a user-supplied argument against a field name obtained by PQfname(),
+ * which is already case-folded.
+ * If arg is not enclosed in double quotes, pg_strcasecmp applies, otherwise
+ * do a case-sensitive comparison with these rules:
+ * - double quotes enclosing 'arg' are filtered out
+ * - double quotes inside 'arg' are expected to be doubled
+ */
+static bool
+fieldNameEquals(const char *arg, const char *fieldname)
+{
+	const char* p = arg;
+	const char* f = fieldname;
+	char c;
+
+	if (*p++ != '"')
+		return !pg_strcasecmp(arg, fieldname);
+
+	while ((c = *p++))
+	{
+		if (c == '"')
+		{
+			if (*p == '"')
+				p++;			/* skip second quote and continue */
+			else if (*p == '\0')
+				return (*f == '\0');	/* p is shorter than f, or is identical */
+		}
+		if (*f == '\0')
+			return false;			/* f is shorter than p */
+		if (c != *f)				/* found one byte that differs */
+			return false;
+		f++;
+	}
+	return (*f=='\0');
+}
+
+/*
+ * arg can be a number or a column name, possibly quoted (like in an ORDER BY clause)
+ * Returns:
+ *  on success, the 0-based index of the column
+ *  or -1 if the column number or name is not found in the result's structure,
+ *        or if it's ambiguous (arg corresponding to several columns)
+ */
+static int
+indexOfColumn(const char *arg, PGresult *res)
+{
+	int idx;
+
+	if (strspn(arg, "0123456789") == strlen(arg))
+	{
+		/* if arg contains only digits, it's a column number */
+		idx = atoi(arg) - 1;
+		if (idx < 0  || idx >= PQnfields(res))
+		{
+			psql_error(_("Invalid column number: %s\n"), arg);
+			return -1;
+		}
+	}
+	else
+	{
+		int i;
+		idx = -1;
+		for (i=0; i < PQnfields(res); i++)
+		{
+			if (fieldNameEquals(arg, PQfname(res, i)))
+			{
+				if (idx>=0)
+				{
+					/* if another idx was already found for the same name */
+					psql_error(_("Ambiguous column name: %s\n"), arg);
+					return -1;
+				}
+				idx = i;
+			}
+		}
+		if (idx == -1)
+		{
+			psql_error(_("Invalid column name: %s\n"), arg);
+			return -1;
+		}
+	}
+	return idx;
+}
+
+/*
+ * Parse col1[<sep>col2][<sep>col3]...
+ * where colN can be:
+ * - a number from 1 to PQnfields(res)
+ * - an unquoted column name matching (case insensitively) one of PQfname(res,...)
+ * - a quoted column name matching (case sensitively) one of PQfname(res,...)
+ * max_columns: 0 if no maximum
+ */
+static int
+parseColumnRefs(char* arg,
+				PGresult *res,
+				int **col_numbers,
+				int max_columns,
+				char separator)
+{
+	char *p = arg;
+	char c;
+	int col_num = -1;
+	int nb_cols = 0;
+	char* field_start = NULL;
+	*col_numbers = NULL;
+	while ((c = *p) != '\0')
+	{
+		bool quoted_field = false;
+		field_start = p;
+
+		/* first char */
+		if (c == '"')
+		{
+			quoted_field = true;
+			p++;
+		}
+
+		while ((c = *p) != '\0')
+		{
+			if (c == separator && !quoted_field)
+				break;
+			if (c == '"')		/* end of field or embedded double quote */
+			{
+				p++;
+				if (*p == '"')
+				{
+					if (quoted_field)
+					{
+						p++;
+						continue;
+					}
+				}
+				else if (quoted_field && *p == separator)
+					break;
+			}
+			p += PQmblen(p, pset.encoding);
+		}
+
+		if (p != field_start)
+		{
+			/* look up the column and add its index into *col_numbers */
+			if (max_columns != 0 && nb_cols == max_columns)
+			{
+				psql_error(_("No more than %d column references expected\n"), max_columns);
+				goto errfail;
+			}
+			c = *p;
+			*p = '\0';
+			col_num = indexOfColumn(field_start, res);
+			*p = c;
+			if (col_num < 0)
+				goto errfail;
+			*col_numbers = (int*)pg_realloc(*col_numbers, (1+nb_cols)*sizeof(int));
+			(*col_numbers)[nb_cols++] = col_num;
+		}
+		else
+		{
+			psql_error(_("Empty column reference\n"));
+			goto errfail;
+		}
+
+		if (*p)
+			p += PQmblen(p, pset.encoding);
+	}
+	return nb_cols;
+
+errfail:
+	pg_free(*col_numbers);
+	*col_numbers = NULL;
+	return -1;
+}
+
+
+/*
+ * Main function.
+ * Process the data from *res according the display options in pset (global),
+ * to generate the horizontal and vertical headers contents,
+ * then call printCrosstab() for the actual output.
+ */
+bool
+PrintResultsInCrossTab(PGresult* res)
+{
+	/* [-|+]COLV or null */
+	char* opt_field_for_rows = pset.crosstabview_col_V;
+	/* [-|+]COLH or null */
+	char* opt_field_for_columns = pset.crosstabview_col_H;
+	int		rn;
+	struct avl_tree	piv_columns;
+	struct avl_tree	piv_rows;
+	struct pivot_field* array_columns = NULL;
+	struct pivot_field* array_rows = NULL;
+	int		num_columns = 0;
+	int		num_rows = 0;
+	bool 	retval = false;
+	int		columns_sort_direction; /* 1:ascending, 0:none, -1:descending */
+	int		rows_sort_direction;    /* 1:ascending, 0:none, -1:descending */
+	int		*colsV = NULL, *colsH = NULL, *colsG = NULL;
+	int		colsG_num;
+	int		nn;
+
+	/* 0-based index of the field whose distinct values will become COLUMN headers */
+	int		field_for_columns = -1;
+	int		sort_field_for_columns = -1;
+
+	/* 0-based index of the field whose distinct values will become ROW headers */
+	int		field_for_rows = -1;
+	int		sort_field_for_rows = -1;
+
+	avlInit(&piv_rows);
+	avlInit(&piv_columns);
+
+	if (res == NULL)
+	{
+		psql_error(_("No result\n"));
+		goto error_return;
+	}
+
+	if (PQresultStatus(res) != PGRES_TUPLES_OK)
+	{
+		psql_error(_("The query must return results to be shown in crosstab\n"));
+		goto error_return;
+	}
+
+	if (PQnfields(res) < 2)
+	{
+		psql_error(_("The query must return at least two columns to be shown in crosstab\n"));
+		goto error_return;
+	}
+
+	/*
+	 * Arguments processing for the vertical header (1st arg)
+	 * displayed in the left-most column. Determine:
+	 * - the sort direction if any
+	 * - the field number of that column in the PGresult
+	 * - the field number of the associated sort column if any
+	 */
+
+	if (opt_field_for_rows == NULL)
+	{
+		field_for_rows = sort_field_for_rows = 0;
+		rows_sort_direction = 0;
+	}
+	else
+	{
+		if (*opt_field_for_rows == '-')
+		{
+			rows_sort_direction = -1;
+			opt_field_for_rows++;
+		}
+		else if (*opt_field_for_rows == '+')
+		{
+			rows_sort_direction = 1;
+			opt_field_for_rows++;
+		}
+		else
+			rows_sort_direction = 0;
+
+		nn = parseColumnRefs(opt_field_for_rows, res, &colsV, 2, ':');
+		if (nn < 0)
+			goto error_return;
+		if (nn==1)
+		{
+			field_for_rows = colsV[0];
+			sort_field_for_rows = field_for_rows;
+		}
+		else
+		{
+			field_for_rows = colsV[0];
+			sort_field_for_rows = colsV[1];
+			if (rows_sort_direction == 0)
+			{
+				psql_error(_("Sort column specified without a sort direction\n"));
+				goto error_return;
+			}
+		}
+	}
+
+	if (field_for_rows < 0)
+		goto error_return;
+
+	/*
+	 * Arguments processing for the horizontal header (2nd arg)
+	 * (pivoted column that gets displayed as the first row).
+	 * Determine:
+	 * - the sort direction if any
+	 * - the field number of that column in the PGresult
+	 * - the field number of the associated sort column if any
+	 */
+
+	if (opt_field_for_columns == NULL)
+	{
+		field_for_columns = sort_field_for_columns = 1;
+		columns_sort_direction = 0;
+	}
+	else
+	{
+		/*
+		 * descending sort is requested if the column reference is
+		 * preceded with a minus sign
+		 */
+		if (*opt_field_for_columns == '-')
+		{
+			columns_sort_direction = -1;
+			opt_field_for_columns++;
+		}
+		else if (*opt_field_for_columns == '+')
+		{
+			columns_sort_direction = 1;
+			opt_field_for_columns++;
+		}
+		else
+			columns_sort_direction = 0;
+
+		nn = parseColumnRefs(opt_field_for_columns, res, &colsH, 2, ':');
+		if (nn <= 0)
+			goto error_return;
+		if (nn==1)
+		{
+			field_for_columns = colsH[0];
+			sort_field_for_columns = field_for_columns;
+		}
+		else
+		{
+			field_for_columns = colsH[0];
+			sort_field_for_columns = colsH[1];
+			if (columns_sort_direction == 0)
+			{
+				psql_error(_("Sort column specified without a sort direction\n"));
+				goto error_return;
+			}
+		}
+
+		if (field_for_columns < 0)
+			goto error_return;
+	}
+
+	if (field_for_columns == field_for_rows)
+	{
+		psql_error(_("The same column cannot be used for both vertical and horizontal headers\n"));
+		goto error_return;
+	}
+
+	/*
+	 * Arguments processing for the columns aside from headers (3rd arg)
+	 * Determine the columns to display in the grid and their order.
+	 */
+	if (pset.crosstabview_cols_grid == NULL)
+	{
+		/*
+		 * By defaut, all the fields from PGresult get displayed into the grid,
+		 * except the two fields that go into the vertical and horizontal
+		 * headers.
+		 */
+		if (PQnfields(res) > 2)
+		{
+			int i, j=0;
+			colsG = (int*)pg_malloc(sizeof(int) * (PQnfields(res)-2));
+			for (i=0; i<PQnfields(res); i++)
+			{
+				if (i!=field_for_rows && i!=field_for_columns)
+					colsG[j++] = i;
+			}
+			colsG_num = PQnfields(res)-2;
+		}
+		else
+		{
+			colsG = NULL;
+			colsG_num = 0;
+		}
+	}
+	else
+	{
+		/*
+		 * Non-default case: a list of fields is given.
+		 * Parse that list to determine the fields to display into the grid,
+		 * and in what order.
+		 * The list format is colA[,colB[,colC...]]
+		 */
+		colsG_num = parseColumnRefs(pset.crosstabview_cols_grid,
+									res, &colsG, PQnfields(res), ',');
+		if (colsG_num <= 0)
+			goto error_return;
+	}
+
+	/*
+	 * First part: accumulate the names that go into the vertical and
+	 * horizontal headers, each into an AVL binary tree to build the set of
+	 * DISTINCT values.
+	 */
+
+	for (rn = 0; rn < PQntuples(res); rn++)
+	{
+		if (!PQgetisnull(res, rn, field_for_rows))
+		{
+			avlMergeValue(&piv_rows,
+						  PQgetvalue(res, rn, field_for_rows),
+						  PQgetvalue(res, rn, sort_field_for_rows));
+
+			if (rows_sort_direction!=0 && piv_rows.count > 65535)
+			{
+				psql_error(_("Maximum number of rows to sort (65535) exceeded for the vertical header\n"));
+				goto error_return;
+			}
+		}
+
+		if (!PQgetisnull(res, rn, field_for_columns))
+		{
+			avlMergeValue(&piv_columns,
+						  PQgetvalue(res, rn, field_for_columns),
+						  PQgetvalue(res, rn, sort_field_for_columns));
+
+			if (piv_columns.count > 1600)
+			{
+				psql_error(_("Maximum number of columns (1600) exceeded\n"));
+				goto error_return;
+			}
+		}
+	}
+
+
+	/*
+	 * Second part: Generate sorted arrays from the AVL trees.
+	 */
+
+	num_columns = piv_columns.count;
+	num_rows = piv_rows.count;
+
+	array_columns = (struct pivot_field*) pg_malloc(sizeof(struct pivot_field) * num_columns);
+	array_rows = (struct pivot_field*) pg_malloc(sizeof(struct pivot_field) * num_rows);
+
+	avlCollectFields(&piv_columns, piv_columns.root, array_columns, 0);
+	avlCollectFields(&piv_rows, piv_rows.root, array_rows, 0);
+
+	/*
+	 * Third part: sort (by server-side query) the horizontal and/or vertical
+	 * header when applicable.
+	 */
+	if (columns_sort_direction != 0)
+	{
+		if (!serverSort(PQftype(res, sort_field_for_columns),
+						array_columns,
+						num_columns,
+						columns_sort_direction))
+			goto error_return;
+	}
+
+	if (rows_sort_direction != 0)
+	{
+		if (!serverSort(PQftype(res, sort_field_for_rows),
+						array_rows,
+						num_rows,
+						rows_sort_direction))
+			goto error_return;
+	}
+
+	/*
+	 * Fourth part: print the crosstab'ed results.
+	 */
+	printCrosstab(res,
+				  num_columns,
+				  array_columns,
+				  field_for_columns,
+				  num_rows,
+				  array_rows,
+				  field_for_rows,
+				  colsG,
+				  colsG_num);
+
+	retval = true;
+
+error_return:
+	avlFree(&piv_columns, piv_columns.root);
+	avlFree(&piv_rows, piv_rows.root);
+	pg_free(array_columns);
+	pg_free(array_rows);
+	pg_free(colsV);
+	pg_free(colsH);
+	pg_free(colsG);
+
+	return retval;
+}
diff --git a/src/bin/psql/crosstabview.h b/src/bin/psql/crosstabview.h
new file mode 100644
index 0000000..d374cfe
--- /dev/null
+++ b/src/bin/psql/crosstabview.h
@@ -0,0 +1,14 @@
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright (c) 2000-2016, PostgreSQL Global Development Group
+ *
+ * src/bin/psql/crosstabview.h
+ */
+
+#ifndef CROSSTABVIEW_H
+#define CROSSTABVIEW_H
+
+/* prototypes */
+extern bool	PrintResultsInCrossTab(PGresult *res);
+#endif   /* CROSSTABVIEW_H */
diff --git a/src/bin/psql/help.c b/src/bin/psql/help.c
index 59f6f25..26afa68 100644
--- a/src/bin/psql/help.c
+++ b/src/bin/psql/help.c
@@ -175,6 +175,7 @@ slashUsage(unsigned short int pager)
 	fprintf(output, _("  \\g [FILE] or ;         execute query (and send results to file or |pipe)\n"));
 	fprintf(output, _("  \\gset [PREFIX]         execute query and store results in psql variables\n"));
 	fprintf(output, _("  \\q                     quit psql\n"));
+	fprintf(output, _("  \\crosstabview [V H]    execute query and display results in crosstab\n"));
 	fprintf(output, _("  \\watch [SEC]           execute query every SEC seconds\n"));
 	fprintf(output, "\n");
 
diff --git a/src/bin/psql/print.c b/src/bin/psql/print.c
index 8958903..f3d9a83 100644
--- a/src/bin/psql/print.c
+++ b/src/bin/psql/print.c
@@ -3291,30 +3291,9 @@ printQuery(const PGresult *result, const printQueryOpt *opt,
 
 	for (i = 0; i < cont.ncolumns; i++)
 	{
-		char		align;
-		Oid			ftype = PQftype(result, i);
-
-		switch (ftype)
-		{
-			case INT2OID:
-			case INT4OID:
-			case INT8OID:
-			case FLOAT4OID:
-			case FLOAT8OID:
-			case NUMERICOID:
-			case OIDOID:
-			case XIDOID:
-			case CIDOID:
-			case CASHOID:
-				align = 'r';
-				break;
-			default:
-				align = 'l';
-				break;
-		}
-
 		printTableAddHeader(&cont, PQfname(result, i),
-							opt->translate_header, align);
+							opt->translate_header,
+							column_type_alignment(PQftype(result, i)));
 	}
 
 	/* set cells */
@@ -3356,6 +3335,31 @@ printQuery(const PGresult *result, const printQueryOpt *opt,
 	printTableCleanup(&cont);
 }
 
+char
+column_type_alignment(Oid ftype)
+{
+	char		align;
+
+	switch (ftype)
+	{
+		case INT2OID:
+		case INT4OID:
+		case INT8OID:
+		case FLOAT4OID:
+		case FLOAT8OID:
+		case NUMERICOID:
+		case OIDOID:
+		case XIDOID:
+		case CIDOID:
+		case CASHOID:
+			align = 'r';
+			break;
+		default:
+			align = 'l';
+			break;
+	}
+	return align;
+}
 
 void
 setDecimalLocale(void)
diff --git a/src/bin/psql/print.h b/src/bin/psql/print.h
index 868fcdd..4f3d85a 100644
--- a/src/bin/psql/print.h
+++ b/src/bin/psql/print.h
@@ -175,7 +175,7 @@ extern FILE *PageOutput(int lines, const printTableOpt *topt);
 extern void ClosePager(FILE *pagerpipe);
 
 extern void html_escaped_print(const char *in, FILE *fout);
-
+extern char column_type_alignment(Oid);
 extern void printTableInit(printTableContent *const content,
 			   const printTableOpt *opt, const char *title,
 			   const int ncolumns, const int nrows);
diff --git a/src/bin/psql/settings.h b/src/bin/psql/settings.h
index 20a6470..9b7f7c4 100644
--- a/src/bin/psql/settings.h
+++ b/src/bin/psql/settings.h
@@ -90,6 +90,10 @@ typedef struct _psqlSettings
 
 	char	   *gfname;			/* one-shot file output argument for \g */
 	char	   *gset_prefix;	/* one-shot prefix argument for \gset */
+	bool		crosstabview_output;  /* one-shot request to print results in crosstab */
+	char		*crosstabview_col_V;  /* one-shot \crosstabview 1st argument */
+	char		*crosstabview_col_H;  /* one-shot \crosstabview 2nd argument */
+	char		*crosstabview_cols_grid;  /* one-shot \crosstabview 3nd argument */
 
 	bool		notty;			/* stdin or stdout is not a tty (as determined
 								 * on startup) */
diff --git a/src/bin/psql/tab-complete.c b/src/bin/psql/tab-complete.c
index f09e65c..50cf55f 100644
--- a/src/bin/psql/tab-complete.c
+++ b/src/bin/psql/tab-complete.c
@@ -1272,7 +1272,8 @@ psql_completion(const char *text, int start, int end)
 
 	/* psql's backslash commands. */
 	static const char *const backslash_commands[] = {
-		"\\a", "\\connect", "\\conninfo", "\\C", "\\cd", "\\copy", "\\copyright",
+		"\\a", "\\connect", "\\conninfo", "\\C", "\\cd", "\\copy",
+		"\\copyright", "\\crosstabview",
 		"\\d", "\\da", "\\db", "\\dc", "\\dC", "\\dd", "\\ddp", "\\dD",
 		"\\des", "\\det", "\\deu", "\\dew", "\\dE", "\\df",
 		"\\dF", "\\dFd", "\\dFp", "\\dFt", "\\dg", "\\di", "\\dl", "\\dL",

diff --git a/doc/src/sgml/ref/psql-ref.sgml b/doc/src/sgml/ref/psql-ref.sgml
index 6d0cb3d..a242ec4 100644
--- a/doc/src/sgml/ref/psql-ref.sgml
+++ b/doc/src/sgml/ref/psql-ref.sgml
@@ -990,6 +990,123 @@ testdb=>
       </varlistentry>
 
       <varlistentry>
+        <term><literal>\crosstabview [
+            [-|+]<replaceable class="parameter">colV</replaceable>
+            [:<replaceable class="parameter">scolV</replaceable>]
+            [-|+]<replaceable class="parameter">colH</replaceable>
+            [:<replaceable class="parameter">scolH</replaceable>]
+            [<replaceable class="parameter">colG1[,colG2...]</replaceable>]
+            ] </literal></term>
+        <listitem>
+        <para>
+        Execute the current query buffer (like <literal>\g</literal>) and shows
+        the results inside a crosstab grid.
+        The output column <replaceable class="parameter">colV</replaceable>
+        becomes a vertical header, optionally sorted by <replaceable class="parameter">scolV</replaceable>,
+        and the output column <replaceable class="parameter">colH</replaceable>
+        becomes a horizontal header, optionally sorted by
+        <replaceable class="parameter">scolH</replaceable>.
+
+        <replaceable class="parameter">colG1[,colG2...]</replaceable>
+        is the list of output columns to project into the grid.
+        By default, all output columns of the query except 
+        <replaceable class="parameter">colV</replaceable> and
+        <replaceable class="parameter">colH</replaceable>
+        are included in this list.
+        </para>
+
+        <para>
+        All columns can be refered to by their position (starting at 1), or by
+        their name. Normal case folding and quoting rules apply on column
+        names. By default,
+        <replaceable class="parameter">colV</replaceable> corresponds to column 1
+        and <replaceable class="parameter">colH</replaceable> to column 2.
+        A query having only one output column cannot be viewed in crosstab, and
+        <replaceable class="parameter">colH</replaceable> must differ from
+        <replaceable class="parameter">colV</replaceable>.
+        </para>
+
+        <para>
+        The vertical header, displayed as the leftmost column,
+        contains the set of all distinct values found in
+        column <replaceable class="parameter">colV</replaceable>, in the order
+        of their first appearance in the query results,
+        or in ascending order if a plus (+) sign precedes
+        <replaceable class="parameter">colV</replaceable>,
+        or in descending order if it's a minus (-) sign.
+        </para>
+        <para>
+        The horizontal header, displayed as the first row,
+        contains the set of all distinct non-null values found in
+        column <replaceable class="parameter">colH</replaceable>.  They come
+        by default in their order of appearance in the query results,
+        or in ascending order if a plus (+) sign precedes
+        <replaceable class="parameter">colH</replaceable>,
+        or in descending order if it's a minus (-) sign.
+
+        Also, they can optionally be sorted by another column, if
+        <replaceable class="parameter">colV</replaceable>
+        (respectively <replaceable class="parameter">colH</replaceable>) is
+        immediately followed by a colon and a reference to another column
+        <replaceable class="parameter">scolV</replaceable>
+        (respectively <replaceable class="parameter">scolH</replaceable>).
+        </para>
+
+        <para>
+        Inside the crosstab grid,
+        given a query output with <literal>N</literal> columns
+        (including <replaceable class="parameter">colV</replaceable> and
+        <replaceable class="parameter">colH</replaceable>),
+        for each distinct value <literal>x</literal> of
+        <replaceable class="parameter">colH</replaceable>
+        and each distinct value <literal>y</literal> of
+        <replaceable class="parameter">colV</replaceable>,
+        the contents of a cell located at the intersection
+        <literal>(x,y)</literal> is determined by these rules:
+        <itemizedlist>
+        <listitem>
+        <para>
+         if there is no corresponding row in the query results such that the
+         value for <replaceable class="parameter">colH</replaceable>
+         is <literal>x</literal> and the value
+         for <replaceable class="parameter">colV</replaceable>
+         is <literal>y</literal>, the cell is empty.
+        </para>
+        </listitem>
+
+        <listitem>
+        <para>
+         if there is exactly one row such that the value
+         for <replaceable class="parameter">colH</replaceable>
+         is <literal>x</literal> and the value
+         for <replaceable class="parameter">colV</replaceable>
+         is <literal>y</literal>, then the <literal>N-2</literal> other
+         columns or the columns listed in
+         <replaceable class="parameter">colG1[,colG2...]</replaceable>
+         are displayed in the cell, separated between each other by
+         a space character if needed.
+
+         If <literal>N=2</literal>, the letter <literal>X</literal> is displayed
+         in the cell as if a virtual third column contained that character.
+        </para>
+        </listitem>
+
+        <listitem>
+        <para>
+         if there are several corresponding rows, the behavior is identical to
+         the case of one row except that the values coming from different rows
+         are stacked vertically, the different source rows being separated by
+         newline characters inside the cell.
+        </para>
+        </listitem>
+
+        </itemizedlist>
+        </para>
+
+        </listitem>
+      </varlistentry>
+
+      <varlistentry>
         <term><literal>\d[S+] [ <link linkend="APP-PSQL-patterns"><replaceable class="parameter">pattern</replaceable></link> ]</literal></term>
 
         <listitem>
diff --git a/src/bin/psql/Makefile b/src/bin/psql/Makefile
index 66e14fb..9d29fe1 100644
--- a/src/bin/psql/Makefile
+++ b/src/bin/psql/Makefile
@@ -23,7 +23,7 @@ override CPPFLAGS := -I. -I$(srcdir) -I$(libpq_srcdir) -I$(top_srcdir)/src/bin/p
 OBJS=	command.o common.o help.o input.o stringutils.o mainloop.o copy.o \
 	startup.o prompt.o variables.o large_obj.o print.o describe.o \
 	tab-complete.o mbprint.o dumputils.o keywords.o kwlookup.o \
-	sql_help.o \
+	sql_help.o crosstabview.o \
 	$(WIN32RES)
 
 
diff --git a/src/bin/psql/command.c b/src/bin/psql/command.c
index 9750a5b..e4db76e 100644
--- a/src/bin/psql/command.c
+++ b/src/bin/psql/command.c
@@ -39,6 +39,7 @@
 
 #include "common.h"
 #include "copy.h"
+#include "crosstabview.h"
 #include "describe.h"
 #include "help.h"
 #include "input.h"
@@ -364,6 +365,39 @@ exec_command(const char *cmd,
 	else if (strcmp(cmd, "copyright") == 0)
 		print_copyright();
 
+	/* \crosstabview -- execute a query and display results in crosstab */
+	else if (strcmp(cmd, "crosstabview") == 0)
+	{
+		char	*opt1,
+			*opt2,
+			*opt3;
+
+		opt1 = psql_scan_slash_option(scan_state,
+									  OT_NORMAL, NULL, false);
+		opt2 = psql_scan_slash_option(scan_state,
+									  OT_NORMAL, NULL, false);
+		opt3 = psql_scan_slash_option(scan_state,
+									  OT_NORMAL, NULL, false);
+
+		if (opt1 && !opt2)
+		{
+			psql_error(_("\\%s: missing second argument\n"), cmd);
+			success = false;
+		}
+		else
+		{
+			pset.crosstabview_col_V = opt1 ? pg_strdup(opt1): NULL;
+			pset.crosstabview_col_H = opt2 ? pg_strdup(opt2): NULL;
+			pset.crosstabview_cols_grid = opt3 ? pg_strdup(opt3): NULL;
+			pset.crosstabview_output = true;
+			status = PSQL_CMD_SEND;
+		}
+
+		free(opt1);
+		free(opt2);
+		free(opt3);
+	}
+
 	/* \d* commands */
 	else if (cmd[0] == 'd')
 	{
diff --git a/src/bin/psql/common.c b/src/bin/psql/common.c
index 2cb2e9b..b368883 100644
--- a/src/bin/psql/common.c
+++ b/src/bin/psql/common.c
@@ -24,6 +24,7 @@
 #include "command.h"
 #include "copy.h"
 #include "mbprint.h"
+#include "crosstabview.h"
 
 
 static bool ExecQueryUsingCursor(const char *query, double *elapsed_msec);
@@ -906,6 +907,8 @@ PrintQueryResults(PGresult *results)
 			/* store or print the data ... */
 			if (pset.gset_prefix)
 				success = StoreQueryTuple(results);
+			else if (pset.crosstabview_output)
+				success = PrintResultsInCrossTab(results);
 			else
 				success = PrintQueryTuples(results);
 			/* if it's INSERT/UPDATE/DELETE RETURNING, also print status */
@@ -1192,6 +1195,23 @@ sendquery_cleanup:
 		pset.gset_prefix = NULL;
 	}
 
+	/* reset \crosstabview settings */
+	pset.crosstabview_output = false;
+	if (pset.crosstabview_col_V)
+	{
+		free(pset.crosstabview_col_V);
+		pset.crosstabview_col_V = NULL;
+	}
+	if (pset.crosstabview_col_H)
+	{
+		free(pset.crosstabview_col_H);
+		pset.crosstabview_col_H = NULL;
+	}
+	if (pset.crosstabview_cols_grid)
+	{
+		free(pset.crosstabview_cols_grid);
+		pset.crosstabview_cols_grid = NULL;
+	}
 	return OK;
 }
 
@@ -1354,7 +1374,25 @@ ExecQueryUsingCursor(const char *query, double *elapsed_msec)
 			is_pager = true;
 		}
 
-		printQuery(results, &my_popt, fout, is_pager, pset.logfile);
+		if (pset.crosstabview_output)
+		{
+			if (ntuples < fetch_count)
+				PrintResultsInCrossTab(results);
+			else
+			{
+				/*
+				  crosstabview is denied if the whole set of rows is not
+				  guaranteed to be fetched in the first iteration, because
+				  it's expected in memory as a single PGresult structure.
+				*/
+				psql_error("\\crosstabview must be used with less than FETCH_COUNT (%d) rows\n",
+					fetch_count);
+				PQclear(results);
+				break;
+			}
+		}
+		else
+			printQuery(results, &my_popt, fout, is_pager, pset.logfile);
 
 		PQclear(results);
 
diff --git a/src/bin/psql/crosstabview.c b/src/bin/psql/crosstabview.c
new file mode 100644
index 0000000..65b10ff
--- /dev/null
+++ b/src/bin/psql/crosstabview.c
@@ -0,0 +1,1038 @@
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright (c) 2000-2016, PostgreSQL Global Development Group
+ *
+ * src/bin/psql/crosstabview.c
+ */
+
+#include "common.h"
+#include "crosstabview.h"
+#include "pqexpbuffer.h"
+#include "settings.h"
+#include <string.h>
+
+/*
+ * Value/position from the resultset that goes into the horizontal or vertical
+ * crosstabview header.
+ */
+struct pivot_field
+{
+	/*
+	 * Pointer obtained from PQgetvalue() for colV or colH. Each distinct
+	 * value becomes an entry in the vertical header (colV), or horizontal
+	 * header (colH)
+	 */
+	char	   *name;
+
+	/*
+	 * When a sort is requested on an alternative column, this holds
+	 * PQgetvalue() for the sort column and the first row
+	 * from which <name> is obtained
+	 */
+	char	   *sort_value;
+
+	/*
+	 * Rank of this value, starting at 0. Initially, it's the relative position
+	 * of the first appearance of this value in the resultset.
+	 * For example, if successive rows contain B,A,C,A,D then it's B:0,A:1,C:2,D:3
+	 * After all values have been gathered, ranks may be updated by serverSort()
+	 */
+	int			rank;
+};
+
+/* Node in avl_tree */
+struct avl_node
+{
+	/* Node contents */
+	struct pivot_field field;
+
+	/*
+	 * Height of this node in the tree (number of nodes on the longest
+	 * path to a leaf).
+	 */
+	int			height;
+
+	/*
+	 * Child nodes. [0] points to left subtree, [1] to right subtree.
+	 * Never NULL, points to the empty node avl_tree.end when no left
+	 * or right value.
+	 */
+	struct avl_node *childs[2];
+};
+
+/*
+ * Control structure for the AVL tree (binary search tree kept
+ * balanced with the AVL algorithm)
+ */
+struct avl_tree
+{
+	int			count;			/* Total number of nodes */
+	struct avl_node *root;		/* root of the tree */
+	struct avl_node *end;		/* Immutable dereferenceable empty tree */
+};
+
+/*
+ * The avl* functions below provide a minimalistic implementation of AVL binary
+ * trees, to efficiently collect the distinct values that will form the horizontal
+ * and vertical headers. It only supports adding new values, no removal or even
+ * search.
+ */
+static void
+avlInit(struct avl_tree *tree)
+{
+	tree->end = (struct avl_node*) pg_malloc0(sizeof(struct avl_node));
+	tree->end->childs[0] = tree->end->childs[1] = tree->end;
+	tree->count = 0;
+	tree->root = tree->end;
+}
+
+/* Deallocate recursively an AVL tree, starting from node */
+static void
+avlFree(struct avl_tree* tree, struct avl_node* node)
+{
+	if (node->childs[0] != tree->end)
+	{
+		avlFree(tree, node->childs[0]);
+		pg_free(node->childs[0]);
+	}
+	if (node->childs[1] != tree->end)
+	{
+		avlFree(tree, node->childs[1]);
+		pg_free(node->childs[1]);
+	}
+	if (node == tree->root) {
+		/* free the root separately as it's not child of anything */
+		if (node != tree->end)
+			pg_free(node);
+		/* free the tree->end struct only once and when all else is freed */
+		pg_free(tree->end);
+	}
+}
+
+/* Set the height to 1 plus the greatest of left and right heights */
+static void
+avlUpdateHeight(struct avl_node *n)
+{
+	n->height = 1 + (n->childs[0]->height > n->childs[1]->height ?
+					 n->childs[0]->height:
+					 n->childs[1]->height);
+}
+
+/* Rotate a subtree left (dir=0) or right (dir=1). Not recursive */
+static struct avl_node*
+avlRotate(struct avl_node **current, int dir)
+{
+	struct avl_node *before = *current;
+	struct avl_node *after = (*current)->childs[dir];
+
+	*current = after;
+	before->childs[dir] = after->childs[!dir];
+	avlUpdateHeight(before);
+	after->childs[!dir] = before;
+
+	return after;
+}
+
+static int
+avlBalance(struct avl_node *n)
+{
+	return n->childs[0]->height - n->childs[1]->height;
+}
+
+/*
+ * After an insertion, possibly rebalance the tree so that the left and right
+ * node heights don't differ by more than 1.
+ * May update *node.
+ */
+static void
+avlAdjustBalance(struct avl_tree *tree, struct avl_node **node)
+{
+	struct avl_node *current = *node;
+	int b = avlBalance(current)/2;
+	if (b != 0)
+	{
+		int dir = (1 - b)/2;
+		if (avlBalance(current->childs[dir]) == -b)
+		  avlRotate(&current->childs[dir], !dir);
+		current = avlRotate(node, dir);
+	}
+	if (current != tree->end)
+	  avlUpdateHeight(current);
+}
+
+/*
+ * Insert a new value/field, starting from *node, reaching the
+ * correct position in the tree by recursion.
+ * Possibly rebalance the tree and possibly update *node.
+ * Do nothing if the value is already present in the tree.
+ */
+static void
+avlInsertNode(struct avl_tree* tree,
+			  struct avl_node **node,
+			  struct pivot_field field)
+{
+	struct avl_node *current = *node;
+
+	if (current == tree->end)
+	{
+		struct avl_node * new_node = (struct avl_node*)
+			pg_malloc(sizeof(struct avl_node));
+		new_node->height = 1;
+		new_node->field = field;
+		new_node->childs[0] = new_node->childs[1] = tree->end;
+		tree->count++;
+		*node = new_node;
+	}
+	else
+	{
+		int cmp = strcmp(field.name, current->field.name);
+		if (cmp != 0)
+		{
+			avlInsertNode(tree,
+						  cmp > 0 ? &current->childs[1] : &current->childs[0],
+						  field);
+			avlAdjustBalance(tree, node);
+		}
+	}
+}
+
+/* Insert the value into the AVL tree, if it does not preexist */
+static void
+avlMergeValue(struct avl_tree* tree, char* name, char* sort_value)
+{
+	struct pivot_field field;
+	field.name = name;
+	field.rank = tree->count;
+	field.sort_value = sort_value;
+	avlInsertNode(tree, &tree->root, field);
+}
+
+/*
+ * Recursively extract node values into the names array, in sorted order with a
+ * left-to-right tree traversal.
+ * Return the next candidate offset to write into the names array.
+ * fields[] must be preallocated to hold tree->count entries
+ */
+static int
+avlCollectFields(struct avl_tree* tree,
+				 struct avl_node* node,
+				 struct pivot_field* fields,
+				 int idx)
+{
+	if (node == tree->end)
+		return idx;
+	idx = avlCollectFields(tree, node->childs[0], fields, idx);
+	fields[idx] = node->field;
+	return avlCollectFields(tree, node->childs[1], fields,  idx+1);
+}
+
+/*
+ * Send a query to sort the list of values in a horizontal or vertical
+ * crosstabview header, and update every source[].rank field with the
+ * new relative position of each value.
+ * coltype is the type's OID for the column from which the values come.
+ * direction is -1 for descending, 1 for ascending, 0 for no sort.
+ */
+static bool
+serverSort(Oid coltype, struct pivot_field *source, int nb_values, int direction)
+{
+	bool retval = false;
+	PGresult *res = NULL;
+	PQExpBufferData query;
+	int i;
+	Oid *param_types;
+	const char** param_values;
+	int* param_formats;
+
+	if (nb_values < 2 || direction==0)
+		return true;					/* nothing to sort */
+
+	param_types = (Oid*) pg_malloc(nb_values*sizeof(Oid));
+	param_values = (const char**) pg_malloc(nb_values*sizeof(char*));
+	param_formats = (int*) pg_malloc(nb_values*sizeof(int));
+
+	initPQExpBuffer(&query);
+
+	/*
+	 * The query returns the original position of each value in our list,
+	 * ordered by its new position. The value itself is not returned.
+	 */
+	appendPQExpBufferStr(&query, "SELECT n FROM (VALUES");
+
+	for (i=0; i < nb_values; i++)
+	{
+		appendPQExpBuffer(&query, "($%d,%d)", i+1, i+1);
+		if (i < nb_values-1)
+			appendPQExpBufferChar(&query, ',');
+		param_types[i] = coltype;
+		param_values[i] = source[i].sort_value;
+		param_formats[i] = 0;
+	}
+
+	appendPQExpBuffer(&query, ") AS l(x,n) ORDER BY x %s",
+					  direction < 0 ? "DESC" : "ASC");
+
+	res = PQexecParams(pset.db,
+					   query.data,
+					   nb_values,
+					   param_types,
+					   param_values,
+					   NULL,	/* lengths not necessary for text format */
+					   param_formats,
+					   0);
+
+	if (res && PQresultStatus(res) == PGRES_TUPLES_OK)
+	{
+		for (i=0; i < PQntuples(res); i++)
+		{
+			int old_pos = atoi(PQgetvalue(res, i, 0));
+
+			if (old_pos < 1 || old_pos > nb_values || i >= nb_values)
+			{
+				/*
+				 * A position outside of the range is normally impossible.
+				 * If this happens, we're facing a malfunctioning or hostile
+				 * server or middleware.
+				 */
+				psql_error(_("Unexpected rank when sorting crosstabview headers\n"));
+				goto cleanup;
+			}
+			else
+			{
+				source[old_pos-1].rank = i;
+			}
+		}
+	}
+	else
+	{
+		psql_error(_("Query error when sorting crosstabview header: %s"),
+				   PQerrorMessage(pset.db));
+		goto cleanup;
+	}
+
+	retval = true;
+
+cleanup:
+	termPQExpBuffer(&query);
+	if (res)
+		PQclear(res);
+	pg_free(param_types);
+	pg_free(param_values);
+	pg_free(param_formats);
+	return retval;
+}
+
+/* for bsearch() inside a sorted array of struct pivot_field */
+static int
+headerCompare(const void *a, const void *b)
+{
+	return strcmp( ((struct pivot_field*)a)->name,
+				   ((struct pivot_field*)b)->name);
+}
+
+
+/*
+ * Output the pivoted resultset with the printTable* functions
+ */
+static void
+printCrosstab(const PGresult *results,
+			  int num_columns,
+			  struct pivot_field *piv_columns,
+			  int field_for_columns,
+			  int num_rows,
+			  struct pivot_field *piv_rows,
+			  int field_for_rows,
+			  int *colsG,
+			  int colsG_num)
+{
+	printQueryOpt popt = pset.popt;
+	printTableContent cont;
+	int	i, j, rn;
+	char col_align = 'l';		/* alignment for values inside the grid */
+	int* horiz_map;			 	/* map indices from sorted horizontal headers to piv_columns */
+	char** allocated_cells; 	/*  Pointers for cell contents that are allocated
+								 *  in this function, when cells cannot simply point to
+								 *  PQgetvalue(results, ...) */
+
+	printTableInit(&cont, &popt.topt, popt.title, num_columns+1, num_rows);
+
+	/* Step 1: set target column names (horizontal header) */
+
+	/* The name of the first column is kept unchanged by the pivoting */
+	printTableAddHeader(&cont,
+						PQfname(results, field_for_rows),
+						false,
+						column_type_alignment(PQftype(results, field_for_rows)));
+
+	/*
+	 * To iterate over piv_columns[] by piv_columns[].rank, create a reverse map
+	 *  associating each piv_columns[].rank to its index in piv_columns.
+	 *  This avoids an O(N^2) loop later
+	 */
+	horiz_map = (int*) pg_malloc(sizeof(int) * num_columns);
+	for (i = 0; i < num_columns; i++)
+	{
+		horiz_map[piv_columns[i].rank] = i;
+	}
+
+
+	/*
+	 * In the common case of only one field projected into the cells, the
+	 * display alignment depends on its PQftype(). Otherwise the contents are
+	 * made-up strings, so the alignment is 'l'
+	 */
+	if (colsG_num == 1)
+		col_align = column_type_alignment(PQftype(results, colsG[0]));
+	else
+		col_align = 'l';
+
+	for (i = 0; i < num_columns; i++)
+	{
+		printTableAddHeader(&cont,
+							piv_columns[horiz_map[i]].name,
+							false,
+							col_align);
+	}
+	pg_free(horiz_map);
+
+	/* Step 2: set row names in the first output column (vertical header) */
+	for (i = 0; i < num_rows; i++)
+	{
+		int k = piv_rows[i].rank;
+		cont.cells[k*(num_columns+1)] = piv_rows[i].name;
+		/* Initialize all cells inside the grid to an empty value */
+		for (j = 0; j < num_columns; j++)
+			cont.cells[k*(num_columns+1)+j+1] = "";
+	}
+	cont.cellsadded = num_rows * (num_columns+1);
+
+	allocated_cells = (char**) pg_malloc0(num_rows * num_columns * sizeof(char*));
+
+	/* Step 3: set all the cells "inside the grid" */
+	for (rn = 0; rn < PQntuples(results); rn++)
+	{
+		char* row_name;
+		char* col_name;
+		int row_number;
+		int col_number;
+		struct pivot_field *p;
+
+		row_number = col_number = -1;
+		/* Find target row */
+		if (!PQgetisnull(results, rn, field_for_rows))
+		{
+			row_name = PQgetvalue(results, rn, field_for_rows);
+			p = (struct pivot_field*) bsearch(&row_name,
+											  piv_rows,
+											  num_rows,
+											  sizeof(struct pivot_field),
+											  headerCompare);
+			if (p)
+				row_number = p->rank;
+		}
+
+		/* Find target column */
+		if (!PQgetisnull(results, rn, field_for_columns))
+		{
+			col_name = PQgetvalue(results, rn, field_for_columns);
+			p = (struct pivot_field*) bsearch(&col_name,
+											  piv_columns,
+											  num_columns,
+											  sizeof(struct pivot_field),
+											  headerCompare);
+			if (p)
+				col_number = p->rank;
+		}
+
+		/* Place value into cell */
+		if (col_number>=0 && row_number>=0)
+		{
+			int idx = 1 + col_number + row_number*(num_columns+1);
+			int src_col = 0;			/* column number in source result */
+
+			/*
+			 * special case: when the source has only 2 columns, use a
+			 * X (cross/checkmark) for the cell content, and set
+			 * src_col to a virtual additional column.
+			 */
+			if (PQnfields(results) == 2)
+				src_col = -1;
+
+			for (i=0; i<colsG_num || src_col==-1; i++)
+			{
+				char *content;
+
+				if (src_col == -1)
+				{
+					content = "X";
+				}
+				else
+				{
+					src_col = colsG[i];
+
+					content = (!PQgetisnull(results, rn, src_col)) ?
+						PQgetvalue(results, rn, src_col) :
+						(popt.nullPrint ? popt.nullPrint : "");
+				}
+
+				if (cont.cells[idx] != NULL && cont.cells[idx][0] != '\0')
+				{
+					/*
+					 * Multiple values for the same (row,col) are projected
+					 * into the same cell. When this happens, separate the
+					 * previous content of the cell from the new value by a
+					 * newline.
+					 */
+					int content_size =
+						strlen(cont.cells[idx])
+						+ 2 			/* room for [CR],LF or space */
+						+ strlen(content)
+						+ 1;			/* '\0' */
+					char *new_content;
+
+					/*
+					 * idx2 is an index into allocated_cells. It differs from
+					 * idx (index into cont.cells), because vertical and
+					 * horizontal headers are included in `cont.cells` but
+					 * excluded from allocated_cells.
+					 */
+					int idx2 = (row_number * num_columns) + col_number;
+
+					if (allocated_cells[idx2] != NULL)
+					{
+						new_content = pg_realloc(allocated_cells[idx2], content_size);
+					}
+					else
+					{
+						/*
+						 * At this point, cont.cells[idx] still contains a
+						 * PQgetvalue() pointer.  Just after, it will contain
+						 * a new pointer maintained in allocated_cells[], and
+						 * freed at the end of this function.
+						 */
+						new_content = pg_malloc(content_size);
+						strcpy(new_content, cont.cells[idx]);
+					}
+					cont.cells[idx] = new_content;
+					allocated_cells[idx2] = new_content;
+
+					/*
+					 * Contents that are on adjacent columns in the source results get
+					 * separated by one space in the target.
+					 * Contents that are on different rows in the source get
+					 * separated by newlines in the target.
+					 */
+					if (i==0)
+						strcat(new_content, "\n");
+					else
+						strcat(new_content, " ");
+					strcat(new_content, content);
+				}
+				else
+				{
+					cont.cells[idx] = content;
+				}
+
+				/* special case of the "virtual column" for checkmark */
+				if (src_col == -1)
+					break;
+			}
+		}
+	}
+
+	printTable(&cont, pset.queryFout, false, pset.logfile);
+	printTableCleanup(&cont);
+
+
+	for (i=0; i < num_rows * num_columns; i++)
+	{
+		if (allocated_cells[i] != NULL)
+			pg_free(allocated_cells[i]);
+	}
+
+	pg_free(allocated_cells);
+}
+
+
+/*
+ * Compare a user-supplied argument against a field name obtained by PQfname(),
+ * which is already case-folded.
+ * If arg is not enclosed in double quotes, pg_strcasecmp applies, otherwise
+ * do a case-sensitive comparison with these rules:
+ * - double quotes enclosing 'arg' are filtered out
+ * - double quotes inside 'arg' are expected to be doubled
+ */
+static bool
+fieldNameEquals(const char *arg, const char *fieldname)
+{
+	const char* p = arg;
+	const char* f = fieldname;
+	char c;
+
+	if (*p++ != '"')
+		return !pg_strcasecmp(arg, fieldname);
+
+	while ((c = *p++))
+	{
+		if (c == '"')
+		{
+			if (*p == '"')
+				p++;			/* skip second quote and continue */
+			else if (*p == '\0')
+				return (*f == '\0');	/* p is shorter than f, or is identical */
+		}
+		if (*f == '\0')
+			return false;			/* f is shorter than p */
+		if (c != *f)				/* found one byte that differs */
+			return false;
+		f++;
+	}
+	return (*f=='\0');
+}
+
+/*
+ * arg can be a number or a column name, possibly quoted (like in an ORDER BY clause)
+ * Returns:
+ *  on success, the 0-based index of the column
+ *  or -1 if the column number or name is not found in the result's structure,
+ *        or if it's ambiguous (arg corresponding to several columns)
+ */
+static int
+indexOfColumn(const char *arg, PGresult *res)
+{
+	int idx;
+
+	if (strspn(arg, "0123456789") == strlen(arg))
+	{
+		/* if arg contains only digits, it's a column number */
+		idx = atoi(arg) - 1;
+		if (idx < 0  || idx >= PQnfields(res))
+		{
+			psql_error(_("Invalid column number: %s\n"), arg);
+			return -1;
+		}
+	}
+	else
+	{
+		int i;
+		idx = -1;
+		for (i=0; i < PQnfields(res); i++)
+		{
+			if (fieldNameEquals(arg, PQfname(res, i)))
+			{
+				if (idx>=0)
+				{
+					/* if another idx was already found for the same name */
+					psql_error(_("Ambiguous column name: %s\n"), arg);
+					return -1;
+				}
+				idx = i;
+			}
+		}
+		if (idx == -1)
+		{
+			psql_error(_("Invalid column name: %s\n"), arg);
+			return -1;
+		}
+	}
+	return idx;
+}
+
+/*
+ * Parse col1[<sep>col2][<sep>col3]...
+ * where colN can be:
+ * - a number from 1 to PQnfields(res)
+ * - an unquoted column name matching (case insensitively) one of PQfname(res,...)
+ * - a quoted column name matching (case sensitively) one of PQfname(res,...)
+ * max_columns: 0 if no maximum
+ */
+static int
+parseColumnRefs(char* arg,
+				PGresult *res,
+				int **col_numbers,
+				int max_columns,
+				char separator)
+{
+	char *p = arg;
+	char c;
+	int col_num = -1;
+	int nb_cols = 0;
+	char* field_start = NULL;
+	*col_numbers = NULL;
+	while ((c = *p) != '\0')
+	{
+		bool quoted_field = false;
+		field_start = p;
+
+		/* first char */
+		if (c == '"')
+		{
+			quoted_field = true;
+			p++;
+		}
+
+		while ((c = *p) != '\0')
+		{
+			if (c == separator && !quoted_field)
+				break;
+			if (c == '"')		/* end of field or embedded double quote */
+			{
+				p++;
+				if (*p == '"')
+				{
+					if (quoted_field)
+					{
+						p++;
+						continue;
+					}
+				}
+				else if (quoted_field && *p == separator)
+					break;
+			}
+			p += PQmblen(p, pset.encoding);
+		}
+
+		if (p != field_start)
+		{
+			/* look up the column and add its index into *col_numbers */
+			if (max_columns != 0 && nb_cols == max_columns)
+			{
+				psql_error(_("No more than %d column references expected\n"), max_columns);
+				goto errfail;
+			}
+			c = *p;
+			*p = '\0';
+			col_num = indexOfColumn(field_start, res);
+			*p = c;
+			if (col_num < 0)
+				goto errfail;
+			*col_numbers = (int*)pg_realloc(*col_numbers, (1+nb_cols)*sizeof(int));
+			(*col_numbers)[nb_cols++] = col_num;
+		}
+		else
+		{
+			psql_error(_("Empty column reference\n"));
+			goto errfail;
+		}
+
+		if (*p)
+			p += PQmblen(p, pset.encoding);
+	}
+	return nb_cols;
+
+errfail:
+	pg_free(*col_numbers);
+	*col_numbers = NULL;
+	return -1;
+}
+
+
+/*
+ * Main function.
+ * Process the data from *res according the display options in pset (global),
+ * to generate the horizontal and vertical headers contents,
+ * then call printCrosstab() for the actual output.
+ */
+bool
+PrintResultsInCrossTab(PGresult* res)
+{
+	/* [-|+]COLV or null */
+	char* opt_field_for_rows = pset.crosstabview_col_V;
+	/* [-|+]COLH or null */
+	char* opt_field_for_columns = pset.crosstabview_col_H;
+	int		rn;
+	struct avl_tree	piv_columns;
+	struct avl_tree	piv_rows;
+	struct pivot_field* array_columns = NULL;
+	struct pivot_field* array_rows = NULL;
+	int		num_columns = 0;
+	int		num_rows = 0;
+	bool 	retval = false;
+	int		columns_sort_direction; /* 1:ascending, 0:none, -1:descending */
+	int		rows_sort_direction;    /* 1:ascending, 0:none, -1:descending */
+	int		*colsV = NULL, *colsH = NULL, *colsG = NULL;
+	int		colsG_num;
+	int		nn;
+
+	/* 0-based index of the field whose distinct values will become COLUMN headers */
+	int		field_for_columns = -1;
+	int		sort_field_for_columns = -1;
+
+	/* 0-based index of the field whose distinct values will become ROW headers */
+	int		field_for_rows = -1;
+	int		sort_field_for_rows = -1;
+
+	avlInit(&piv_rows);
+	avlInit(&piv_columns);
+
+	if (res == NULL)
+	{
+		psql_error(_("No result\n"));
+		goto error_return;
+	}
+
+	if (PQresultStatus(res) != PGRES_TUPLES_OK)
+	{
+		psql_error(_("The query must return results to be shown in crosstab\n"));
+		goto error_return;
+	}
+
+	if (PQnfields(res) < 2)
+	{
+		psql_error(_("The query must return at least two columns to be shown in crosstab\n"));
+		goto error_return;
+	}
+
+	/*
+	 * Arguments processing for the vertical header (1st arg)
+	 * displayed in the left-most column. Determine:
+	 * - the sort direction if any
+	 * - the field number of that column in the PGresult
+	 * - the field number of the associated sort column if any
+	 */
+
+	if (opt_field_for_rows == NULL)
+	{
+		field_for_rows = sort_field_for_rows = 0;
+		rows_sort_direction = 0;
+	}
+	else
+	{
+		if (*opt_field_for_rows == '-')
+		{
+			rows_sort_direction = -1;
+			opt_field_for_rows++;
+		}
+		else if (*opt_field_for_rows == '+')
+		{
+			rows_sort_direction = 1;
+			opt_field_for_rows++;
+		}
+		else
+			rows_sort_direction = 0;
+
+		nn = parseColumnRefs(opt_field_for_rows, res, &colsV, 2, ':');
+		if (nn < 0)
+			goto error_return;
+		if (nn==1)
+		{
+			field_for_rows = colsV[0];
+			sort_field_for_rows = field_for_rows;
+		}
+		else
+		{
+			field_for_rows = colsV[0];
+			sort_field_for_rows = colsV[1];
+			if (rows_sort_direction == 0)
+			{
+				psql_error(_("Sort column specified without a sort direction\n"));
+				goto error_return;
+			}
+		}
+	}
+
+	if (field_for_rows < 0)
+		goto error_return;
+
+	/*
+	 * Arguments processing for the horizontal header (2nd arg)
+	 * (pivoted column that gets displayed as the first row).
+	 * Determine:
+	 * - the sort direction if any
+	 * - the field number of that column in the PGresult
+	 * - the field number of the associated sort column if any
+	 */
+
+	if (opt_field_for_columns == NULL)
+	{
+		field_for_columns = sort_field_for_columns = 1;
+		columns_sort_direction = 0;
+	}
+	else
+	{
+		/*
+		 * descending sort is requested if the column reference is
+		 * preceded with a minus sign
+		 */
+		if (*opt_field_for_columns == '-')
+		{
+			columns_sort_direction = -1;
+			opt_field_for_columns++;
+		}
+		else if (*opt_field_for_columns == '+')
+		{
+			columns_sort_direction = 1;
+			opt_field_for_columns++;
+		}
+		else
+			columns_sort_direction = 0;
+
+		nn = parseColumnRefs(opt_field_for_columns, res, &colsH, 2, ':');
+		if (nn <= 0)
+			goto error_return;
+		if (nn==1)
+		{
+			field_for_columns = colsH[0];
+			sort_field_for_columns = field_for_columns;
+		}
+		else
+		{
+			field_for_columns = colsH[0];
+			sort_field_for_columns = colsH[1];
+			if (columns_sort_direction == 0)
+			{
+				psql_error(_("Sort column specified without a sort direction\n"));
+				goto error_return;
+			}
+		}
+
+		if (field_for_columns < 0)
+			goto error_return;
+	}
+
+	if (field_for_columns == field_for_rows)
+	{
+		psql_error(_("The same column cannot be used for both vertical and horizontal headers\n"));
+		goto error_return;
+	}
+
+	/*
+	 * Arguments processing for the columns aside from headers (3rd arg)
+	 * Determine the columns to display in the grid and their order.
+	 */
+	if (pset.crosstabview_cols_grid == NULL)
+	{
+		/*
+		 * By defaut, all the fields from PGresult get displayed into the grid,
+		 * except the two fields that go into the vertical and horizontal
+		 * headers.
+		 */
+		if (PQnfields(res) > 2)
+		{
+			int i, j=0;
+			colsG = (int*)pg_malloc(sizeof(int) * (PQnfields(res)-2));
+			for (i=0; i<PQnfields(res); i++)
+			{
+				if (i!=field_for_rows && i!=field_for_columns)
+					colsG[j++] = i;
+			}
+			colsG_num = PQnfields(res)-2;
+		}
+		else
+		{
+			colsG = NULL;
+			colsG_num = 0;
+		}
+	}
+	else
+	{
+		/*
+		 * Non-default case: a list of fields is given.
+		 * Parse that list to determine the fields to display into the grid,
+		 * and in what order.
+		 * The list format is colA[,colB[,colC...]]
+		 */
+		colsG_num = parseColumnRefs(pset.crosstabview_cols_grid,
+									res, &colsG, PQnfields(res), ',');
+		if (colsG_num <= 0)
+			goto error_return;
+	}
+
+	/*
+	 * First part: accumulate the names that go into the vertical and
+	 * horizontal headers, each into an AVL binary tree to build the set of
+	 * DISTINCT values.
+	 */
+
+	for (rn = 0; rn < PQntuples(res); rn++)
+	{
+		if (!PQgetisnull(res, rn, field_for_rows))
+		{
+			avlMergeValue(&piv_rows,
+						  PQgetvalue(res, rn, field_for_rows),
+						  PQgetvalue(res, rn, sort_field_for_rows));
+
+			if (rows_sort_direction!=0 && piv_rows.count > 65535)
+			{
+				psql_error(_("Maximum number of rows to sort (65535) exceeded for the vertical header\n"));
+				goto error_return;
+			}
+		}
+
+		if (!PQgetisnull(res, rn, field_for_columns))
+		{
+			avlMergeValue(&piv_columns,
+						  PQgetvalue(res, rn, field_for_columns),
+						  PQgetvalue(res, rn, sort_field_for_columns));
+
+			if (piv_columns.count > 1600)
+			{
+				psql_error(_("Maximum number of columns (1600) exceeded\n"));
+				goto error_return;
+			}
+		}
+	}
+
+
+	/*
+	 * Second part: Generate sorted arrays from the AVL trees.
+	 */
+
+	num_columns = piv_columns.count;
+	num_rows = piv_rows.count;
+
+	array_columns = (struct pivot_field*) pg_malloc(sizeof(struct pivot_field) * num_columns);
+	array_rows = (struct pivot_field*) pg_malloc(sizeof(struct pivot_field) * num_rows);
+
+	avlCollectFields(&piv_columns, piv_columns.root, array_columns, 0);
+	avlCollectFields(&piv_rows, piv_rows.root, array_rows, 0);
+
+	/*
+	 * Third part: sort (by server-side query) the horizontal and/or vertical
+	 * header when applicable.
+	 */
+	if (columns_sort_direction != 0)
+	{
+		if (!serverSort(PQftype(res, sort_field_for_columns),
+						array_columns,
+						num_columns,
+						columns_sort_direction))
+			goto error_return;
+	}
+
+	if (rows_sort_direction != 0)
+	{
+		if (!serverSort(PQftype(res, sort_field_for_rows),
+						array_rows,
+						num_rows,
+						rows_sort_direction))
+			goto error_return;
+	}
+
+	/*
+	 * Fourth part: print the crosstab'ed results.
+	 */
+	printCrosstab(res,
+				  num_columns,
+				  array_columns,
+				  field_for_columns,
+				  num_rows,
+				  array_rows,
+				  field_for_rows,
+				  colsG,
+				  colsG_num);
+
+	retval = true;
+
+error_return:
+	avlFree(&piv_columns, piv_columns.root);
+	avlFree(&piv_rows, piv_rows.root);
+	pg_free(array_columns);
+	pg_free(array_rows);
+	pg_free(colsV);
+	pg_free(colsH);
+	pg_free(colsG);
+
+	return retval;
+}
diff --git a/src/bin/psql/crosstabview.h b/src/bin/psql/crosstabview.h
new file mode 100644
index 0000000..d374cfe
--- /dev/null
+++ b/src/bin/psql/crosstabview.h
@@ -0,0 +1,14 @@
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright (c) 2000-2016, PostgreSQL Global Development Group
+ *
+ * src/bin/psql/crosstabview.h
+ */
+
+#ifndef CROSSTABVIEW_H
+#define CROSSTABVIEW_H
+
+/* prototypes */
+extern bool	PrintResultsInCrossTab(PGresult *res);
+#endif   /* CROSSTABVIEW_H */
diff --git a/src/bin/psql/help.c b/src/bin/psql/help.c
index 59f6f25..26afa68 100644
--- a/src/bin/psql/help.c
+++ b/src/bin/psql/help.c
@@ -175,6 +175,7 @@ slashUsage(unsigned short int pager)
 	fprintf(output, _("  \\g [FILE] or ;         execute query (and send results to file or |pipe)\n"));
 	fprintf(output, _("  \\gset [PREFIX]         execute query and store results in psql variables\n"));
 	fprintf(output, _("  \\q                     quit psql\n"));
+	fprintf(output, _("  \\crosstabview [V H]    execute query and display results in crosstab\n"));
 	fprintf(output, _("  \\watch [SEC]           execute query every SEC seconds\n"));
 	fprintf(output, "\n");
 
diff --git a/src/bin/psql/print.c b/src/bin/psql/print.c
index 8958903..f3d9a83 100644
--- a/src/bin/psql/print.c
+++ b/src/bin/psql/print.c
@@ -3291,30 +3291,9 @@ printQuery(const PGresult *result, const printQueryOpt *opt,
 
 	for (i = 0; i < cont.ncolumns; i++)
 	{
-		char		align;
-		Oid			ftype = PQftype(result, i);
-
-		switch (ftype)
-		{
-			case INT2OID:
-			case INT4OID:
-			case INT8OID:
-			case FLOAT4OID:
-			case FLOAT8OID:
-			case NUMERICOID:
-			case OIDOID:
-			case XIDOID:
-			case CIDOID:
-			case CASHOID:
-				align = 'r';
-				break;
-			default:
-				align = 'l';
-				break;
-		}
-
 		printTableAddHeader(&cont, PQfname(result, i),
-							opt->translate_header, align);
+							opt->translate_header,
+							column_type_alignment(PQftype(result, i)));
 	}
 
 	/* set cells */
@@ -3356,6 +3335,31 @@ printQuery(const PGresult *result, const printQueryOpt *opt,
 	printTableCleanup(&cont);
 }
 
+char
+column_type_alignment(Oid ftype)
+{
+	char		align;
+
+	switch (ftype)
+	{
+		case INT2OID:
+		case INT4OID:
+		case INT8OID:
+		case FLOAT4OID:
+		case FLOAT8OID:
+		case NUMERICOID:
+		case OIDOID:
+		case XIDOID:
+		case CIDOID:
+		case CASHOID:
+			align = 'r';
+			break;
+		default:
+			align = 'l';
+			break;
+	}
+	return align;
+}
 
 void
 setDecimalLocale(void)
diff --git a/src/bin/psql/print.h b/src/bin/psql/print.h
index 868fcdd..4f3d85a 100644
--- a/src/bin/psql/print.h
+++ b/src/bin/psql/print.h
@@ -175,7 +175,7 @@ extern FILE *PageOutput(int lines, const printTableOpt *topt);
 extern void ClosePager(FILE *pagerpipe);
 
 extern void html_escaped_print(const char *in, FILE *fout);
-
+extern char column_type_alignment(Oid);
 extern void printTableInit(printTableContent *const content,
 			   const printTableOpt *opt, const char *title,
 			   const int ncolumns, const int nrows);
diff --git a/src/bin/psql/settings.h b/src/bin/psql/settings.h
index 20a6470..9b7f7c4 100644
--- a/src/bin/psql/settings.h
+++ b/src/bin/psql/settings.h
@@ -90,6 +90,10 @@ typedef struct _psqlSettings
 
 	char	   *gfname;			/* one-shot file output argument for \g */
 	char	   *gset_prefix;	/* one-shot prefix argument for \gset */
+	bool		crosstabview_output;  /* one-shot request to print results in crosstab */
+	char		*crosstabview_col_V;  /* one-shot \crosstabview 1st argument */
+	char		*crosstabview_col_H;  /* one-shot \crosstabview 2nd argument */
+	char		*crosstabview_cols_grid;  /* one-shot \crosstabview 3nd argument */
 
 	bool		notty;			/* stdin or stdout is not a tty (as determined
 								 * on startup) */
diff --git a/src/bin/psql/tab-complete.c b/src/bin/psql/tab-complete.c
index 5f27120..c1e93f2 100644
--- a/src/bin/psql/tab-complete.c
+++ b/src/bin/psql/tab-complete.c
@@ -1273,7 +1273,8 @@ psql_completion(const char *text, int start, int end)
 
 	/* psql's backslash commands. */
 	static const char *const backslash_commands[] = {
-		"\\a", "\\connect", "\\conninfo", "\\C", "\\cd", "\\copy", "\\copyright",
+		"\\a", "\\connect", "\\conninfo", "\\C", "\\cd", "\\copy",
+		"\\copyright", "\\crosstabview",
 		"\\d", "\\da", "\\db", "\\dc", "\\dC", "\\dd", "\\ddp", "\\dD",
 		"\\des", "\\det", "\\deu", "\\dew", "\\dE", "\\df",
 		"\\dF", "\\dFd", "\\dFp", "\\dFt", "\\dg", "\\di", "\\dl", "\\dL",
diff --git a/src/test/regress/expected/psql.out b/src/test/regress/expected/psql.out
index 178a809..7861360 100644
--- a/src/test/regress/expected/psql.out
+++ b/src/test/regress/expected/psql.out
@@ -2665,3 +2665,110 @@ NOTICE:  foo
 CONTEXT:  PL/pgSQL function inline_code_block line 3 at RAISE
 ERROR:  bar
 CONTEXT:  PL/pgSQL function inline_code_block line 4 at RAISE
+-- \crosstabview
+\pset expanded off
+\pset columns 0
+\pset border 1
+\pset format aligned
+BEGIN;
+CREATE TEMPORARY TABLE fruits (
+    name text,
+    num integer,
+    imported date
+) ON COMMIT DROP;
+\copy fruits from stdin;
+-- vertical header post-sorted, horizontal header sorted by query
+select name, to_char(imported, 'mon') mon, sum(num) as sum
+from fruits group by 1,2 order by 2
+ \crosstabview -1 2
+     name     | apr | aug | feb | jan | jul | jun | mar  | nov | oct | sep 
+--------------+-----+-----+-----+-----+-----+-----+------+-----+-----+-----
+ Strawberries |  32 |     |     |     |     |     |   50 |     |     |    
+ Squash       |     |     |     |     |  80 |     |      |     |     |    
+ Saffron      |     |     |     |     | 536 |     |      |     |     |    
+ Naranjillo   |     |     |     |     | 126 |     |      |     |     | 262
+ Ice Plant    | 135 | 279 |     |     |     |     |      |     |     |    
+ Grape        | 393 |     | 260 | 300 | 441 | 542 | 1353 |     | 225 |    
+ Ginger       |     |     |     |     | 160 |     |      |     |     |    
+ Coconut Palm |     |     |     |     |     |     |      |     |     |  26
+ Citron       | 774 |     |     |     |     |     |      |     |     |    
+ Celery       |  12 |     |     |     |     |     |      |     |     |    
+ Blueberry    |     |     |     |     |     |     |      |  32 |     |    
+ Avocado      |     |     |     |     |     |     |      |     | 130 |    
+ Apple        |     |     |     |     | 140 |     |      |     |     |    
+ Angelica     |     |     |     |     |     |     |   80 |     |     |    
+(14 rows)
+
+-- include NULL value (to be discarded from header)
+select name, to_char(imported, 'mon') mon, sum(num) as sum
+from fruits group by 1,2
+union select null, 'jan', 1
+order by 2 \crosstabview -1 2
+     name     | apr | aug | feb | jan | jul | jun | mar  | nov | oct | sep 
+--------------+-----+-----+-----+-----+-----+-----+------+-----+-----+-----
+ Strawberries |  32 |     |     |     |     |     |   50 |     |     |    
+ Squash       |     |     |     |     |  80 |     |      |     |     |    
+ Saffron      |     |     |     |     | 536 |     |      |     |     |    
+ Naranjillo   |     |     |     |     | 126 |     |      |     |     | 262
+ Ice Plant    | 135 | 279 |     |     |     |     |      |     |     |    
+ Grape        | 393 |     | 260 | 300 | 441 | 542 | 1353 |     | 225 |    
+ Ginger       |     |     |     |     | 160 |     |      |     |     |    
+ Coconut Palm |     |     |     |     |     |     |      |     |     |  26
+ Citron       | 774 |     |     |     |     |     |      |     |     |    
+ Celery       |  12 |     |     |     |     |     |      |     |     |    
+ Blueberry    |     |     |     |     |     |     |      |  32 |     |    
+ Avocado      |     |     |     |     |     |     |      |     | 130 |    
+ Apple        |     |     |     |     | 140 |     |      |     |     |    
+ Angelica     |     |     |     |     |     |     |   80 |     |     |    
+(14 rows)
+
+-- 4 fields
+-- include a NULL value in the horizontal header (to be discarded)
+-- fieldname with double quotes
+-- descending sort on date
+select name as "name of ""fruit""", to_char(imported, 'mon') mon, imported, sum(num) as sum
+from fruits group by 1,2,3
+union select 'Citron', NULL, NULL as imported, 1
+\crosstabview -"name of ""fruit""" -2:3 sum
+ name of "fruit" | nov | oct | sep | aug | jul | jun | apr | mar  | feb | jan 
+-----------------+-----+-----+-----+-----+-----+-----+-----+------+-----+-----
+ Strawberries    |     |     |     |     |     |     |  32 |   50 |     |    
+ Squash          |     |     |     |     |  80 |     |     |      |     |    
+ Saffron         |     |     |     |     | 536 |     |     |      |     |    
+ Naranjillo      |     |     | 262 |     | 126 |     |     |      |     |    
+ Ice Plant       |     |     |     | 279 |     |     | 135 |      |     |    
+ Grape           |     | 225 |     |     | 441 | 542 | 393 | 1353 | 260 | 300
+ Ginger          |     |     |     |     | 160 |     |     |      |     |    
+ Coconut Palm    |     |     |  26 |     |     |     |     |      |     |    
+ Citron          |     |     |     |     |     |     | 774 |      |     |    
+ Celery          |     |     |     |     |     |     |  12 |      |     |    
+ Blueberry       |  32 |     |     |     |     |     |     |      |     |    
+ Avocado         |     | 130 |     |     |     |     |     |      |     |    
+ Apple           |     |     |     |     | 140 |     |     |      |     |    
+ Angelica        |     |     |     |     |     |     |     |   80 |     |    
+(14 rows)
+
+-- 4 fields, double sort, field referenced by names
+select sum, name, to_char(imported, 'mon') mon, imported
+  from (select sum(num), name, date_trunc('month',imported)::date as imported
+   from fruits group by 2,3) x
+\crosstabview +name +mon:imported sum
+     name     | jan | feb | mar  | apr | jun | jul | aug | sep | oct | nov 
+--------------+-----+-----+------+-----+-----+-----+-----+-----+-----+-----
+ Angelica     |     |     |   80 |     |     |     |     |     |     |    
+ Apple        |     |     |      |     |     | 140 |     |     |     |    
+ Avocado      |     |     |      |     |     |     |     |     | 130 |    
+ Blueberry    |     |     |      |     |     |     |     |     |     |  32
+ Celery       |     |     |      |  12 |     |     |     |     |     |    
+ Citron       |     |     |      | 774 |     |     |     |     |     |    
+ Coconut Palm |     |     |      |     |     |     |     |  26 |     |    
+ Ginger       |     |     |      |     |     | 160 |     |     |     |    
+ Grape        | 300 | 260 | 1353 | 393 | 542 | 441 |     |     | 225 |    
+ Ice Plant    |     |     |      | 135 |     |     | 279 |     |     |    
+ Naranjillo   |     |     |      |     |     | 126 |     | 262 |     |    
+ Saffron      |     |     |      |     |     | 536 |     |     |     |    
+ Squash       |     |     |      |     |     |  80 |     |     |     |    
+ Strawberries |     |     |   50 |  32 |     |     |     |     |     |    
+(14 rows)
+
+COMMIT;
diff --git a/src/test/regress/sql/psql.sql b/src/test/regress/sql/psql.sql
index 2f81380..77e22f6 100644
--- a/src/test/regress/sql/psql.sql
+++ b/src/test/regress/sql/psql.sql
@@ -351,3 +351,69 @@ begin
   raise notice 'foo';
   raise exception 'bar';
 end $$;
+
+-- \crosstabview
+
+\pset expanded off
+\pset columns 0
+\pset border 1
+\pset format aligned
+BEGIN;
+CREATE TEMPORARY TABLE fruits (
+    name text,
+    num integer,
+    imported date
+) ON COMMIT DROP;
+\copy fruits from stdin;
+Grape	300	2015-01-08
+Grape	260	2015-02-09
+Grape	1353	2015-03-11
+Grape	393	2015-04-15
+Grape	542	2015-06-09
+Grape	441	2015-07-20
+Grape	225	2015-10-09
+Strawberries	50	2015-03-11
+Strawberries	32	2015-04-22
+Saffron	536	2015-07-12
+Squash	80	2015-07-14
+Citron	774	2015-04-02
+Celery	12	2015-04-07
+Coconut Palm	26	2015-09-16
+Blueberry	32	2015-11-16
+Angelica	80	2015-03-20
+Avocado	130	2015-10-19
+Apple	140	2015-07-02
+Ginger	160	2015-07-15
+Ice Plant	135	2015-04-03
+Ice Plant	279	2015-08-04
+Naranjillo	126	2015-07-31
+Naranjillo	262	2015-09-11
+\.
+
+-- vertical header post-sorted, horizontal header sorted by query
+select name, to_char(imported, 'mon') mon, sum(num) as sum
+from fruits group by 1,2 order by 2
+ \crosstabview -1 2
+
+-- include NULL value (to be discarded from header)
+select name, to_char(imported, 'mon') mon, sum(num) as sum
+from fruits group by 1,2
+union select null, 'jan', 1
+order by 2 \crosstabview -1 2
+
+-- 4 fields
+-- include a NULL value in the horizontal header (to be discarded)
+-- fieldname with double quotes
+-- descending sort on date
+select name as "name of ""fruit""", to_char(imported, 'mon') mon, imported, sum(num) as sum
+from fruits group by 1,2,3
+union select 'Citron', NULL, NULL as imported, 1
+\crosstabview -"name of ""fruit""" -2:3 sum
+
+-- 4 fields, double sort, field referenced by names
+select sum, name, to_char(imported, 'mon') mon, imported
+  from (select sum(num), name, date_trunc('month',imported)::date as imported
+   from fruits group by 2,3) x
+\crosstabview +name +mon:imported sum
+
+COMMIT;

diff --git a/doc/src/sgml/ref/psql-ref.sgml b/doc/src/sgml/ref/psql-ref.sgml
index 8a85804..da0621b 100644
--- a/doc/src/sgml/ref/psql-ref.sgml
+++ b/doc/src/sgml/ref/psql-ref.sgml
@@ -990,6 +990,113 @@ testdb=>
       </varlistentry>
 
       <varlistentry>
+        <term><literal>\crosstabview [
+            <replaceable class="parameter">colV</replaceable>
+            <replaceable class="parameter">colH</replaceable>
+            [:<replaceable class="parameter">scolH</replaceable>]
+            [<replaceable class="parameter">colG1[,colG2...]</replaceable>]
+            ] </literal></term>
+        <listitem>
+        <para>
+        Execute the current query buffer (like <literal>\g</literal>) and shows
+        the results inside a crosstab grid.
+        The output column <replaceable class="parameter">colV</replaceable>
+        becomes a vertical header
+        and the output column <replaceable class="parameter">colH</replaceable>
+        becomes a horizontal header, optionally sorted by ranking data obtained
+        from <replaceable class="parameter">scolH</replaceable>.
+
+        <replaceable class="parameter">colG1[,colG2...]</replaceable>
+        is the list of output columns to project into the grid.
+        By default, all output columns of the query except 
+        <replaceable class="parameter">colV</replaceable> and
+        <replaceable class="parameter">colH</replaceable>
+        are included in this list.
+        </para>
+
+        <para>
+        All columns can be refered to by their position (starting at 1), or by
+        their name. Normal case folding and quoting rules apply on column
+        names. By default,
+        <replaceable class="parameter">colV</replaceable> corresponds to column 1
+        and <replaceable class="parameter">colH</replaceable> to column 2.
+        A query having only one output column cannot be viewed in crosstab, and
+        <replaceable class="parameter">colH</replaceable> must differ from
+        <replaceable class="parameter">colV</replaceable>.
+        </para>
+
+        <para>
+        The vertical header, displayed as the leftmost column,
+        contains the deduplicated values found in
+        column <replaceable class="parameter">colV</replaceable>, in the same
+        order as in the query results.
+        </para>
+        <para>
+        The horizontal header, displayed as the first row,
+        contains the deduplicated values found in
+        column <replaceable class="parameter">colH</replaceable>, in
+        the order of appearance in the query results.
+        If specified, the optional <replaceable class="parameter">scolH</replaceable>
+        argument refers to a column whose values should be integer numbers
+        by which <replaceable class="parameter">colH</replaceable> will be sorted
+        to be positioned in the horizontal header.
+        </para>
+
+        <para>
+        Inside the crosstab grid,
+        given a query output with <literal>N</literal> columns
+        (including <replaceable class="parameter">colV</replaceable> and
+        <replaceable class="parameter">colH</replaceable>),
+        for each distinct value <literal>x</literal> of
+        <replaceable class="parameter">colH</replaceable>
+        and each distinct value <literal>y</literal> of
+        <replaceable class="parameter">colV</replaceable>,
+        the contents of a cell located at the intersection
+        <literal>(x,y)</literal> is determined by these rules:
+        <itemizedlist>
+        <listitem>
+        <para>
+         if there is no corresponding row in the query results such that the
+         value for <replaceable class="parameter">colH</replaceable>
+         is <literal>x</literal> and the value
+         for <replaceable class="parameter">colV</replaceable>
+         is <literal>y</literal>, the cell is empty.
+        </para>
+        </listitem>
+
+        <listitem>
+        <para>
+         if there is exactly one row such that the value
+         for <replaceable class="parameter">colH</replaceable>
+         is <literal>x</literal> and the value
+         for <replaceable class="parameter">colV</replaceable>
+         is <literal>y</literal>, then the <literal>N-2</literal> other
+         columns or the columns listed in
+         <replaceable class="parameter">colG1[,colG2...]</replaceable>
+         are displayed in the cell, separated between each other by
+         a space character if needed.
+
+         If <literal>N=2</literal>, the letter <literal>X</literal> is displayed
+         in the cell as if a virtual third column contained that character.
+        </para>
+        </listitem>
+
+        <listitem>
+        <para>
+         if there are several corresponding rows, the behavior is identical to
+         the case of one row except that the values coming from different rows
+         are stacked vertically, the different source rows being separated by
+         newline characters inside the cell.
+        </para>
+        </listitem>
+
+        </itemizedlist>
+        </para>
+
+        </listitem>
+      </varlistentry>
+
+      <varlistentry>
         <term><literal>\d[S+] [ <link linkend="APP-PSQL-patterns"><replaceable class="parameter">pattern</replaceable></link> ]</literal></term>
 
         <listitem>
diff --git a/src/bin/psql/Makefile b/src/bin/psql/Makefile
index 66e14fb..9d29fe1 100644
--- a/src/bin/psql/Makefile
+++ b/src/bin/psql/Makefile
@@ -23,7 +23,7 @@ override CPPFLAGS := -I. -I$(srcdir) -I$(libpq_srcdir) -I$(top_srcdir)/src/bin/p
 OBJS=	command.o common.o help.o input.o stringutils.o mainloop.o copy.o \
 	startup.o prompt.o variables.o large_obj.o print.o describe.o \
 	tab-complete.o mbprint.o dumputils.o keywords.o kwlookup.o \
-	sql_help.o \
+	sql_help.o crosstabview.o \
 	$(WIN32RES)
 
 
diff --git a/src/bin/psql/command.c b/src/bin/psql/command.c
index 9750a5b..e4db76e 100644
--- a/src/bin/psql/command.c
+++ b/src/bin/psql/command.c
@@ -39,6 +39,7 @@
 
 #include "common.h"
 #include "copy.h"
+#include "crosstabview.h"
 #include "describe.h"
 #include "help.h"
 #include "input.h"
@@ -364,6 +365,39 @@ exec_command(const char *cmd,
 	else if (strcmp(cmd, "copyright") == 0)
 		print_copyright();
 
+	/* \crosstabview -- execute a query and display results in crosstab */
+	else if (strcmp(cmd, "crosstabview") == 0)
+	{
+		char	*opt1,
+			*opt2,
+			*opt3;
+
+		opt1 = psql_scan_slash_option(scan_state,
+									  OT_NORMAL, NULL, false);
+		opt2 = psql_scan_slash_option(scan_state,
+									  OT_NORMAL, NULL, false);
+		opt3 = psql_scan_slash_option(scan_state,
+									  OT_NORMAL, NULL, false);
+
+		if (opt1 && !opt2)
+		{
+			psql_error(_("\\%s: missing second argument\n"), cmd);
+			success = false;
+		}
+		else
+		{
+			pset.crosstabview_col_V = opt1 ? pg_strdup(opt1): NULL;
+			pset.crosstabview_col_H = opt2 ? pg_strdup(opt2): NULL;
+			pset.crosstabview_cols_grid = opt3 ? pg_strdup(opt3): NULL;
+			pset.crosstabview_output = true;
+			status = PSQL_CMD_SEND;
+		}
+
+		free(opt1);
+		free(opt2);
+		free(opt3);
+	}
+
 	/* \d* commands */
 	else if (cmd[0] == 'd')
 	{
diff --git a/src/bin/psql/common.c b/src/bin/psql/common.c
index 2cb2e9b..b368883 100644
--- a/src/bin/psql/common.c
+++ b/src/bin/psql/common.c
@@ -24,6 +24,7 @@
 #include "command.h"
 #include "copy.h"
 #include "mbprint.h"
+#include "crosstabview.h"
 
 
 static bool ExecQueryUsingCursor(const char *query, double *elapsed_msec);
@@ -906,6 +907,8 @@ PrintQueryResults(PGresult *results)
 			/* store or print the data ... */
 			if (pset.gset_prefix)
 				success = StoreQueryTuple(results);
+			else if (pset.crosstabview_output)
+				success = PrintResultsInCrossTab(results);
 			else
 				success = PrintQueryTuples(results);
 			/* if it's INSERT/UPDATE/DELETE RETURNING, also print status */
@@ -1192,6 +1195,23 @@ sendquery_cleanup:
 		pset.gset_prefix = NULL;
 	}
 
+	/* reset \crosstabview settings */
+	pset.crosstabview_output = false;
+	if (pset.crosstabview_col_V)
+	{
+		free(pset.crosstabview_col_V);
+		pset.crosstabview_col_V = NULL;
+	}
+	if (pset.crosstabview_col_H)
+	{
+		free(pset.crosstabview_col_H);
+		pset.crosstabview_col_H = NULL;
+	}
+	if (pset.crosstabview_cols_grid)
+	{
+		free(pset.crosstabview_cols_grid);
+		pset.crosstabview_cols_grid = NULL;
+	}
 	return OK;
 }
 
@@ -1354,7 +1374,25 @@ ExecQueryUsingCursor(const char *query, double *elapsed_msec)
 			is_pager = true;
 		}
 
-		printQuery(results, &my_popt, fout, is_pager, pset.logfile);
+		if (pset.crosstabview_output)
+		{
+			if (ntuples < fetch_count)
+				PrintResultsInCrossTab(results);
+			else
+			{
+				/*
+				  crosstabview is denied if the whole set of rows is not
+				  guaranteed to be fetched in the first iteration, because
+				  it's expected in memory as a single PGresult structure.
+				*/
+				psql_error("\\crosstabview must be used with less than FETCH_COUNT (%d) rows\n",
+					fetch_count);
+				PQclear(results);
+				break;
+			}
+		}
+		else
+			printQuery(results, &my_popt, fout, is_pager, pset.logfile);
 
 		PQclear(results);
 
diff --git a/src/bin/psql/crosstabview.c b/src/bin/psql/crosstabview.c
new file mode 100644
index 0000000..4e21162
--- /dev/null
+++ b/src/bin/psql/crosstabview.c
@@ -0,0 +1,938 @@
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright (c) 2000-2016, PostgreSQL Global Development Group
+ *
+ * src/bin/psql/crosstabview.c
+ */
+
+#include "common.h"
+#include "crosstabview.h"
+#include "pqexpbuffer.h"
+#include "settings.h"
+#include <string.h>
+
+/*
+ * Value/position from the resultset that goes into the horizontal or vertical
+ * crosstabview header.
+ */
+struct pivot_field
+{
+	/*
+	 * Pointer obtained from PQgetvalue() for colV or colH. Each distinct
+	 * value becomes an entry in the vertical header (colV), or horizontal
+	 * header (colH).
+	 * A Null value is represented by a NULL pointer.
+	 */
+	char	   *name;
+
+	/*
+	 * When a sort is requested on an alternative column, this holds
+	 * PQgetvalue() for the sort column corresponding to <name>. If
+	 * <name> appear multiple times, it's the first value in the
+	 * order of the results that is kept.
+	 * A Null value is represented by a NULL pointer.
+	 */
+	char	   *sort_value;
+
+	/*
+	 * Rank of this value, starting at 0. Initially, it's the relative position
+	 * of the first appearance of <name> in the resultset.
+	 * For example, if successive rows contain B,A,C,A,D then it's B:0,A:1,C:2,D:3
+	 * When a sort column is specified, ranks get updated in a final pass to reflect
+	 * the desired order.
+	 */
+	int			rank;
+};
+
+/* Node in avl_tree */
+struct avl_node
+{
+	/* Node contents */
+	struct pivot_field field;
+
+	/*
+	 * Height of this node in the tree (number of nodes on the longest
+	 * path to a leaf).
+	 */
+	int			height;
+
+	/*
+	 * Child nodes. [0] points to left subtree, [1] to right subtree.
+	 * Never NULL, points to the empty node avl_tree.end when no left
+	 * or right value.
+	 */
+	struct avl_node *childs[2];
+};
+
+/*
+ * Control structure for the AVL tree (binary search tree kept
+ * balanced with the AVL algorithm)
+ */
+struct avl_tree
+{
+	int			count;			/* Total number of nodes */
+	struct avl_node *root;		/* root of the tree */
+	struct avl_node *end;		/* Immutable dereferenceable empty tree */
+};
+
+/*
+ * Value comparator for vertical and horizontal headers
+ * used for deduplication only.
+ * - null values are considered equal
+ * - non-null < null
+ * - non-null values are compared with strcmp()
+ */
+static int
+pivotFieldCompare(const void *a, const void *b)
+{
+	struct pivot_field* pa = (struct pivot_field*) a;
+	struct pivot_field* pb = (struct pivot_field*) b;
+
+	/* test null values */
+	if (!pb->name)
+		return pa->name ? -1 : 0;
+	else if (!pa->name)
+		return 1;
+	/* non-null values */
+	return strcmp( ((struct pivot_field*)a)->name,
+				   ((struct pivot_field*)b)->name);
+}
+
+static int
+rankCompare(const void* a, const void* b)
+{
+	return *((int*)a) - *((int*)b);
+}
+
+/*
+ * The avl* functions below provide a minimalistic implementation of AVL binary
+ * trees, to efficiently collect the distinct values that will form the horizontal
+ * and vertical headers. It only supports adding new values, no removal or even
+ * search.
+ */
+static void
+avlInit(struct avl_tree *tree)
+{
+	tree->end = (struct avl_node*) pg_malloc0(sizeof(struct avl_node));
+	tree->end->childs[0] = tree->end->childs[1] = tree->end;
+	tree->count = 0;
+	tree->root = tree->end;
+}
+
+/* Deallocate recursively an AVL tree, starting from node */
+static void
+avlFree(struct avl_tree* tree, struct avl_node* node)
+{
+	if (node->childs[0] != tree->end)
+	{
+		avlFree(tree, node->childs[0]);
+		pg_free(node->childs[0]);
+	}
+	if (node->childs[1] != tree->end)
+	{
+		avlFree(tree, node->childs[1]);
+		pg_free(node->childs[1]);
+	}
+	if (node == tree->root) {
+		/* free the root separately as it's not child of anything */
+		if (node != tree->end)
+			pg_free(node);
+		/* free the tree->end struct only once and when all else is freed */
+		pg_free(tree->end);
+	}
+}
+
+/* Set the height to 1 plus the greatest of left and right heights */
+static void
+avlUpdateHeight(struct avl_node *n)
+{
+	n->height = 1 + (n->childs[0]->height > n->childs[1]->height ?
+					 n->childs[0]->height:
+					 n->childs[1]->height);
+}
+
+/* Rotate a subtree left (dir=0) or right (dir=1). Not recursive */
+static struct avl_node*
+avlRotate(struct avl_node **current, int dir)
+{
+	struct avl_node *before = *current;
+	struct avl_node *after = (*current)->childs[dir];
+
+	*current = after;
+	before->childs[dir] = after->childs[!dir];
+	avlUpdateHeight(before);
+	after->childs[!dir] = before;
+
+	return after;
+}
+
+static int
+avlBalance(struct avl_node *n)
+{
+	return n->childs[0]->height - n->childs[1]->height;
+}
+
+/*
+ * After an insertion, possibly rebalance the tree so that the left and right
+ * node heights don't differ by more than 1.
+ * May update *node.
+ */
+static void
+avlAdjustBalance(struct avl_tree *tree, struct avl_node **node)
+{
+	struct avl_node *current = *node;
+	int b = avlBalance(current)/2;
+	if (b != 0)
+	{
+		int dir = (1 - b)/2;
+		if (avlBalance(current->childs[dir]) == -b)
+		  avlRotate(&current->childs[dir], !dir);
+		current = avlRotate(node, dir);
+	}
+	if (current != tree->end)
+	  avlUpdateHeight(current);
+}
+
+/*
+ * Insert a new value/field, starting from *node, reaching the
+ * correct position in the tree by recursion.
+ * Possibly rebalance the tree and possibly update *node.
+ * Do nothing if the value is already present in the tree.
+ */
+static void
+avlInsertNode(struct avl_tree* tree,
+			  struct avl_node **node,
+			  struct pivot_field field)
+{
+	struct avl_node *current = *node;
+
+	if (current == tree->end)
+	{
+		struct avl_node * new_node = (struct avl_node*)
+			pg_malloc(sizeof(struct avl_node));
+		new_node->height = 1;
+		new_node->field = field;
+		new_node->childs[0] = new_node->childs[1] = tree->end;
+		tree->count++;
+		*node = new_node;
+	}
+	else
+	{
+		int cmp = pivotFieldCompare(&field, &current->field);
+		if (cmp != 0)
+		{
+			avlInsertNode(tree,
+						  cmp > 0 ? &current->childs[1] : &current->childs[0],
+						  field);
+			avlAdjustBalance(tree, node);
+		}
+	}
+}
+
+/* Insert the value into the AVL tree, if it does not preexist */
+static void
+avlMergeValue(struct avl_tree* tree, char* name, char* sort_value)
+{
+	struct pivot_field field;
+	field.name = name;
+	field.rank = tree->count;
+	field.sort_value = sort_value;
+	avlInsertNode(tree, &tree->root, field);
+}
+
+/*
+ * Recursively extract node values into the names array, in sorted order with a
+ * left-to-right tree traversal.
+ * Return the next candidate offset to write into the names array.
+ * fields[] must be preallocated to hold tree->count entries
+ */
+static int
+avlCollectFields(struct avl_tree* tree,
+				 struct avl_node* node,
+				 struct pivot_field* fields,
+				 int idx)
+{
+	if (node == tree->end)
+		return idx;
+	idx = avlCollectFields(tree, node->childs[0], fields, idx);
+	fields[idx] = node->field;
+	return avlCollectFields(tree, node->childs[1], fields,  idx+1);
+}
+
+
+static void
+rankSort(int num_columns, struct pivot_field* piv_columns)
+{
+	int* hmap; /* [[offset in piv_columns, rank], ...for every header entry] */
+	int i;
+
+	hmap = (int*) pg_malloc(sizeof(int) * num_columns * 2);
+	for (i = 0; i < num_columns; i++)
+	{
+		char *val = piv_columns[i].sort_value;
+		/* ranking information is valid if non null and matches /^-?\d+$/ */
+		if (val && ((*val == '-' && strspn(val+1, "0123456789") == strlen(val+1) )
+					|| strspn(val, "0123456789") == strlen(val)))
+		{
+			hmap[i*2] = atoi(val);
+			hmap[i*2+1] = i;
+		}
+		else
+		{
+			/* invalid rank information ignored (equivalent to rank 0) */
+			hmap[i*2] = 0;
+			hmap[i*2+1] = i;
+		}
+	}
+
+	qsort(hmap, num_columns, sizeof(int)*2, rankCompare);
+
+	for (i=0; i < num_columns; i++)
+	{
+		piv_columns[hmap[i*2+1]].rank = i;
+	}
+
+	pg_free(hmap);
+}
+
+
+/*
+ * Output the pivoted resultset with the printTable* functions
+ */
+static void
+printCrosstab(const PGresult *results,
+			  int num_columns,
+			  struct pivot_field *piv_columns,
+			  int field_for_columns,
+			  int num_rows,
+			  struct pivot_field *piv_rows,
+			  int field_for_rows,
+			  int *colsG,
+			  int colsG_num)
+{
+	printQueryOpt popt = pset.popt;
+	printTableContent cont;
+	int	i, j, rn;
+	char col_align = 'l';		/* alignment for values inside the grid */
+	int* horiz_map;			 	/* map indices from sorted horizontal headers to piv_columns */
+	char** allocated_cells; 	/*  Pointers for cell contents that are allocated
+								 *  in this function, when cells cannot simply point to
+								 *  PQgetvalue(results, ...) */
+
+	printTableInit(&cont, &popt.topt, popt.title, num_columns+1, num_rows);
+
+	/* Step 1: set target column names (horizontal header) */
+
+	/* The name of the first column is kept unchanged by the pivoting */
+	printTableAddHeader(&cont,
+						PQfname(results, field_for_rows),
+						false,
+						column_type_alignment(PQftype(results, field_for_rows)));
+
+	/*
+	 * To iterate over piv_columns[] by piv_columns[].rank, create a reverse map
+	 *  associating each piv_columns[].rank to its index in piv_columns.
+	 *  This avoids an O(N^2) loop later
+	 */
+	horiz_map = (int*) pg_malloc(sizeof(int) * num_columns);
+	for (i = 0; i < num_columns; i++)
+	{
+		horiz_map[piv_columns[i].rank] = i;
+	}
+
+	/*
+	 * In the common case of only one field projected into the cells, the
+	 * display alignment depends on its PQftype(). Otherwise the contents are
+	 * made-up strings, so the alignment is 'l'
+	 */
+	if (colsG_num == 1)
+		col_align = column_type_alignment(PQftype(results, colsG[0]));
+	else
+		col_align = 'l';
+
+	for (i = 0; i < num_columns; i++)
+	{
+		char *colname = piv_columns[horiz_map[i]].name ?
+			piv_columns[horiz_map[i]].name :
+			(popt.nullPrint ? popt.nullPrint : "");
+
+		printTableAddHeader(&cont,
+							colname,
+							false,
+							col_align);
+	}
+	pg_free(horiz_map);
+
+	/* Step 2: set row names in the first output column (vertical header) */
+	for (i = 0; i < num_rows; i++)
+	{
+		int k = piv_rows[i].rank;
+		cont.cells[k*(num_columns+1)] = piv_rows[i].name ?
+			piv_rows[i].name :
+			(popt.nullPrint ? popt.nullPrint : "");
+		/* Initialize all cells inside the grid to an empty value */
+		for (j = 0; j < num_columns; j++)
+			cont.cells[k*(num_columns+1)+j+1] = "";
+	}
+	cont.cellsadded = num_rows * (num_columns+1);
+
+	allocated_cells = (char**) pg_malloc0(num_rows * num_columns * sizeof(char*));
+
+	/* Step 3: set all the cells "inside the grid" */
+	for (rn = 0; rn < PQntuples(results); rn++)
+	{
+		int row_number;
+		int col_number;
+		struct pivot_field *p;
+
+		/* Find target row */
+		struct pivot_field elt;
+		if (!PQgetisnull(results, rn, field_for_rows))
+			elt.name = PQgetvalue(results, rn, field_for_rows);
+		else
+			elt.name = NULL;
+		p = (struct pivot_field*) bsearch(&elt,
+										  piv_rows,
+										  num_rows,
+										  sizeof(struct pivot_field),
+										  pivotFieldCompare);
+
+		row_number = p ? p->rank : -1;
+
+		/* Find target column */
+		if (!PQgetisnull(results, rn, field_for_columns))
+			elt.name = PQgetvalue(results, rn, field_for_columns);
+		else
+			elt.name = NULL;
+
+		p = (struct pivot_field*) bsearch(&elt,
+										  piv_columns,
+										  num_columns,
+										  sizeof(struct pivot_field),
+										  pivotFieldCompare);
+		col_number = p? p->rank : -1;
+
+		/* Place value into cell */
+		if (col_number>=0 && row_number>=0)
+		{
+			int idx = 1 + col_number + row_number*(num_columns+1);
+			int src_col = 0;			/* column number in source result */
+
+			/*
+			 * special case: when the source has only 2 columns, use a
+			 * X (cross/checkmark) for the cell content, and set
+			 * src_col to a virtual additional column.
+			 */
+			if (PQnfields(results) == 2)
+				src_col = -1;
+
+			for (i=0; i<colsG_num || src_col==-1; i++)
+			{
+				char *content;
+
+				if (src_col == -1)
+				{
+					content = "X";
+				}
+				else
+				{
+					src_col = colsG[i];
+
+					content = (!PQgetisnull(results, rn, src_col)) ?
+						PQgetvalue(results, rn, src_col) :
+						(popt.nullPrint ? popt.nullPrint : "");
+				}
+
+				if (cont.cells[idx] != NULL && cont.cells[idx][0] != '\0')
+				{
+					/*
+					 * Multiple values for the same (row,col) are projected
+					 * into the same cell. When this happens, separate the
+					 * previous content of the cell from the new value by a
+					 * newline.
+					 */
+					int content_size =
+						strlen(cont.cells[idx])
+						+ 2 			/* room for [CR],LF or space */
+						+ strlen(content)
+						+ 1;			/* '\0' */
+					char *new_content;
+
+					/*
+					 * idx2 is an index into allocated_cells. It differs from
+					 * idx (index into cont.cells), because vertical and
+					 * horizontal headers are included in `cont.cells` but
+					 * excluded from allocated_cells.
+					 */
+					int idx2 = (row_number * num_columns) + col_number;
+
+					if (allocated_cells[idx2] != NULL)
+					{
+						new_content = pg_realloc(allocated_cells[idx2], content_size);
+					}
+					else
+					{
+						/*
+						 * At this point, cont.cells[idx] still contains a
+						 * PQgetvalue() pointer.  Just after, it will contain
+						 * a new pointer maintained in allocated_cells[], and
+						 * freed at the end of this function.
+						 */
+						new_content = pg_malloc(content_size);
+						strcpy(new_content, cont.cells[idx]);
+					}
+					cont.cells[idx] = new_content;
+					allocated_cells[idx2] = new_content;
+
+					/*
+					 * Contents that are on adjacent columns in the source results get
+					 * separated by one space in the target.
+					 * Contents that are on different rows in the source get
+					 * separated by newlines in the target.
+					 */
+					if (i==0)
+						strcat(new_content, "\n");
+					else
+						strcat(new_content, " ");
+					strcat(new_content, content);
+				}
+				else
+				{
+					cont.cells[idx] = content;
+				}
+
+				/* special case of the "virtual column" for checkmark */
+				if (src_col == -1)
+					break;
+			}
+		}
+	}
+
+	printTable(&cont, pset.queryFout, false, pset.logfile);
+	printTableCleanup(&cont);
+
+
+	for (i=0; i < num_rows * num_columns; i++)
+	{
+		if (allocated_cells[i] != NULL)
+			pg_free(allocated_cells[i]);
+	}
+
+	pg_free(allocated_cells);
+}
+
+
+/*
+ * Compare a user-supplied argument against a field name obtained by PQfname(),
+ * which is already case-folded.
+ * If arg is not enclosed in double quotes, pg_strcasecmp applies, otherwise
+ * do a case-sensitive comparison with these rules:
+ * - double quotes enclosing 'arg' are filtered out
+ * - double quotes inside 'arg' are expected to be doubled
+ */
+static bool
+fieldNameEquals(const char *arg, const char *fieldname)
+{
+	const char* p = arg;
+	const char* f = fieldname;
+	char c;
+
+	if (*p++ != '"')
+		return !pg_strcasecmp(arg, fieldname);
+
+	while ((c = *p++))
+	{
+		if (c == '"')
+		{
+			if (*p == '"')
+				p++;			/* skip second quote and continue */
+			else if (*p == '\0')
+				return (*f == '\0');	/* p is shorter than f, or is identical */
+		}
+		if (*f == '\0')
+			return false;			/* f is shorter than p */
+		if (c != *f)				/* found one byte that differs */
+			return false;
+		f++;
+	}
+	return (*f=='\0');
+}
+
+/*
+ * arg can be a number or a column name, possibly quoted (like in an ORDER BY clause)
+ * Returns:
+ *  on success, the 0-based index of the column
+ *  or -1 if the column number or name is not found in the result's structure,
+ *        or if it's ambiguous (arg corresponding to several columns)
+ */
+static int
+indexOfColumn(const char *arg, PGresult *res)
+{
+	int idx;
+
+	if (strspn(arg, "0123456789") == strlen(arg))
+	{
+		/* if arg contains only digits, it's a column number */
+		idx = atoi(arg) - 1;
+		if (idx < 0  || idx >= PQnfields(res))
+		{
+			psql_error(_("Invalid column number: %s\n"), arg);
+			return -1;
+		}
+	}
+	else
+	{
+		int i;
+		idx = -1;
+		for (i=0; i < PQnfields(res); i++)
+		{
+			if (fieldNameEquals(arg, PQfname(res, i)))
+			{
+				if (idx>=0)
+				{
+					/* if another idx was already found for the same name */
+					psql_error(_("Ambiguous column name: %s\n"), arg);
+					return -1;
+				}
+				idx = i;
+			}
+		}
+		if (idx == -1)
+		{
+			psql_error(_("Invalid column name: %s\n"), arg);
+			return -1;
+		}
+	}
+	return idx;
+}
+
+/*
+ * Parse col1[<sep>col2][<sep>col3]...
+ * where colN can be:
+ * - a number from 1 to PQnfields(res)
+ * - an unquoted column name matching (case insensitively) one of PQfname(res,...)
+ * - a quoted column name matching (case sensitively) one of PQfname(res,...)
+ * max_columns: 0 if no maximum
+ */
+static int
+parseColumnRefs(char* arg,
+				PGresult *res,
+				int **col_numbers,
+				int max_columns,
+				char separator)
+{
+	char *p = arg;
+	char c;
+	int col_num = -1;
+	int nb_cols = 0;
+	char* field_start = NULL;
+	*col_numbers = NULL;
+	while ((c = *p) != '\0')
+	{
+		bool quoted_field = false;
+		field_start = p;
+
+		/* first char */
+		if (c == '"')
+		{
+			quoted_field = true;
+			p++;
+		}
+
+		while ((c = *p) != '\0')
+		{
+			if (c == separator && !quoted_field)
+				break;
+			if (c == '"')		/* end of field or embedded double quote */
+			{
+				p++;
+				if (*p == '"')
+				{
+					if (quoted_field)
+					{
+						p++;
+						continue;
+					}
+				}
+				else if (quoted_field && *p == separator)
+					break;
+			}
+			p += PQmblen(p, pset.encoding);
+		}
+
+		if (p != field_start)
+		{
+			/* look up the column and add its index into *col_numbers */
+			if (max_columns != 0 && nb_cols == max_columns)
+			{
+				psql_error(_("No more than %d column references expected\n"), max_columns);
+				goto errfail;
+			}
+			c = *p;
+			*p = '\0';
+			col_num = indexOfColumn(field_start, res);
+			*p = c;
+			if (col_num < 0)
+				goto errfail;
+			*col_numbers = (int*)pg_realloc(*col_numbers, (1+nb_cols)*sizeof(int));
+			(*col_numbers)[nb_cols++] = col_num;
+		}
+		else
+		{
+			psql_error(_("Empty column reference\n"));
+			goto errfail;
+		}
+
+		if (*p)
+			p += PQmblen(p, pset.encoding);
+	}
+	return nb_cols;
+
+errfail:
+	pg_free(*col_numbers);
+	*col_numbers = NULL;
+	return -1;
+}
+
+
+/*
+ * Main function.
+ * Process the data from *res according the display options in pset (global),
+ * to generate the horizontal and vertical headers contents,
+ * then call printCrosstab() for the actual output.
+ */
+bool
+PrintResultsInCrossTab(PGresult* res)
+{
+	/* COLV or null */
+	char* opt_field_for_rows = pset.crosstabview_col_V;
+	/* COLH[:SCOLH] or null */
+	char* opt_field_for_columns = pset.crosstabview_col_H;
+	int		rn;
+	struct avl_tree	piv_columns;
+	struct avl_tree	piv_rows;
+	struct pivot_field* array_columns = NULL;
+	struct pivot_field* array_rows = NULL;
+	int		num_columns = 0;
+	int		num_rows = 0;
+	bool 	retval = false;
+	/*
+	 * column definitions involved in the vertical header, horizontal header,
+	 * and grid
+	 */
+	int		*colsV = NULL, *colsH = NULL, *colsG = NULL;
+	int		colsG_num;
+	int		nn;
+
+	/* 0-based index of the field whose distinct values will become COLUMN headers */
+	int		field_for_columns = -1;
+	int		sort_field_for_columns = -1;
+
+	/* 0-based index of the field whose distinct values will become ROW headers */
+	int		field_for_rows = -1;
+
+	avlInit(&piv_rows);
+	avlInit(&piv_columns);
+
+	if (res == NULL)
+	{
+		psql_error(_("No result\n"));
+		goto error_return;
+	}
+
+	if (PQresultStatus(res) != PGRES_TUPLES_OK)
+	{
+		psql_error(_("The query must return results to be shown in crosstab\n"));
+		goto error_return;
+	}
+
+	if (PQnfields(res) < 2)
+	{
+		psql_error(_("The query must return at least two columns to be shown in crosstab\n"));
+		goto error_return;
+	}
+
+	/*
+	 * Arguments processing for the vertical header (1st arg)
+	 * displayed in the left-most column. Only a reference to a field
+	 * is accepted (no sort column).
+	 */
+
+	if (opt_field_for_rows == NULL)
+	{
+		field_for_rows = 0;
+	}
+	else
+	{
+		nn = parseColumnRefs(opt_field_for_rows, res, &colsV, 1, ':');
+		if (nn != 1)
+			goto error_return;
+		field_for_rows = colsV[0];
+	}
+
+	if (field_for_rows < 0)
+		goto error_return;
+
+	/*
+	 * Arguments processing for the horizontal header (2nd arg)
+	 * (pivoted column that gets displayed as the first row).
+	 * Determine:
+	 * - the sort direction if any
+	 * - the field number of that column in the PGresult
+	 * - the field number of the associated sort column if any
+	 */
+
+	if (opt_field_for_columns == NULL)
+		field_for_columns = 1;
+	else
+	{
+		nn = parseColumnRefs(opt_field_for_columns, res, &colsH, 2, ':');
+		if (nn <= 0)
+			goto error_return;
+		if (nn==1)
+			field_for_columns = colsH[0];
+		else
+		{
+			field_for_columns = colsH[0];
+			sort_field_for_columns = colsH[1];
+		}
+
+		if (field_for_columns < 0)
+			goto error_return;
+	}
+
+	if (field_for_columns == field_for_rows)
+	{
+		psql_error(_("The same column cannot be used for both vertical and horizontal headers\n"));
+		goto error_return;
+	}
+
+	/*
+	 * Arguments processing for the columns aside from headers (3rd arg)
+	 * Determine the columns to display in the grid and their order.
+	 */
+	if (pset.crosstabview_cols_grid == NULL)
+	{
+		/*
+		 * By defaut, all the fields from PGresult get displayed into the grid,
+		 * except the two fields that go into the vertical and horizontal
+		 * headers.
+		 */
+		if (PQnfields(res) > 2)
+		{
+			int i, j=0;
+			colsG = (int*)pg_malloc(sizeof(int) * (PQnfields(res)-2));
+			for (i=0; i<PQnfields(res); i++)
+			{
+				if (i!=field_for_rows && i!=field_for_columns)
+					colsG[j++] = i;
+			}
+			colsG_num = PQnfields(res)-2;
+		}
+		else
+		{
+			colsG = NULL;
+			colsG_num = 0;
+		}
+	}
+	else
+	{
+		/*
+		 * Non-default case: a list of fields is given.
+		 * Parse that list to determine the fields to display into the grid,
+		 * and in what order.
+		 * The list format is colA[,colB[,colC...]]
+		 */
+		colsG_num = parseColumnRefs(pset.crosstabview_cols_grid,
+									res, &colsG, PQnfields(res), ',');
+		if (colsG_num <= 0)
+			goto error_return;
+	}
+
+	/*
+	 * First part: accumulate the names that go into the vertical and
+	 * horizontal headers, each into an AVL binary tree to build the set of
+	 * DISTINCT values.
+	 */
+
+	for (rn = 0; rn < PQntuples(res); rn++)
+	{
+		/* horizontal */
+		char* val = PQgetisnull(res, rn, field_for_columns) ? NULL:
+			PQgetvalue(res, rn, field_for_columns);
+
+		if (sort_field_for_columns >= 0)
+		{
+			char* val1 = PQgetisnull(res, rn, sort_field_for_columns) ? NULL:
+				PQgetvalue(res, rn, sort_field_for_columns);
+
+			avlMergeValue(&piv_columns, val, val1);
+		}
+		else
+		{
+			avlMergeValue(&piv_columns, val, NULL);
+		}
+
+		if (piv_columns.count > 1600)
+		{
+			psql_error(_("Maximum number of columns (1600) exceeded\n"));
+			goto error_return;
+		}
+
+		/* vertical */
+		val = PQgetisnull(res, rn, field_for_rows) ? NULL:
+			PQgetvalue(res, rn, field_for_rows);
+
+		avlMergeValue(&piv_rows, val, NULL);
+	}
+
+	/*
+	 * Second part: Generate sorted arrays from the AVL trees.
+	 */
+
+	num_columns = piv_columns.count;
+	num_rows = piv_rows.count;
+
+	array_columns = (struct pivot_field*)
+		pg_malloc(sizeof(struct pivot_field) * num_columns);
+
+	array_rows = (struct pivot_field*)
+		pg_malloc(sizeof(struct pivot_field) * num_rows);
+
+	avlCollectFields(&piv_columns, piv_columns.root, array_columns, 0);
+	avlCollectFields(&piv_rows, piv_rows.root, array_rows, 0);
+
+	/*
+	 * Third part: optionally, process the ranking data for the horizontal
+	 * header
+	 */
+	if (sort_field_for_columns >= 0)
+		rankSort(num_columns, array_columns);
+
+	/*
+	 * Fourth part: print the crosstab'ed results.
+	 */
+	printCrosstab(res,
+				  num_columns,
+				  array_columns,
+				  field_for_columns,
+				  num_rows,
+				  array_rows,
+				  field_for_rows,
+				  colsG,
+				  colsG_num);
+
+	retval = true;
+
+error_return:
+	avlFree(&piv_columns, piv_columns.root);
+	avlFree(&piv_rows, piv_rows.root);
+	pg_free(array_columns);
+	pg_free(array_rows);
+	pg_free(colsV);
+	pg_free(colsH);
+	pg_free(colsG);
+
+	return retval;
+}
diff --git a/src/bin/psql/crosstabview.h b/src/bin/psql/crosstabview.h
new file mode 100644
index 0000000..d374cfe
--- /dev/null
+++ b/src/bin/psql/crosstabview.h
@@ -0,0 +1,14 @@
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright (c) 2000-2016, PostgreSQL Global Development Group
+ *
+ * src/bin/psql/crosstabview.h
+ */
+
+#ifndef CROSSTABVIEW_H
+#define CROSSTABVIEW_H
+
+/* prototypes */
+extern bool	PrintResultsInCrossTab(PGresult *res);
+#endif   /* CROSSTABVIEW_H */
diff --git a/src/bin/psql/help.c b/src/bin/psql/help.c
index 59f6f25..f5411ac 100644
--- a/src/bin/psql/help.c
+++ b/src/bin/psql/help.c
@@ -175,6 +175,7 @@ slashUsage(unsigned short int pager)
 	fprintf(output, _("  \\g [FILE] or ;         execute query (and send results to file or |pipe)\n"));
 	fprintf(output, _("  \\gset [PREFIX]         execute query and store results in psql variables\n"));
 	fprintf(output, _("  \\q                     quit psql\n"));
+	fprintf(output, _("  \\crosstabview [COLUMNS] execute query and display results in crosstab\n"));
 	fprintf(output, _("  \\watch [SEC]           execute query every SEC seconds\n"));
 	fprintf(output, "\n");
 
diff --git a/src/bin/psql/print.c b/src/bin/psql/print.c
index 85dbd30..32360a6 100644
--- a/src/bin/psql/print.c
+++ b/src/bin/psql/print.c
@@ -3293,30 +3293,9 @@ printQuery(const PGresult *result, const printQueryOpt *opt,
 
 	for (i = 0; i < cont.ncolumns; i++)
 	{
-		char		align;
-		Oid			ftype = PQftype(result, i);
-
-		switch (ftype)
-		{
-			case INT2OID:
-			case INT4OID:
-			case INT8OID:
-			case FLOAT4OID:
-			case FLOAT8OID:
-			case NUMERICOID:
-			case OIDOID:
-			case XIDOID:
-			case CIDOID:
-			case CASHOID:
-				align = 'r';
-				break;
-			default:
-				align = 'l';
-				break;
-		}
-
 		printTableAddHeader(&cont, PQfname(result, i),
-							opt->translate_header, align);
+							opt->translate_header,
+							column_type_alignment(PQftype(result, i)));
 	}
 
 	/* set cells */
@@ -3358,6 +3337,31 @@ printQuery(const PGresult *result, const printQueryOpt *opt,
 	printTableCleanup(&cont);
 }
 
+char
+column_type_alignment(Oid ftype)
+{
+	char		align;
+
+	switch (ftype)
+	{
+		case INT2OID:
+		case INT4OID:
+		case INT8OID:
+		case FLOAT4OID:
+		case FLOAT8OID:
+		case NUMERICOID:
+		case OIDOID:
+		case XIDOID:
+		case CIDOID:
+		case CASHOID:
+			align = 'r';
+			break;
+		default:
+			align = 'l';
+			break;
+	}
+	return align;
+}
 
 void
 setDecimalLocale(void)
diff --git a/src/bin/psql/print.h b/src/bin/psql/print.h
index 005ba15..d5d62b2 100644
--- a/src/bin/psql/print.h
+++ b/src/bin/psql/print.h
@@ -174,7 +174,7 @@ extern FILE *PageOutput(int lines, const printTableOpt *topt);
 extern void ClosePager(FILE *pagerpipe);
 
 extern void html_escaped_print(const char *in, FILE *fout);
-
+extern char column_type_alignment(Oid);
 extern void printTableInit(printTableContent *const content,
 			   const printTableOpt *opt, const char *title,
 			   const int ncolumns, const int nrows);
diff --git a/src/bin/psql/settings.h b/src/bin/psql/settings.h
index 20a6470..9b7f7c4 100644
--- a/src/bin/psql/settings.h
+++ b/src/bin/psql/settings.h
@@ -90,6 +90,10 @@ typedef struct _psqlSettings
 
 	char	   *gfname;			/* one-shot file output argument for \g */
 	char	   *gset_prefix;	/* one-shot prefix argument for \gset */
+	bool		crosstabview_output;  /* one-shot request to print results in crosstab */
+	char		*crosstabview_col_V;  /* one-shot \crosstabview 1st argument */
+	char		*crosstabview_col_H;  /* one-shot \crosstabview 2nd argument */
+	char		*crosstabview_cols_grid;  /* one-shot \crosstabview 3nd argument */
 
 	bool		notty;			/* stdin or stdout is not a tty (as determined
 								 * on startup) */
diff --git a/src/bin/psql/tab-complete.c b/src/bin/psql/tab-complete.c
index 6a81416..5f18a5d 100644
--- a/src/bin/psql/tab-complete.c
+++ b/src/bin/psql/tab-complete.c
@@ -1273,7 +1273,8 @@ psql_completion(const char *text, int start, int end)
 
 	/* psql's backslash commands. */
 	static const char *const backslash_commands[] = {
-		"\\a", "\\connect", "\\conninfo", "\\C", "\\cd", "\\copy", "\\copyright",
+		"\\a", "\\connect", "\\conninfo", "\\C", "\\cd", "\\copy",
+		"\\copyright", "\\crosstabview",
 		"\\d", "\\da", "\\db", "\\dc", "\\dC", "\\dd", "\\ddp", "\\dD",
 		"\\des", "\\det", "\\deu", "\\dew", "\\dE", "\\df",
 		"\\dF", "\\dFd", "\\dFp", "\\dFt", "\\dg", "\\di", "\\dl", "\\dL",