proposal: multiple psql option -c

diff --git a/src/bin/psql/mainloop.c b/src/bin/psql/mainloop.c
new file mode 100644
index b6cef94..bfd5bf5
*** a/src/bin/psql/mainloop.c
--- b/src/bin/psql/mainloop.c
*************** MainLoop(FILE *source)
*** 43,48 ****
--- 43,49 ----
  	volatile promptStatus_t prompt_status = PROMPT_READY;
  	volatile int count_eof = 0;
  	volatile bool die_on_error = false;
+ 	Commands *cmd = pset.commands;
  
  	/* Save the prior command source */
  	FILE	   *prev_cmd_source;
*************** MainLoop(FILE *source)
*** 135,140 ****
--- 136,156 ----
  				prompt_status = PROMPT_READY;
  			line = gets_interactive(get_prompt(prompt_status));
  		}
+ 		else if (pset.commands != NULL)
+ 		{
+ 			pset.cur_cmd_interactive = false;
+ 
+ 			if (cmd != NULL)
+ 			{
+ 				line = cmd->actions;
+ 				cmd = cmd->next;
+ 			}
+ 			else
+ 			{
+ 				successResult = EXIT_SUCCESS;
+ 				break;
+ 			}
+ 		}
  		else
  		{
  			line = gets_fromFile(source);
diff --git a/src/bin/psql/settings.h b/src/bin/psql/settings.h
new file mode 100644
index d34dc28..46d2a81
*** a/src/bin/psql/settings.h
--- b/src/bin/psql/settings.h
*************** enum trivalue
*** 77,82 ****
--- 77,88 ----
  	TRI_YES
  };
  
+ typedef struct _Commands
+ {
+ 	char *actions;
+ 	struct _Commands *next;
+ } Commands;
+ 
  typedef struct _psqlSettings
  {
  	PGconn	   *db;				/* connection to backend */
*************** typedef struct _psqlSettings
*** 129,134 ****
--- 135,141 ----
  	const char *prompt2;
  	const char *prompt3;
  	PGVerbosity verbosity;		/* current error verbosity level */
+ 	Commands *commands;
  } PsqlSettings;
  
  extern PsqlSettings pset;
diff --git a/src/bin/psql/startup.c b/src/bin/psql/startup.c
new file mode 100644
index 28ba75a..cbceb91
*** a/src/bin/psql/startup.c
--- b/src/bin/psql/startup.c
*************** enum _actions
*** 54,60 ****
  	ACT_SINGLE_SLASH,
  	ACT_LIST_DB,
  	ACT_SINGLE_QUERY,
! 	ACT_FILE
  };
  
  struct adhoc_opts
--- 54,61 ----
  	ACT_SINGLE_SLASH,
  	ACT_LIST_DB,
  	ACT_SINGLE_QUERY,
! 	ACT_FILE,
! 	ACT_COMMANDS
  };
  
  struct adhoc_opts
*************** main(int argc, char *argv[])
*** 158,163 ****
--- 159,166 ----
  	SetVariable(pset.vars, "PROMPT2", DEFAULT_PROMPT2);
  	SetVariable(pset.vars, "PROMPT3", DEFAULT_PROMPT3);
  
+ 	pset.commands = NULL;
+ 
  	parse_psql_options(argc, argv, &options);
  
  	/*
*************** main(int argc, char *argv[])
*** 326,331 ****
--- 329,340 ----
  			? EXIT_SUCCESS : EXIT_FAILURE;
  	}
  
+ 	else if (options.action == ACT_COMMANDS)
+ 	{
+ 		pset.notty = true;
+ 		successResult = MainLoop(stdin);
+ 	}
+ 
  	/*
  	 * or otherwise enter interactive main loop
  	 */
*************** parse_psql_options(int argc, char *argv[
*** 403,409 ****
  
  	memset(options, 0, sizeof *options);
  
! 	while ((c = getopt_long(argc, argv, "aAbc:d:eEf:F:h:HlL:no:p:P:qR:sStT:U:v:VwWxXz?01",
  							long_options, &optindex)) != -1)
  	{
  		switch (c)
--- 412,418 ----
  
  	memset(options, 0, sizeof *options);
  
! 	while ((c = getopt_long(argc, argv, "aAbc:C:d:eEf:F:h:HlL:no:p:P:qR:sStT:U:v:VwWxXz?01",
  							long_options, &optindex)) != -1)
  	{
  		switch (c)
*************** parse_psql_options(int argc, char *argv[
*** 427,432 ****
--- 436,460 ----
  				else
  					options->action = ACT_SINGLE_QUERY;
  				break;
+ 			case 'C':
+ 				{
+ 					Commands *cmd = pg_malloc(sizeof(Commands));
+ 					Commands *ptr = pset.commands;
+ 
+ 					if (ptr == NULL)
+ 						pset.commands = cmd;
+ 					else
+ 					{
+ 						while (ptr->next != NULL)
+ 							ptr =  ptr->next;
+ 
+ 						ptr->next = cmd;
+ 					}
+ 					cmd->next = NULL;
+ 					cmd->actions = pg_strdup(optarg);
+ 					options->action = ACT_COMMANDS;
+ 				}
+ 				break;
  			case 'd':
  				options->dbname = pg_strdup(optarg);
  				break;

commit 9c71d3dbdc3b81f4f8535c93b69507fe5d9af897
Author: Pavel Stehule <pavel.stehule@gooddata.com>
Date:   Wed Aug 26 13:03:56 2015 +0200

    inital

diff --git a/doc/src/sgml/ref/psql-ref.sgml b/doc/src/sgml/ref/psql-ref.sgml
index f996865..750c4ae 100644
--- a/doc/src/sgml/ref/psql-ref.sgml
+++ b/doc/src/sgml/ref/psql-ref.sgml
@@ -223,6 +223,20 @@ EOF
     </varlistentry>
 
     <varlistentry>
+      <term><option>-g <replaceable class="parameter">command(s)</replaceable></></term>
+      <term><option>--group-command=<replaceable class="parameter">command(s)</replaceable></></term>
+      <listitem>
+      <para>
+      Specifies that <application>psql</application> is to execute one or
+      more command strings, <replaceable class="parameter">commands</replaceable>,
+      and then exit. This is useful in shell scripts. Start-up files
+      (<filename>psqlrc</filename> and <filename>~/.psqlrc</filename>) are
+      ignored with this option.
+      </para>
+      </listitem>
+    </varlistentry>
+
+    <varlistentry>
       <term><option>-h <replaceable class="parameter">hostname</replaceable></></term>
       <term><option>--host=<replaceable class="parameter">hostname</replaceable></></term>
       <listitem>
diff --git a/src/bin/psql/help.c b/src/bin/psql/help.c
index d3e3114..55aa423 100644
--- a/src/bin/psql/help.c
+++ b/src/bin/psql/help.c
@@ -79,6 +79,8 @@ usage(unsigned short int pager)
 	fprintf(output, _("  -c, --command=COMMAND    run only single command (SQL or internal) and exit\n"));
 	fprintf(output, _("  -d, --dbname=DBNAME      database name to connect to (default: \"%s\")\n"), env);
 	fprintf(output, _("  -f, --file=FILENAME      execute commands from file, then exit\n"));
+	fprintf(output, _("  -g, --group-command=COMMAND\n"
+					  "                           run more groups of commands (SQL or internal) and exit\n"));
 	fprintf(output, _("  -l, --list               list available databases, then exit\n"));
 	fprintf(output, _("  -v, --set=, --variable=NAME=VALUE\n"
 					  "                           set psql variable NAME to VALUE e.g.: -v ON_ERROR_STOP=1\n"));
diff --git a/src/bin/psql/mainloop.c b/src/bin/psql/mainloop.c
index b6cef94..62db503 100644
--- a/src/bin/psql/mainloop.c
+++ b/src/bin/psql/mainloop.c
@@ -43,6 +43,7 @@ MainLoop(FILE *source)
 	volatile promptStatus_t prompt_status = PROMPT_READY;
 	volatile int count_eof = 0;
 	volatile bool die_on_error = false;
+	GroupCommand *cmd = pset.group_commands;
 
 	/* Save the prior command source */
 	FILE	   *prev_cmd_source;
@@ -135,6 +136,20 @@ MainLoop(FILE *source)
 				prompt_status = PROMPT_READY;
 			line = gets_interactive(get_prompt(prompt_status));
 		}
+		else if (pset.group_commands != NULL)
+		{
+			/* Is there some unprocessed group command? */
+			if (cmd != NULL)
+			{
+				line = cmd->actions;
+				cmd = cmd->next;
+			}
+			else
+			{
+				successResult = EXIT_SUCCESS;
+				break;
+			}
+		}
 		else
 		{
 			line = gets_fromFile(source);
diff --git a/src/bin/psql/settings.h b/src/bin/psql/settings.h
index d34dc28..d23d67a 100644
--- a/src/bin/psql/settings.h
+++ b/src/bin/psql/settings.h
@@ -77,6 +77,12 @@ enum trivalue
 	TRI_YES
 };
 
+typedef struct _GroupCommand
+{
+	char *actions;
+	struct _GroupCommand *next;
+} GroupCommand;
+
 typedef struct _psqlSettings
 {
 	PGconn	   *db;				/* connection to backend */
@@ -129,6 +135,7 @@ typedef struct _psqlSettings
 	const char *prompt2;
 	const char *prompt3;
 	PGVerbosity verbosity;		/* current error verbosity level */
+	GroupCommand *group_commands;
 } PsqlSettings;
 
 extern PsqlSettings pset;
diff --git a/src/bin/psql/startup.c b/src/bin/psql/startup.c
index 28ba75a..9c3f91f 100644
--- a/src/bin/psql/startup.c
+++ b/src/bin/psql/startup.c
@@ -54,7 +54,8 @@ enum _actions
 	ACT_SINGLE_SLASH,
 	ACT_LIST_DB,
 	ACT_SINGLE_QUERY,
-	ACT_FILE
+	ACT_FILE,
+	ACT_GROUP_COMMANDS
 };
 
 struct adhoc_opts
@@ -158,6 +159,8 @@ main(int argc, char *argv[])
 	SetVariable(pset.vars, "PROMPT2", DEFAULT_PROMPT2);
 	SetVariable(pset.vars, "PROMPT3", DEFAULT_PROMPT3);
 
+	pset.group_commands = NULL;
+
 	parse_psql_options(argc, argv, &options);
 
 	/*
@@ -326,6 +329,13 @@ main(int argc, char *argv[])
 			? EXIT_SUCCESS : EXIT_FAILURE;
 	}
 
+	else if (options.action == ACT_GROUP_COMMANDS)
+	{
+		pset.notty = true;
+		SetVariableBool(pset.vars, "SINGLELINE");
+		successResult = MainLoop(stdin);
+	}
+
 	/*
 	 * or otherwise enter interactive main loop
 	 */
@@ -370,6 +380,7 @@ parse_psql_options(int argc, char *argv[], struct adhoc_opts * options)
 		{"file", required_argument, NULL, 'f'},
 		{"field-separator", required_argument, NULL, 'F'},
 		{"field-separator-zero", no_argument, NULL, 'z'},
+		{"group-command", required_argument, NULL, 'g'},
 		{"host", required_argument, NULL, 'h'},
 		{"html", no_argument, NULL, 'H'},
 		{"list", no_argument, NULL, 'l'},
@@ -401,9 +412,12 @@ parse_psql_options(int argc, char *argv[], struct adhoc_opts * options)
 	int			optindex;
 	int			c;
 
+	bool			cmd_opt_is_used = false;
+	bool			group_cmd_opt_is_used = false;
+
 	memset(options, 0, sizeof *options);
 
-	while ((c = getopt_long(argc, argv, "aAbc:d:eEf:F:h:HlL:no:p:P:qR:sStT:U:v:VwWxXz?01",
+	while ((c = getopt_long(argc, argv, "aAbc:d:eEf:F:g:h:HlL:no:p:P:qR:sStT:U:v:VwWxXz?01",
 							long_options, &optindex)) != -1)
 	{
 		switch (c)
@@ -418,6 +432,8 @@ parse_psql_options(int argc, char *argv[], struct adhoc_opts * options)
 				SetVariable(pset.vars, "ECHO", "errors");
 				break;
 			case 'c':
+				cmd_opt_is_used = true;
+
 				options->action_string = pg_strdup(optarg);
 				if (optarg[0] == '\\')
 				{
@@ -444,6 +460,27 @@ parse_psql_options(int argc, char *argv[], struct adhoc_opts * options)
 				pset.popt.topt.fieldSep.separator = pg_strdup(optarg);
 				pset.popt.topt.fieldSep.separator_zero = false;
 				break;
+			case 'g':
+				{
+					GroupCommand *cmd = pg_malloc(sizeof(GroupCommand));
+					GroupCommand *ptr = pset.group_commands;
+
+					group_cmd_opt_is_used = true;
+
+					if (ptr == NULL)
+						pset.group_commands = cmd;
+					else
+					{
+						while (ptr->next != NULL)
+							ptr =  ptr->next;
+
+						ptr->next = cmd;
+					}
+					cmd->next = NULL;
+					cmd->actions = pg_strdup(optarg);
+					options->action = ACT_GROUP_COMMANDS;
+				}
+				break;
 			case 'h':
 				options->host = pg_strdup(optarg);
 				break;
@@ -600,6 +637,13 @@ parse_psql_options(int argc, char *argv[], struct adhoc_opts * options)
 		}
 	}
 
+	if (cmd_opt_is_used && group_cmd_opt_is_used)
+	{
+		fprintf(stderr, _("%s: options -c/--command and -g/--group_command cannot be used together\n"),
+				pset.progname);
+		exit(EXIT_FAILURE);
+	}
+
 	/*
 	 * if we still have arguments, use it as the database name and username
 	 */

commit bef661b7c822f4fe9f004bf55645a3e47e514bc8
Author: Pavel Stehule <pavel.stehule@gooddata.com>
Date:   Wed Aug 26 13:03:56 2015 +0200

    inital

diff --git a/doc/src/sgml/ref/psql-ref.sgml b/doc/src/sgml/ref/psql-ref.sgml
index f996865..750c4ae 100644
--- a/doc/src/sgml/ref/psql-ref.sgml
+++ b/doc/src/sgml/ref/psql-ref.sgml
@@ -223,6 +223,20 @@ EOF
     </varlistentry>
 
     <varlistentry>
+      <term><option>-g <replaceable class="parameter">command(s)</replaceable></></term>
+      <term><option>--group-command=<replaceable class="parameter">command(s)</replaceable></></term>
+      <listitem>
+      <para>
+      Specifies that <application>psql</application> is to execute one or
+      more command strings, <replaceable class="parameter">commands</replaceable>,
+      and then exit. This is useful in shell scripts. Start-up files
+      (<filename>psqlrc</filename> and <filename>~/.psqlrc</filename>) are
+      ignored with this option.
+      </para>
+      </listitem>
+    </varlistentry>
+
+    <varlistentry>
       <term><option>-h <replaceable class="parameter">hostname</replaceable></></term>
       <term><option>--host=<replaceable class="parameter">hostname</replaceable></></term>
       <listitem>
diff --git a/src/bin/psql/command.c b/src/bin/psql/command.c
index 6181a61..277e980 100644
--- a/src/bin/psql/command.c
+++ b/src/bin/psql/command.c
@@ -2292,7 +2292,6 @@ process_file(char *filename, bool single_txn, bool use_relative_path)
 	int			result;
 	char	   *oldfilename;
 	char		relpath[MAXPGPATH];
-	PGresult   *res;
 
 	if (!filename)
 	{
@@ -2337,37 +2336,8 @@ process_file(char *filename, bool single_txn, bool use_relative_path)
 	oldfilename = pset.inputfile;
 	pset.inputfile = filename;
 
-	if (single_txn)
-	{
-		if ((res = PSQLexec("BEGIN")) == NULL)
-		{
-			if (pset.on_error_stop)
-			{
-				result = EXIT_USER;
-				goto error;
-			}
-		}
-		else
-			PQclear(res);
-	}
-
-	result = MainLoop(fd);
+	result = MainLoop(fd, single_txn);
 
-	if (single_txn)
-	{
-		if ((res = PSQLexec("COMMIT")) == NULL)
-		{
-			if (pset.on_error_stop)
-			{
-				result = EXIT_USER;
-				goto error;
-			}
-		}
-		else
-			PQclear(res);
-	}
-
-error:
 	if (fd != stdin)
 		fclose(fd);
 
@@ -2375,8 +2345,6 @@ error:
 	return result;
 }
 
-
-
 static const char *
 _align2string(enum printFormat in)
 {
diff --git a/src/bin/psql/help.c b/src/bin/psql/help.c
index d3e3114..55aa423 100644
--- a/src/bin/psql/help.c
+++ b/src/bin/psql/help.c
@@ -79,6 +79,8 @@ usage(unsigned short int pager)
 	fprintf(output, _("  -c, --command=COMMAND    run only single command (SQL or internal) and exit\n"));
 	fprintf(output, _("  -d, --dbname=DBNAME      database name to connect to (default: \"%s\")\n"), env);
 	fprintf(output, _("  -f, --file=FILENAME      execute commands from file, then exit\n"));
+	fprintf(output, _("  -g, --group-command=COMMAND\n"
+					  "                           run more groups of commands (SQL or internal) and exit\n"));
 	fprintf(output, _("  -l, --list               list available databases, then exit\n"));
 	fprintf(output, _("  -v, --set=, --variable=NAME=VALUE\n"
 					  "                           set psql variable NAME to VALUE e.g.: -v ON_ERROR_STOP=1\n"));
diff --git a/src/bin/psql/mainloop.c b/src/bin/psql/mainloop.c
index b6cef94..4147238 100644
--- a/src/bin/psql/mainloop.c
+++ b/src/bin/psql/mainloop.c
@@ -24,8 +24,8 @@
  * This loop is re-entrant. May be called by \i command
  *	which reads input from a file.
  */
-int
-MainLoop(FILE *source)
+static int
+_MainLoop(FILE *source)
 {
 	PsqlScanState scan_state;	/* lexer working state */
 	volatile PQExpBuffer query_buf;		/* buffer for query being accumulated */
@@ -43,6 +43,7 @@ MainLoop(FILE *source)
 	volatile promptStatus_t prompt_status = PROMPT_READY;
 	volatile int count_eof = 0;
 	volatile bool die_on_error = false;
+	GroupCommand *cmd = pset.group_commands;
 
 	/* Save the prior command source */
 	FILE	   *prev_cmd_source;
@@ -135,6 +136,20 @@ MainLoop(FILE *source)
 				prompt_status = PROMPT_READY;
 			line = gets_interactive(get_prompt(prompt_status));
 		}
+		else if (pset.group_commands != NULL)
+		{
+			/* Is there some unprocessed group command? */
+			if (cmd != NULL)
+			{
+				line = cmd->actions;
+				cmd = cmd->next;
+			}
+			else
+			{
+				successResult = EXIT_SUCCESS;
+				break;
+			}
+		}
 		else
 		{
 			line = gets_fromFile(source);
@@ -451,6 +466,43 @@ MainLoop(FILE *source)
 	return successResult;
 }	/* MainLoop() */
 
+/*
+ * Transactional MainLoop
+ *
+ * allow to execute all statements in single transaction
+ */
+int
+MainLoop(FILE *source, bool single_txn)
+{
+	int			result;
+	PGresult   *res;
+
+	if (single_txn)
+	{
+		if ((res = PSQLexec("BEGIN")) == NULL)
+		{
+			if (pset.on_error_stop)
+				return EXIT_USER;
+		}
+		else
+			PQclear(res);
+	}
+
+	result = _MainLoop(source);
+
+	if (single_txn)
+	{
+		if ((res = PSQLexec("COMMIT")) == NULL)
+		{
+			if (pset.on_error_stop)
+				return EXIT_USER;
+		}
+		else
+			PQclear(res);
+	}
+
+	return result;
+}
 
 /*
  * psqlscan.c is #include'd here instead of being compiled on its own.
diff --git a/src/bin/psql/mainloop.h b/src/bin/psql/mainloop.h
index 8f1325c..53c9a11 100644
--- a/src/bin/psql/mainloop.h
+++ b/src/bin/psql/mainloop.h
@@ -10,6 +10,6 @@
 
 #include "postgres_fe.h"
 
-int			MainLoop(FILE *source);
+int			MainLoop(FILE *source, bool single_txn);
 
 #endif   /* MAINLOOP_H */
diff --git a/src/bin/psql/settings.h b/src/bin/psql/settings.h
index d34dc28..d23d67a 100644
--- a/src/bin/psql/settings.h
+++ b/src/bin/psql/settings.h
@@ -77,6 +77,12 @@ enum trivalue
 	TRI_YES
 };
 
+typedef struct _GroupCommand
+{
+	char *actions;
+	struct _GroupCommand *next;
+} GroupCommand;
+
 typedef struct _psqlSettings
 {
 	PGconn	   *db;				/* connection to backend */
@@ -129,6 +135,7 @@ typedef struct _psqlSettings
 	const char *prompt2;
 	const char *prompt3;
 	PGVerbosity verbosity;		/* current error verbosity level */
+	GroupCommand *group_commands;
 } PsqlSettings;
 
 extern PsqlSettings pset;
diff --git a/src/bin/psql/startup.c b/src/bin/psql/startup.c
index 28ba75a..4c9383f 100644
--- a/src/bin/psql/startup.c
+++ b/src/bin/psql/startup.c
@@ -54,7 +54,8 @@ enum _actions
 	ACT_SINGLE_SLASH,
 	ACT_LIST_DB,
 	ACT_SINGLE_QUERY,
-	ACT_FILE
+	ACT_FILE,
+	ACT_GROUP_COMMANDS
 };
 
 struct adhoc_opts
@@ -158,6 +159,8 @@ main(int argc, char *argv[])
 	SetVariable(pset.vars, "PROMPT2", DEFAULT_PROMPT2);
 	SetVariable(pset.vars, "PROMPT3", DEFAULT_PROMPT3);
 
+	pset.group_commands = NULL;
+
 	parse_psql_options(argc, argv, &options);
 
 	/*
@@ -326,6 +329,13 @@ main(int argc, char *argv[])
 			? EXIT_SUCCESS : EXIT_FAILURE;
 	}
 
+	else if (options.action == ACT_GROUP_COMMANDS)
+	{
+		pset.notty = true;
+		SetVariableBool(pset.vars, "SINGLELINE");
+		successResult = MainLoop(NULL, options.single_txn);
+	}
+
 	/*
 	 * or otherwise enter interactive main loop
 	 */
@@ -338,7 +348,7 @@ main(int argc, char *argv[])
 		if (!pset.quiet)
 			printf(_("Type \"help\" for help.\n\n"));
 		initializeInput(options.no_readline ? 0 : 1);
-		successResult = MainLoop(stdin);
+		successResult = MainLoop(stdin, false);
 	}
 
 	/* clean up */
@@ -370,6 +380,7 @@ parse_psql_options(int argc, char *argv[], struct adhoc_opts * options)
 		{"file", required_argument, NULL, 'f'},
 		{"field-separator", required_argument, NULL, 'F'},
 		{"field-separator-zero", no_argument, NULL, 'z'},
+		{"group-command", required_argument, NULL, 'g'},
 		{"host", required_argument, NULL, 'h'},
 		{"html", no_argument, NULL, 'H'},
 		{"list", no_argument, NULL, 'l'},
@@ -401,9 +412,12 @@ parse_psql_options(int argc, char *argv[], struct adhoc_opts * options)
 	int			optindex;
 	int			c;
 
+	bool			cmd_opt_is_used = false;
+	bool			group_cmd_opt_is_used = false;
+
 	memset(options, 0, sizeof *options);
 
-	while ((c = getopt_long(argc, argv, "aAbc:d:eEf:F:h:HlL:no:p:P:qR:sStT:U:v:VwWxXz?01",
+	while ((c = getopt_long(argc, argv, "aAbc:d:eEf:F:g:h:HlL:no:p:P:qR:sStT:U:v:VwWxXz?01",
 							long_options, &optindex)) != -1)
 	{
 		switch (c)
@@ -418,6 +432,8 @@ parse_psql_options(int argc, char *argv[], struct adhoc_opts * options)
 				SetVariable(pset.vars, "ECHO", "errors");
 				break;
 			case 'c':
+				cmd_opt_is_used = true;
+
 				options->action_string = pg_strdup(optarg);
 				if (optarg[0] == '\\')
 				{
@@ -444,6 +460,27 @@ parse_psql_options(int argc, char *argv[], struct adhoc_opts * options)
 				pset.popt.topt.fieldSep.separator = pg_strdup(optarg);
 				pset.popt.topt.fieldSep.separator_zero = false;
 				break;
+			case 'g':
+				{
+					GroupCommand *cmd = pg_malloc(sizeof(GroupCommand));
+					GroupCommand *ptr = pset.group_commands;
+
+					group_cmd_opt_is_used = true;
+
+					if (ptr == NULL)
+						pset.group_commands = cmd;
+					else
+					{
+						while (ptr->next != NULL)
+							ptr =  ptr->next;
+
+						ptr->next = cmd;
+					}
+					cmd->next = NULL;
+					cmd->actions = pg_strdup(optarg);
+					options->action = ACT_GROUP_COMMANDS;
+				}
+				break;
 			case 'h':
 				options->host = pg_strdup(optarg);
 				break;
@@ -600,6 +637,13 @@ parse_psql_options(int argc, char *argv[], struct adhoc_opts * options)
 		}
 	}
 
+	if (cmd_opt_is_used && group_cmd_opt_is_used)
+	{
+		fprintf(stderr, _("%s: options -c/--command and -g/--group_command cannot be used together\n"),
+				pset.progname);
+		exit(EXIT_FAILURE);
+	}
+
 	/*
 	 * if we still have arguments, use it as the database name and username
 	 */

diff --git a/doc/src/sgml/ref/psql-ref.sgml b/doc/src/sgml/ref/psql-ref.sgml
new file mode 100644
index 212dbfa..c932bb2
*** a/doc/src/sgml/ref/psql-ref.sgml
--- b/doc/src/sgml/ref/psql-ref.sgml
*************** EOF
*** 223,228 ****
--- 223,242 ----
      </varlistentry>
  
      <varlistentry>
+       <term><option>-g <replaceable class="parameter">command(s)</replaceable></></term>
+       <term><option>--group-command=<replaceable class="parameter">command(s)</replaceable></></term>
+       <listitem>
+       <para>
+       Specifies that <application>psql</application> is to execute one or
+       more command strings, <replaceable class="parameter">commands</replaceable>,
+       and then exit. This is useful in shell scripts. Start-up files
+       (<filename>psqlrc</filename> and <filename>~/.psqlrc</filename>) are
+       ignored with this option.
+       </para>
+       </listitem>
+     </varlistentry>
+ 
+     <varlistentry>
        <term><option>-h <replaceable class="parameter">hostname</replaceable></></term>
        <term><option>--host=<replaceable class="parameter">hostname</replaceable></></term>
        <listitem>
diff --git a/src/bin/psql/command.c b/src/bin/psql/command.c
new file mode 100644
index 50d3ff5..73ed5c1
*** a/src/bin/psql/command.c
--- b/src/bin/psql/command.c
*************** process_file(char *filename, bool single
*** 2293,2299 ****
  	int			result;
  	char	   *oldfilename;
  	char		relpath[MAXPGPATH];
- 	PGresult   *res;
  
  	if (!filename)
  	{
--- 2293,2298 ----
*************** process_file(char *filename, bool single
*** 2338,2374 ****
  	oldfilename = pset.inputfile;
  	pset.inputfile = filename;
  
! 	if (single_txn)
! 	{
! 		if ((res = PSQLexec("BEGIN")) == NULL)
! 		{
! 			if (pset.on_error_stop)
! 			{
! 				result = EXIT_USER;
! 				goto error;
! 			}
! 		}
! 		else
! 			PQclear(res);
! 	}
! 
! 	result = MainLoop(fd);
! 
! 	if (single_txn)
! 	{
! 		if ((res = PSQLexec("COMMIT")) == NULL)
! 		{
! 			if (pset.on_error_stop)
! 			{
! 				result = EXIT_USER;
! 				goto error;
! 			}
! 		}
! 		else
! 			PQclear(res);
! 	}
  
- error:
  	if (fd != stdin)
  		fclose(fd);
  
--- 2337,2344 ----
  	oldfilename = pset.inputfile;
  	pset.inputfile = filename;
  
! 	result = MainLoop(fd, single_txn);
  
  	if (fd != stdin)
  		fclose(fd);
  
*************** error:
*** 2376,2383 ****
  	return result;
  }
  
- 
- 
  static const char *
  _align2string(enum printFormat in)
  {
--- 2346,2351 ----
diff --git a/src/bin/psql/help.c b/src/bin/psql/help.c
new file mode 100644
index 5b63e76..2ef4ea6
*** a/src/bin/psql/help.c
--- b/src/bin/psql/help.c
*************** usage(unsigned short int pager)
*** 83,88 ****
--- 83,90 ----
  	fprintf(output, _("  -c, --command=COMMAND    run only single command (SQL or internal) and exit\n"));
  	fprintf(output, _("  -d, --dbname=DBNAME      database name to connect to (default: \"%s\")\n"), env);
  	fprintf(output, _("  -f, --file=FILENAME      execute commands from file, then exit\n"));
+ 	fprintf(output, _("  -g, --group-command=COMMAND\n"
+ 					  "                           run more groups of commands (SQL or internal) and exit\n"));
  	fprintf(output, _("  -l, --list               list available databases, then exit\n"));
  	fprintf(output, _("  -v, --set=, --variable=NAME=VALUE\n"
  					  "                           set psql variable NAME to VALUE\n"
diff --git a/src/bin/psql/mainloop.c b/src/bin/psql/mainloop.c
new file mode 100644
index b6cef94..4147238
*** a/src/bin/psql/mainloop.c
--- b/src/bin/psql/mainloop.c
***************
*** 24,31 ****
   * This loop is re-entrant. May be called by \i command
   *	which reads input from a file.
   */
! int
! MainLoop(FILE *source)
  {
  	PsqlScanState scan_state;	/* lexer working state */
  	volatile PQExpBuffer query_buf;		/* buffer for query being accumulated */
--- 24,31 ----
   * This loop is re-entrant. May be called by \i command
   *	which reads input from a file.
   */
! static int
! _MainLoop(FILE *source)
  {
  	PsqlScanState scan_state;	/* lexer working state */
  	volatile PQExpBuffer query_buf;		/* buffer for query being accumulated */
*************** MainLoop(FILE *source)
*** 43,48 ****
--- 43,49 ----
  	volatile promptStatus_t prompt_status = PROMPT_READY;
  	volatile int count_eof = 0;
  	volatile bool die_on_error = false;
+ 	GroupCommand *cmd = pset.group_commands;
  
  	/* Save the prior command source */
  	FILE	   *prev_cmd_source;
*************** MainLoop(FILE *source)
*** 135,140 ****
--- 136,155 ----
  				prompt_status = PROMPT_READY;
  			line = gets_interactive(get_prompt(prompt_status));
  		}
+ 		else if (pset.group_commands != NULL)
+ 		{
+ 			/* Is there some unprocessed group command? */
+ 			if (cmd != NULL)
+ 			{
+ 				line = cmd->actions;
+ 				cmd = cmd->next;
+ 			}
+ 			else
+ 			{
+ 				successResult = EXIT_SUCCESS;
+ 				break;
+ 			}
+ 		}
  		else
  		{
  			line = gets_fromFile(source);
*************** MainLoop(FILE *source)
*** 451,456 ****
--- 466,508 ----
  	return successResult;
  }	/* MainLoop() */
  
+ /*
+  * Transactional MainLoop
+  *
+  * allow to execute all statements in single transaction
+  */
+ int
+ MainLoop(FILE *source, bool single_txn)
+ {
+ 	int			result;
+ 	PGresult   *res;
+ 
+ 	if (single_txn)
+ 	{
+ 		if ((res = PSQLexec("BEGIN")) == NULL)
+ 		{
+ 			if (pset.on_error_stop)
+ 				return EXIT_USER;
+ 		}
+ 		else
+ 			PQclear(res);
+ 	}
+ 
+ 	result = _MainLoop(source);
+ 
+ 	if (single_txn)
+ 	{
+ 		if ((res = PSQLexec("COMMIT")) == NULL)
+ 		{
+ 			if (pset.on_error_stop)
+ 				return EXIT_USER;
+ 		}
+ 		else
+ 			PQclear(res);
+ 	}
+ 
+ 	return result;
+ }
  
  /*
   * psqlscan.c is #include'd here instead of being compiled on its own.
diff --git a/src/bin/psql/mainloop.h b/src/bin/psql/mainloop.h
new file mode 100644
index 8f1325c..53c9a11
*** a/src/bin/psql/mainloop.h
--- b/src/bin/psql/mainloop.h
***************
*** 10,15 ****
  
  #include "postgres_fe.h"
  
! int			MainLoop(FILE *source);
  
  #endif   /* MAINLOOP_H */
--- 10,15 ----
  
  #include "postgres_fe.h"
  
! int			MainLoop(FILE *source, bool single_txn);
  
  #endif   /* MAINLOOP_H */
diff --git a/src/bin/psql/settings.h b/src/bin/psql/settings.h
new file mode 100644
index 1885bb1..29455ac
*** a/src/bin/psql/settings.h
--- b/src/bin/psql/settings.h
*************** enum trivalue
*** 77,82 ****
--- 77,88 ----
  	TRI_YES
  };
  
+ typedef struct _GroupCommand
+ {
+ 	char *actions;
+ 	struct _GroupCommand *next;
+ } GroupCommand;
+ 
  typedef struct _psqlSettings
  {
  	PGconn	   *db;				/* connection to backend */
*************** typedef struct _psqlSettings
*** 130,135 ****
--- 136,142 ----
  	const char *prompt3;
  	PGVerbosity verbosity;		/* current error verbosity level */
  	PGContextVisibility show_context;	/* current context display level */
+ 	GroupCommand *group_commands;
  } PsqlSettings;
  
  extern PsqlSettings pset;
diff --git a/src/bin/psql/startup.c b/src/bin/psql/startup.c
new file mode 100644
index 7aa997d..df334b4
*** a/src/bin/psql/startup.c
--- b/src/bin/psql/startup.c
*************** enum _actions
*** 54,60 ****
  	ACT_SINGLE_SLASH,
  	ACT_LIST_DB,
  	ACT_SINGLE_QUERY,
! 	ACT_FILE
  };
  
  struct adhoc_opts
--- 54,61 ----
  	ACT_SINGLE_SLASH,
  	ACT_LIST_DB,
  	ACT_SINGLE_QUERY,
! 	ACT_FILE,
! 	ACT_GROUP_COMMANDS
  };
  
  struct adhoc_opts
*************** main(int argc, char *argv[])
*** 159,164 ****
--- 160,167 ----
  	SetVariable(pset.vars, "PROMPT2", DEFAULT_PROMPT2);
  	SetVariable(pset.vars, "PROMPT3", DEFAULT_PROMPT3);
  
+ 	pset.group_commands = NULL;
+ 
  	parse_psql_options(argc, argv, &options);
  
  	/*
*************** main(int argc, char *argv[])
*** 327,332 ****
--- 330,342 ----
  			? EXIT_SUCCESS : EXIT_FAILURE;
  	}
  
+ 	else if (options.action == ACT_GROUP_COMMANDS)
+ 	{
+ 		pset.notty = true;
+ 		SetVariableBool(pset.vars, "SINGLELINE");
+ 		successResult = MainLoop(NULL, options.single_txn);
+ 	}
+ 
  	/*
  	 * or otherwise enter interactive main loop
  	 */
*************** main(int argc, char *argv[])
*** 339,345 ****
  		if (!pset.quiet)
  			printf(_("Type \"help\" for help.\n\n"));
  		initializeInput(options.no_readline ? 0 : 1);
! 		successResult = MainLoop(stdin);
  	}
  
  	/* clean up */
--- 349,355 ----
  		if (!pset.quiet)
  			printf(_("Type \"help\" for help.\n\n"));
  		initializeInput(options.no_readline ? 0 : 1);
! 		successResult = MainLoop(stdin, false);
  	}
  
  	/* clean up */
*************** parse_psql_options(int argc, char *argv[
*** 371,376 ****
--- 381,387 ----
  		{"file", required_argument, NULL, 'f'},
  		{"field-separator", required_argument, NULL, 'F'},
  		{"field-separator-zero", no_argument, NULL, 'z'},
+ 		{"group-command", required_argument, NULL, 'g'},
  		{"host", required_argument, NULL, 'h'},
  		{"html", no_argument, NULL, 'H'},
  		{"list", no_argument, NULL, 'l'},
*************** parse_psql_options(int argc, char *argv[
*** 402,410 ****
  	int			optindex;
  	int			c;
  
  	memset(options, 0, sizeof *options);
  
! 	while ((c = getopt_long(argc, argv, "aAbc:d:eEf:F:h:HlL:no:p:P:qR:sStT:U:v:VwWxXz?01",
  							long_options, &optindex)) != -1)
  	{
  		switch (c)
--- 413,424 ----
  	int			optindex;
  	int			c;
  
+ 	bool			cmd_opt_is_used = false;
+ 	bool			group_cmd_opt_is_used = false;
+ 
  	memset(options, 0, sizeof *options);
  
! 	while ((c = getopt_long(argc, argv, "aAbc:d:eEf:F:g:h:HlL:no:p:P:qR:sStT:U:v:VwWxXz?01",
  							long_options, &optindex)) != -1)
  	{
  		switch (c)
*************** parse_psql_options(int argc, char *argv[
*** 419,424 ****
--- 433,440 ----
  				SetVariable(pset.vars, "ECHO", "errors");
  				break;
  			case 'c':
+ 				cmd_opt_is_used = true;
+ 
  				options->action_string = pg_strdup(optarg);
  				if (optarg[0] == '\\')
  				{
*************** parse_psql_options(int argc, char *argv[
*** 445,450 ****
--- 461,487 ----
  				pset.popt.topt.fieldSep.separator = pg_strdup(optarg);
  				pset.popt.topt.fieldSep.separator_zero = false;
  				break;
+ 			case 'g':
+ 				{
+ 					GroupCommand *cmd = pg_malloc(sizeof(GroupCommand));
+ 					GroupCommand *ptr = pset.group_commands;
+ 
+ 					group_cmd_opt_is_used = true;
+ 
+ 					if (ptr == NULL)
+ 						pset.group_commands = cmd;
+ 					else
+ 					{
+ 						while (ptr->next != NULL)
+ 							ptr =  ptr->next;
+ 
+ 						ptr->next = cmd;
+ 					}
+ 					cmd->next = NULL;
+ 					cmd->actions = pg_strdup(optarg);
+ 					options->action = ACT_GROUP_COMMANDS;
+ 				}
+ 				break;
  			case 'h':
  				options->host = pg_strdup(optarg);
  				break;
*************** parse_psql_options(int argc, char *argv[
*** 601,606 ****
--- 638,650 ----
  		}
  	}
  
+ 	if (cmd_opt_is_used && group_cmd_opt_is_used)
+ 	{
+ 		fprintf(stderr, _("%s: options -c/--command and -g/--group_command cannot be used together\n"),
+ 				pset.progname);
+ 		exit(EXIT_FAILURE);
+ 	}
+ 
  	/*
  	 * if we still have arguments, use it as the database name and username
  	 */

diff --git a/doc/src/sgml/ref/psql-ref.sgml b/doc/src/sgml/ref/psql-ref.sgml
new file mode 100644
index 212dbfa..18ff8e5
*** a/doc/src/sgml/ref/psql-ref.sgml
--- b/doc/src/sgml/ref/psql-ref.sgml
*************** EOF
*** 223,228 ****
--- 223,268 ----
      </varlistentry>
  
      <varlistentry>
+       <term><option>-g <replaceable class="parameter">command(s)</replaceable></></term>
+       <term><option>--group-command=<replaceable class="parameter">command(s)</replaceable></></term>
+       <listitem>
+       <para>
+       Specifies that <application>psql</application> is to execute one or
+       more command strings, <replaceable class="parameter">commands</replaceable>,
+       and then exit. This is useful in shell scripts. Start-up files
+       (<filename>psqlrc</filename> and <filename>~/.psqlrc</filename>) are
+       ignored with this option.
+       </para>
+ 
+       <para>
+       There are a few differences between <option>-c</option> and
+       <option>-g</option> options. The option <option>-c</option> can be used
+       only once. The option <option>-g</option> can be used more times.
+       This can simplify writing some non trivial SQL commands. With the
+       <option>-g</option> option it is possible to call several <application>psql</application>
+       parametrized backslash commands. When you execute multiple SQL
+       commands via <option>-c</option> option, only result of last command
+       is returned. The execution started by <option>-g</option> option shows
+       result of all commands.
+       </para>
+ 
+       <para>
+       Another difference is in wrapping the transaction. The <option>-c</option>
+       option runs commands in one transaction. The <option>-g</option> option
+       uses autocommit mode by default. This allows running multiple commads
+       which would otherwise not be allowed to execute within one transaction.
+       This is typical for <command>VACUUM</command> command.
+ <programlisting>
+ psql -Atq -g "VACUUM FULL foo; SELECT pg_relation_size('foo')"
+ psql -Atq -g "VACUUM FULL foo" -g "SELECT pg_relation_size('foo')"
+ </programlisting>
+ 
+       </para>
+ 
+       </listitem>
+     </varlistentry>
+ 
+     <varlistentry>
        <term><option>-h <replaceable class="parameter">hostname</replaceable></></term>
        <term><option>--host=<replaceable class="parameter">hostname</replaceable></></term>
        <listitem>
diff --git a/src/bin/psql/command.c b/src/bin/psql/command.c
new file mode 100644
index 50d3ff5..73ed5c1
*** a/src/bin/psql/command.c
--- b/src/bin/psql/command.c
*************** process_file(char *filename, bool single
*** 2293,2299 ****
  	int			result;
  	char	   *oldfilename;
  	char		relpath[MAXPGPATH];
- 	PGresult   *res;
  
  	if (!filename)
  	{
--- 2293,2298 ----
*************** process_file(char *filename, bool single
*** 2338,2374 ****
  	oldfilename = pset.inputfile;
  	pset.inputfile = filename;
  
! 	if (single_txn)
! 	{
! 		if ((res = PSQLexec("BEGIN")) == NULL)
! 		{
! 			if (pset.on_error_stop)
! 			{
! 				result = EXIT_USER;
! 				goto error;
! 			}
! 		}
! 		else
! 			PQclear(res);
! 	}
! 
! 	result = MainLoop(fd);
! 
! 	if (single_txn)
! 	{
! 		if ((res = PSQLexec("COMMIT")) == NULL)
! 		{
! 			if (pset.on_error_stop)
! 			{
! 				result = EXIT_USER;
! 				goto error;
! 			}
! 		}
! 		else
! 			PQclear(res);
! 	}
  
- error:
  	if (fd != stdin)
  		fclose(fd);
  
--- 2337,2344 ----
  	oldfilename = pset.inputfile;
  	pset.inputfile = filename;
  
! 	result = MainLoop(fd, single_txn);
  
  	if (fd != stdin)
  		fclose(fd);
  
*************** error:
*** 2376,2383 ****
  	return result;
  }
  
- 
- 
  static const char *
  _align2string(enum printFormat in)
  {
--- 2346,2351 ----
diff --git a/src/bin/psql/help.c b/src/bin/psql/help.c
new file mode 100644
index 5b63e76..2ef4ea6
*** a/src/bin/psql/help.c
--- b/src/bin/psql/help.c
*************** usage(unsigned short int pager)
*** 83,88 ****
--- 83,90 ----
  	fprintf(output, _("  -c, --command=COMMAND    run only single command (SQL or internal) and exit\n"));
  	fprintf(output, _("  -d, --dbname=DBNAME      database name to connect to (default: \"%s\")\n"), env);
  	fprintf(output, _("  -f, --file=FILENAME      execute commands from file, then exit\n"));
+ 	fprintf(output, _("  -g, --group-command=COMMAND\n"
+ 					  "                           run more groups of commands (SQL or internal) and exit\n"));
  	fprintf(output, _("  -l, --list               list available databases, then exit\n"));
  	fprintf(output, _("  -v, --set=, --variable=NAME=VALUE\n"
  					  "                           set psql variable NAME to VALUE\n"
diff --git a/src/bin/psql/mainloop.c b/src/bin/psql/mainloop.c
new file mode 100644
index b6cef94..4147238
*** a/src/bin/psql/mainloop.c
--- b/src/bin/psql/mainloop.c
***************
*** 24,31 ****
   * This loop is re-entrant. May be called by \i command
   *	which reads input from a file.
   */
! int
! MainLoop(FILE *source)
  {
  	PsqlScanState scan_state;	/* lexer working state */
  	volatile PQExpBuffer query_buf;		/* buffer for query being accumulated */
--- 24,31 ----
   * This loop is re-entrant. May be called by \i command
   *	which reads input from a file.
   */
! static int
! _MainLoop(FILE *source)
  {
  	PsqlScanState scan_state;	/* lexer working state */
  	volatile PQExpBuffer query_buf;		/* buffer for query being accumulated */
*************** MainLoop(FILE *source)
*** 43,48 ****
--- 43,49 ----
  	volatile promptStatus_t prompt_status = PROMPT_READY;
  	volatile int count_eof = 0;
  	volatile bool die_on_error = false;
+ 	GroupCommand *cmd = pset.group_commands;
  
  	/* Save the prior command source */
  	FILE	   *prev_cmd_source;
*************** MainLoop(FILE *source)
*** 135,140 ****
--- 136,155 ----
  				prompt_status = PROMPT_READY;
  			line = gets_interactive(get_prompt(prompt_status));
  		}
+ 		else if (pset.group_commands != NULL)
+ 		{
+ 			/* Is there some unprocessed group command? */
+ 			if (cmd != NULL)
+ 			{
+ 				line = cmd->actions;
+ 				cmd = cmd->next;
+ 			}
+ 			else
+ 			{
+ 				successResult = EXIT_SUCCESS;
+ 				break;
+ 			}
+ 		}
  		else
  		{
  			line = gets_fromFile(source);
*************** MainLoop(FILE *source)
*** 451,456 ****
--- 466,508 ----
  	return successResult;
  }	/* MainLoop() */
  
+ /*
+  * Transactional MainLoop
+  *
+  * allow to execute all statements in single transaction
+  */
+ int
+ MainLoop(FILE *source, bool single_txn)
+ {
+ 	int			result;
+ 	PGresult   *res;
+ 
+ 	if (single_txn)
+ 	{
+ 		if ((res = PSQLexec("BEGIN")) == NULL)
+ 		{
+ 			if (pset.on_error_stop)
+ 				return EXIT_USER;
+ 		}
+ 		else
+ 			PQclear(res);
+ 	}
+ 
+ 	result = _MainLoop(source);
+ 
+ 	if (single_txn)
+ 	{
+ 		if ((res = PSQLexec("COMMIT")) == NULL)
+ 		{
+ 			if (pset.on_error_stop)
+ 				return EXIT_USER;
+ 		}
+ 		else
+ 			PQclear(res);
+ 	}
+ 
+ 	return result;
+ }
  
  /*
   * psqlscan.c is #include'd here instead of being compiled on its own.
diff --git a/src/bin/psql/mainloop.h b/src/bin/psql/mainloop.h
new file mode 100644
index 8f1325c..53c9a11
*** a/src/bin/psql/mainloop.h
--- b/src/bin/psql/mainloop.h
***************
*** 10,15 ****
  
  #include "postgres_fe.h"
  
! int			MainLoop(FILE *source);
  
  #endif   /* MAINLOOP_H */
--- 10,15 ----
  
  #include "postgres_fe.h"
  
! int			MainLoop(FILE *source, bool single_txn);
  
  #endif   /* MAINLOOP_H */
diff --git a/src/bin/psql/settings.h b/src/bin/psql/settings.h
new file mode 100644
index 1885bb1..29455ac
*** a/src/bin/psql/settings.h
--- b/src/bin/psql/settings.h
*************** enum trivalue
*** 77,82 ****
--- 77,88 ----
  	TRI_YES
  };
  
+ typedef struct _GroupCommand
+ {
+ 	char *actions;
+ 	struct _GroupCommand *next;
+ } GroupCommand;
+ 
  typedef struct _psqlSettings
  {
  	PGconn	   *db;				/* connection to backend */
*************** typedef struct _psqlSettings
*** 130,135 ****
--- 136,142 ----
  	const char *prompt3;
  	PGVerbosity verbosity;		/* current error verbosity level */
  	PGContextVisibility show_context;	/* current context display level */
+ 	GroupCommand *group_commands;
  } PsqlSettings;
  
  extern PsqlSettings pset;
diff --git a/src/bin/psql/startup.c b/src/bin/psql/startup.c
new file mode 100644
index 7aa997d..df334b4
*** a/src/bin/psql/startup.c
--- b/src/bin/psql/startup.c
*************** enum _actions
*** 54,60 ****
  	ACT_SINGLE_SLASH,
  	ACT_LIST_DB,
  	ACT_SINGLE_QUERY,
! 	ACT_FILE
  };
  
  struct adhoc_opts
--- 54,61 ----
  	ACT_SINGLE_SLASH,
  	ACT_LIST_DB,
  	ACT_SINGLE_QUERY,
! 	ACT_FILE,
! 	ACT_GROUP_COMMANDS
  };
  
  struct adhoc_opts
*************** main(int argc, char *argv[])
*** 159,164 ****
--- 160,167 ----
  	SetVariable(pset.vars, "PROMPT2", DEFAULT_PROMPT2);
  	SetVariable(pset.vars, "PROMPT3", DEFAULT_PROMPT3);
  
+ 	pset.group_commands = NULL;
+ 
  	parse_psql_options(argc, argv, &options);
  
  	/*
*************** main(int argc, char *argv[])
*** 327,332 ****
--- 330,342 ----
  			? EXIT_SUCCESS : EXIT_FAILURE;
  	}
  
+ 	else if (options.action == ACT_GROUP_COMMANDS)
+ 	{
+ 		pset.notty = true;
+ 		SetVariableBool(pset.vars, "SINGLELINE");
+ 		successResult = MainLoop(NULL, options.single_txn);
+ 	}
+ 
  	/*
  	 * or otherwise enter interactive main loop
  	 */
*************** main(int argc, char *argv[])
*** 339,345 ****
  		if (!pset.quiet)
  			printf(_("Type \"help\" for help.\n\n"));
  		initializeInput(options.no_readline ? 0 : 1);
! 		successResult = MainLoop(stdin);
  	}
  
  	/* clean up */
--- 349,355 ----
  		if (!pset.quiet)
  			printf(_("Type \"help\" for help.\n\n"));
  		initializeInput(options.no_readline ? 0 : 1);
! 		successResult = MainLoop(stdin, false);
  	}
  
  	/* clean up */
*************** parse_psql_options(int argc, char *argv[
*** 371,376 ****
--- 381,387 ----
  		{"file", required_argument, NULL, 'f'},
  		{"field-separator", required_argument, NULL, 'F'},
  		{"field-separator-zero", no_argument, NULL, 'z'},
+ 		{"group-command", required_argument, NULL, 'g'},
  		{"host", required_argument, NULL, 'h'},
  		{"html", no_argument, NULL, 'H'},
  		{"list", no_argument, NULL, 'l'},
*************** parse_psql_options(int argc, char *argv[
*** 402,410 ****
  	int			optindex;
  	int			c;
  
  	memset(options, 0, sizeof *options);
  
! 	while ((c = getopt_long(argc, argv, "aAbc:d:eEf:F:h:HlL:no:p:P:qR:sStT:U:v:VwWxXz?01",
  							long_options, &optindex)) != -1)
  	{
  		switch (c)
--- 413,424 ----
  	int			optindex;
  	int			c;
  
+ 	bool			cmd_opt_is_used = false;
+ 	bool			group_cmd_opt_is_used = false;
+ 
  	memset(options, 0, sizeof *options);
  
! 	while ((c = getopt_long(argc, argv, "aAbc:d:eEf:F:g:h:HlL:no:p:P:qR:sStT:U:v:VwWxXz?01",
  							long_options, &optindex)) != -1)
  	{
  		switch (c)
*************** parse_psql_options(int argc, char *argv[
*** 419,424 ****
--- 433,440 ----
  				SetVariable(pset.vars, "ECHO", "errors");
  				break;
  			case 'c':
+ 				cmd_opt_is_used = true;
+ 
  				options->action_string = pg_strdup(optarg);
  				if (optarg[0] == '\\')
  				{
*************** parse_psql_options(int argc, char *argv[
*** 445,450 ****
--- 461,487 ----
  				pset.popt.topt.fieldSep.separator = pg_strdup(optarg);
  				pset.popt.topt.fieldSep.separator_zero = false;
  				break;
+ 			case 'g':
+ 				{
+ 					GroupCommand *cmd = pg_malloc(sizeof(GroupCommand));
+ 					GroupCommand *ptr = pset.group_commands;
+ 
+ 					group_cmd_opt_is_used = true;
+ 
+ 					if (ptr == NULL)
+ 						pset.group_commands = cmd;
+ 					else
+ 					{
+ 						while (ptr->next != NULL)
+ 							ptr =  ptr->next;
+ 
+ 						ptr->next = cmd;
+ 					}
+ 					cmd->next = NULL;
+ 					cmd->actions = pg_strdup(optarg);
+ 					options->action = ACT_GROUP_COMMANDS;
+ 				}
+ 				break;
  			case 'h':
  				options->host = pg_strdup(optarg);
  				break;
*************** parse_psql_options(int argc, char *argv[
*** 601,606 ****
--- 638,650 ----
  		}
  	}
  
+ 	if (cmd_opt_is_used && group_cmd_opt_is_used)
+ 	{
+ 		fprintf(stderr, _("%s: options -c/--command and -g/--group_command cannot be used together\n"),
+ 				pset.progname);
+ 		exit(EXIT_FAILURE);
+ 	}
+ 
  	/*
  	 * if we still have arguments, use it as the database name and username
  	 */

diff --git a/doc/src/sgml/ref/psql-ref.sgml b/doc/src/sgml/ref/psql-ref.sgml
new file mode 100644
index 5899bb4..3ef32d2
*** a/doc/src/sgml/ref/psql-ref.sgml
--- b/doc/src/sgml/ref/psql-ref.sgml
*************** EOF
*** 132,137 ****
--- 132,176 ----
      </varlistentry>
  
      <varlistentry>
+       <term><option>-C <replaceable class="parameter">command(s)</replaceable></></term>
+       <term><option>--multi-command=<replaceable class="parameter">command(s)</replaceable></></term>
+       <listitem>
+       <para>
+       Specifies that <application>psql</application> is to execute one or
+       more command strings, <replaceable class="parameter">commands</replaceable>,
+       and then exit. This is useful in shell scripts. Start-up files
+       (<filename>psqlrc</filename> and <filename>~/.psqlrc</filename>) are
+       ignored with this option.
+       </para>
+ 
+       <para>
+       There are a few differences between <option>-c</option> and
+       <option>-C</option> options. The option <option>-c</option> can be used
+       only once. The option <option>-C</option> can be used more times.
+       This can simplify writing some non trivial SQL commands. With the
+       <option>-C</option> option it is possible to call several <application>psql</application>
+       parametrized backslash commands. When you execute multiple SQL
+       commands via <option>-c</option> option, only result of last command
+       is returned. The execution started by <option>-C</option> option shows
+       result of all commands.
+       </para>
+ 
+       <para>
+       Another difference is in wrapping the transaction. The <option>-c</option>
+       option runs commands in one transaction. The <option>-C</option> option
+       uses autocommit mode by default. This allows running multiple commads
+       which would otherwise not be allowed to execute within one transaction.
+       This is typical for <command>VACUUM</command> command.
+ <programlisting>
+ psql -Atq -C "VACUUM FULL foo; SELECT pg_relation_size('foo')"
+ psql -Atq -C "VACUUM FULL foo" -C "SELECT pg_relation_size('foo')"
+ </programlisting>
+       </para>
+ 
+       </listitem>
+     </varlistentry>
+ 
+     <varlistentry>
        <term><option>-d <replaceable class="parameter">dbname</replaceable></></term>
        <term><option>--dbname=<replaceable class="parameter">dbname</replaceable></></term>
        <listitem>
diff --git a/src/bin/psql/command.c b/src/bin/psql/command.c
new file mode 100644
index 72c00c1..1bc20d3
*** a/src/bin/psql/command.c
--- b/src/bin/psql/command.c
*************** process_file(char *filename, bool single
*** 2293,2299 ****
  	int			result;
  	char	   *oldfilename;
  	char		relpath[MAXPGPATH];
- 	PGresult   *res;
  
  	if (!filename)
  	{
--- 2293,2298 ----
*************** process_file(char *filename, bool single
*** 2338,2374 ****
  	oldfilename = pset.inputfile;
  	pset.inputfile = filename;
  
! 	if (single_txn)
! 	{
! 		if ((res = PSQLexec("BEGIN")) == NULL)
! 		{
! 			if (pset.on_error_stop)
! 			{
! 				result = EXIT_USER;
! 				goto error;
! 			}
! 		}
! 		else
! 			PQclear(res);
! 	}
! 
! 	result = MainLoop(fd);
! 
! 	if (single_txn)
! 	{
! 		if ((res = PSQLexec("COMMIT")) == NULL)
! 		{
! 			if (pset.on_error_stop)
! 			{
! 				result = EXIT_USER;
! 				goto error;
! 			}
! 		}
! 		else
! 			PQclear(res);
! 	}
  
- error:
  	if (fd != stdin)
  		fclose(fd);
  
--- 2337,2344 ----
  	oldfilename = pset.inputfile;
  	pset.inputfile = filename;
  
! 	result = MainLoop(fd, single_txn);
  
  	if (fd != stdin)
  		fclose(fd);
  
*************** error:
*** 2376,2383 ****
  	return result;
  }
  
- 
- 
  static const char *
  _align2string(enum printFormat in)
  {
--- 2346,2351 ----
diff --git a/src/bin/psql/help.c b/src/bin/psql/help.c
new file mode 100644
index 5b63e76..7058ada
*** a/src/bin/psql/help.c
--- b/src/bin/psql/help.c
*************** usage(unsigned short int pager)
*** 81,86 ****
--- 81,88 ----
  	if (!env)
  		env = user;
  	fprintf(output, _("  -c, --command=COMMAND    run only single command (SQL or internal) and exit\n"));
+ 	fprintf(output, _("  -C, --multi-command=COMMAND\n"
+ 					  "                           run more multiple commands (SQL or internal) and exit\n"));
  	fprintf(output, _("  -d, --dbname=DBNAME      database name to connect to (default: \"%s\")\n"), env);
  	fprintf(output, _("  -f, --file=FILENAME      execute commands from file, then exit\n"));
  	fprintf(output, _("  -l, --list               list available databases, then exit\n"));
diff --git a/src/bin/psql/mainloop.c b/src/bin/psql/mainloop.c
new file mode 100644
index b6cef94..930d2c5
*** a/src/bin/psql/mainloop.c
--- b/src/bin/psql/mainloop.c
***************
*** 25,31 ****
   *	which reads input from a file.
   */
  int
! MainLoop(FILE *source)
  {
  	PsqlScanState scan_state;	/* lexer working state */
  	volatile PQExpBuffer query_buf;		/* buffer for query being accumulated */
--- 25,31 ----
   *	which reads input from a file.
   */
  int
! MainLoop(FILE *source, bool single_txn)
  {
  	PsqlScanState scan_state;	/* lexer working state */
  	volatile PQExpBuffer query_buf;		/* buffer for query being accumulated */
*************** MainLoop(FILE *source)
*** 43,48 ****
--- 43,50 ----
  	volatile promptStatus_t prompt_status = PROMPT_READY;
  	volatile int count_eof = 0;
  	volatile bool die_on_error = false;
+ 	Commands *cmds = pset.commands;
+ 	PGresult *result;
  
  	/* Save the prior command source */
  	FILE	   *prev_cmd_source;
*************** MainLoop(FILE *source)
*** 60,65 ****
--- 62,79 ----
  	pset.lineno = 0;
  	pset.stmt_lineno = 1;
  
+ 	/* Start transaction when it is required before any allocation */
+ 	if (single_txn)
+ 	{
+ 		if ((result = PSQLexec("BEGIN")) == NULL)
+ 		{
+ 			if (pset.on_error_stop)
+ 				return EXIT_USER;
+ 		}
+ 		else
+ 			PQclear(result);
+ 	}
+ 
  	/* Create working state */
  	scan_state = psql_scan_create();
  
*************** MainLoop(FILE *source)
*** 135,140 ****
--- 149,168 ----
  				prompt_status = PROMPT_READY;
  			line = gets_interactive(get_prompt(prompt_status));
  		}
+ 		else if (pset.commands != NULL)
+ 		{
+ 			/* Is there some unprocessed multi command? */
+ 			if (cmds != NULL)
+ 			{
+ 				line = cmds->actions;
+ 				cmds = cmds->next;
+ 			}
+ 			else
+ 			{
+ 				successResult = EXIT_SUCCESS;
+ 				break;
+ 			}
+ 		}
  		else
  		{
  			line = gets_fromFile(source);
*************** MainLoop(FILE *source)
*** 429,434 ****
--- 457,474 ----
  			successResult = EXIT_BADCONN;
  	}
  
+ 	/* Commit success transaction */
+ 	if (single_txn && successResult == EXIT_SUCCESS)
+ 	{
+ 		if ((result = PSQLexec("COMMIT")) == NULL)
+ 		{
+ 			if (die_on_error)
+ 				successResult = EXIT_USER;
+ 		}
+ 		else
+ 			PQclear(result);
+ 	}
+ 
  	/*
  	 * Let's just make real sure the SIGINT handler won't try to use
  	 * sigint_interrupt_jmp after we exit this routine.  If there is an outer
*************** MainLoop(FILE *source)
*** 451,457 ****
  	return successResult;
  }	/* MainLoop() */
  
- 
  /*
   * psqlscan.c is #include'd here instead of being compiled on its own.
   * This is because we need postgres_fe.h to be read before any system
--- 491,496 ----
diff --git a/src/bin/psql/mainloop.h b/src/bin/psql/mainloop.h
new file mode 100644
index 8f1325c..53c9a11
*** a/src/bin/psql/mainloop.h
--- b/src/bin/psql/mainloop.h
***************
*** 10,15 ****
  
  #include "postgres_fe.h"
  
! int			MainLoop(FILE *source);
  
  #endif   /* MAINLOOP_H */
--- 10,15 ----
  
  #include "postgres_fe.h"
  
! int			MainLoop(FILE *source, bool single_txn);
  
  #endif   /* MAINLOOP_H */
diff --git a/src/bin/psql/settings.h b/src/bin/psql/settings.h
new file mode 100644
index 1885bb1..39ced85
*** a/src/bin/psql/settings.h
--- b/src/bin/psql/settings.h
*************** enum trivalue
*** 77,82 ****
--- 77,88 ----
  	TRI_YES
  };
  
+ typedef struct _Commands
+ {
+ 	char *actions;
+ 	struct _Commands *next;
+ } Commands;
+ 
  typedef struct _psqlSettings
  {
  	PGconn	   *db;				/* connection to backend */
*************** typedef struct _psqlSettings
*** 130,135 ****
--- 136,142 ----
  	const char *prompt3;
  	PGVerbosity verbosity;		/* current error verbosity level */
  	PGContextVisibility show_context;	/* current context display level */
+ 	Commands *commands;
  } PsqlSettings;
  
  extern PsqlSettings pset;
diff --git a/src/bin/psql/startup.c b/src/bin/psql/startup.c
new file mode 100644
index 7aa997d..6118b07
*** a/src/bin/psql/startup.c
--- b/src/bin/psql/startup.c
*************** enum _actions
*** 54,60 ****
  	ACT_SINGLE_SLASH,
  	ACT_LIST_DB,
  	ACT_SINGLE_QUERY,
! 	ACT_FILE
  };
  
  struct adhoc_opts
--- 54,61 ----
  	ACT_SINGLE_SLASH,
  	ACT_LIST_DB,
  	ACT_SINGLE_QUERY,
! 	ACT_FILE,
! 	ACT_COMMAND_LINE
  };
  
  struct adhoc_opts
*************** main(int argc, char *argv[])
*** 159,164 ****
--- 160,167 ----
  	SetVariable(pset.vars, "PROMPT2", DEFAULT_PROMPT2);
  	SetVariable(pset.vars, "PROMPT3", DEFAULT_PROMPT3);
  
+ 	pset.commands = NULL;
+ 
  	parse_psql_options(argc, argv, &options);
  
  	/*
*************** main(int argc, char *argv[])
*** 327,332 ****
--- 330,344 ----
  			? EXIT_SUCCESS : EXIT_FAILURE;
  	}
  
+ 	else if (options.action == ACT_COMMAND_LINE)
+ 	{
+ 		pset.notty = true;
+ 
+ 		/* use singleline mode, doesn't need semicolon on the end line */
+ 		SetVariableBool(pset.vars, "SINGLELINE");
+ 		successResult = MainLoop(NULL, options.single_txn);
+ 	}
+ 
  	/*
  	 * or otherwise enter interactive main loop
  	 */
*************** main(int argc, char *argv[])
*** 339,345 ****
  		if (!pset.quiet)
  			printf(_("Type \"help\" for help.\n\n"));
  		initializeInput(options.no_readline ? 0 : 1);
! 		successResult = MainLoop(stdin);
  	}
  
  	/* clean up */
--- 351,357 ----
  		if (!pset.quiet)
  			printf(_("Type \"help\" for help.\n\n"));
  		initializeInput(options.no_readline ? 0 : 1);
! 		successResult = MainLoop(stdin, false);
  	}
  
  	/* clean up */
*************** parse_psql_options(int argc, char *argv[
*** 375,380 ****
--- 387,393 ----
  		{"html", no_argument, NULL, 'H'},
  		{"list", no_argument, NULL, 'l'},
  		{"log-file", required_argument, NULL, 'L'},
+ 		{"multi-command", required_argument, NULL, 'C'},
  		{"no-readline", no_argument, NULL, 'n'},
  		{"single-transaction", no_argument, NULL, '1'},
  		{"output", required_argument, NULL, 'o'},
*************** parse_psql_options(int argc, char *argv[
*** 402,410 ****
  	int			optindex;
  	int			c;
  
  	memset(options, 0, sizeof *options);
  
! 	while ((c = getopt_long(argc, argv, "aAbc:d:eEf:F:h:HlL:no:p:P:qR:sStT:U:v:VwWxXz?01",
  							long_options, &optindex)) != -1)
  	{
  		switch (c)
--- 415,426 ----
  	int			optindex;
  	int			c;
  
+ 	bool			cmd_opt_is_used = false;
+ 	bool			commands_opt_is_used = false;
+ 
  	memset(options, 0, sizeof *options);
  
! 	while ((c = getopt_long(argc, argv, "aAbc:C:d:eEf:F:h:HlL:no:p:P:qR:sStT:U:v:VwWxXz?01",
  							long_options, &optindex)) != -1)
  	{
  		switch (c)
*************** parse_psql_options(int argc, char *argv[
*** 419,424 ****
--- 435,442 ----
  				SetVariable(pset.vars, "ECHO", "errors");
  				break;
  			case 'c':
+ 				cmd_opt_is_used = true;
+ 
  				options->action_string = pg_strdup(optarg);
  				if (optarg[0] == '\\')
  				{
*************** parse_psql_options(int argc, char *argv[
*** 428,433 ****
--- 446,472 ----
  				else
  					options->action = ACT_SINGLE_QUERY;
  				break;
+ 			case 'C':
+ 				{
+ 					Commands *cmds = pg_malloc(sizeof(Commands));
+ 					Commands *ptr = pset.commands;
+ 
+ 					commands_opt_is_used = true;
+ 
+ 					if (ptr == NULL)
+ 						pset.commands = cmds;
+ 					else
+ 					{
+ 						while (ptr->next != NULL)
+ 							ptr =  ptr->next;
+ 
+ 						ptr->next = cmds;
+ 					}
+ 					cmds->next = NULL;
+ 					cmds->actions = pg_strdup(optarg);
+ 					options->action = ACT_COMMAND_LINE;
+ 				}
+ 				break;
  			case 'd':
  				options->dbname = pg_strdup(optarg);
  				break;
*************** parse_psql_options(int argc, char *argv[
*** 601,606 ****
--- 640,652 ----
  		}
  	}
  
+ 	if (cmd_opt_is_used && commands_opt_is_used)
+ 	{
+ 		fprintf(stderr, _("%s: options -c/--command and -C/--multi_command cannot be used together\n"),
+ 				pset.progname);
+ 		exit(EXIT_FAILURE);
+ 	}
+ 
  	/*
  	 * if we still have arguments, use it as the database name and username
  	 */

From dff689aa6518cd0100e296573e16f9175dd4c07e Mon Sep 17 00:00:00 2001
From: Catalin Iacob <iacobcatalin@gmail.com>
Date: Wed, 25 Nov 2015 08:04:43 +0100
Subject: [PATCH] Update docs for repeated -c

---
 doc/src/sgml/ref/psql-ref.sgml | 106 ++++++++++++++++++++++++-----------------
 1 file changed, 62 insertions(+), 44 deletions(-)

diff --git a/doc/src/sgml/ref/psql-ref.sgml b/doc/src/sgml/ref/psql-ref.sgml
index 5899bb4..2928c92 100644
--- a/doc/src/sgml/ref/psql-ref.sgml
+++ b/doc/src/sgml/ref/psql-ref.sgml
@@ -38,9 +38,10 @@ PostgreSQL documentation
      <productname>PostgreSQL</productname>. It enables you to type in
      queries interactively, issue them to
      <productname>PostgreSQL</productname>, and see the query results.
-     Alternatively, input can be from a file. In addition, it provides a
-     number of meta-commands and various shell-like features to
-     facilitate writing scripts and automating a wide variety of tasks.
+     Alternatively, input can be from a file or from command line
+     arguments. In addition, it provides a number of meta-commands and various
+     shell-like features to facilitate writing scripts and automating a wide
+     variety of tasks.
     </para>
  </refsect1>
 
@@ -89,38 +90,45 @@ PostgreSQL documentation
       <term><option>--command=<replaceable class="parameter">command</replaceable></></term>
       <listitem>
       <para>
-      Specifies that <application>psql</application> is to execute one
-      command string, <replaceable class="parameter">command</replaceable>,
-      and then exit. This is useful in shell scripts. Start-up files
-      (<filename>psqlrc</filename> and <filename>~/.psqlrc</filename>) are
-      ignored with this option.
+      Specifies that <application>psql</application> is to execute the given
+      command string, <replaceable class="parameter">command</replaceable>.
+      This option can be repeated and combined in any order with
+      the <option>-f</option> option.
       </para>
       <para>
-      <replaceable class="parameter">command</replaceable> must be either
-      a command string that is completely parsable by the server (i.e.,
-      it contains no <application>psql</application>-specific features),
-      or a single backslash command. Thus you cannot mix
-      <acronym>SQL</acronym> and <application>psql</application>
-      meta-commands with this option. To achieve that, you could
-      pipe the string into <application>psql</application>, for example:
-      <literal>echo '\x \\ SELECT * FROM foo;' | psql</literal>.
+      <replaceable class="parameter">command</replaceable> must be either a
+      command string that is completely parsable by the server (i.e., it
+      contains no <application>psql</application>-specific features), or a
+      single backslash command. Thus you cannot mix
+      <acronym>SQL</acronym> and <application>psql</application> meta-commands
+      with this option. To achieve that, you could use
+      repeated <option>-c</option> options or pipe the string
+      into <application>psql</application>, for example:
+      <literal>psql -c '\x' -c 'SELECT * FROM foo;'</literal> or
+      <literal>echo '\x \\ SELECT * FROM foo;' | psql</literal>
       (<literal>\\</> is the separator meta-command.)
       </para>
       <para>
-       If the command string contains multiple SQL commands, they are
-       processed in a single transaction, unless there are explicit
-       <command>BEGIN</>/<command>COMMIT</> commands included in the
-       string to divide it into multiple transactions.  This is
-       different from the behavior when the same string is fed to
-       <application>psql</application>'s standard input.  Also, only
-       the result of the last SQL command is returned.
+       Each command string passed to <option>-c</option> is sent to the server
+       as a single query. Because of this, the server executes it as a single
+       transaction, even if a command string contains
+       multiple <acronym>SQL</acronym> commands, unless there are
+       explicit <command>BEGIN</>/<command>COMMIT</> commands included in the
+       string to divide it into multiple transactions.  Also, the server only
+       returns the result of the last <acronym>SQL</acronym> command to the
+       client.  This is different from the behavior when the same string with
+       multiple <acronym>SQL</acronym> commands is fed
+       to <application>psql</application>'s standard input because
+       then <application>psql</application> sends each <acronym>SQL</acronym>
+       command separately.
       </para>
       <para>
-       Because of these legacy behaviors, putting more than one command in
-       the <option>-c</option> string often has unexpected results.  It's
-       better to feed multiple commands to <application>psql</application>'s
-       standard input, either using <application>echo</application> as
-       illustrated above, or via a shell here-document, for example:
+       Because of the execution as a single query, putting more than one
+       command in the <option>-c</option> string often has unexpected results.
+       It's better to use repeated <option>-c</option> commands or feed
+       multiple commands to <application>psql</application>'s standard input,
+       either using <application>echo</application> as illustrated above, or
+       via a shell here-document, for example:
 <programlisting>
 psql &lt;&lt;EOF
 \x
@@ -183,11 +191,13 @@ EOF
       <term><option>--file=<replaceable class="parameter">filename</replaceable></></term>
       <listitem>
       <para>
-      Use the file <replaceable class="parameter">filename</replaceable>
-      as the source of commands instead of reading commands interactively.
-      After the file is processed, <application>psql</application>
-      terminates. This is in many ways equivalent to the meta-command
-      <command>\i</command>.
+      Use the file <replaceable class="parameter">filename</replaceable> as
+      the source of commands instead of reading commands interactively.  This
+      option can be repeated and combined in any order with
+      the <option>-c</option> option.  After the commands in
+      every <option>-c</option> command string and <option>-f</option> file
+      are processed, <application>psql</application> terminates.  This option
+      is in many ways equivalent to the meta-command <command>\i</command>.
       </para>
 
       <para>
@@ -539,20 +549,21 @@ EOF
       <term><option>--single-transaction</option></term>
       <listitem>
        <para>
-        When <application>psql</application> executes a script, adding
-        this option wraps <command>BEGIN</>/<command>COMMIT</> around the
-        script to execute it as a single transaction.  This ensures that
-        either all the commands complete successfully, or no changes are
-        applied.
+        When <application>psql</application> executes commands from a script
+        and/or a <option>-c</option> option, adding this option
+        wraps <command>BEGIN</>/<command>COMMIT</> around all of those
+        commands as a whole to execute them as a single transaction.  This
+        ensures that either all the commands complete successfully, or no
+        changes are applied.
        </para>
 
        <para>
-        If the script itself uses <command>BEGIN</>, <command>COMMIT</>,
+        If the commands themselves
+        contain <command>BEGIN</>, <command>COMMIT</>,
         or <command>ROLLBACK</>, this option will not have the desired
-        effects.
-        Also, if the script contains any command that cannot be executed
-        inside a transaction block, specifying this option will cause that
-        command (and hence the whole transaction) to fail.
+        effects.  Also, if an individual command cannot be executed inside a
+        transaction block, specifying this option will cause the whole
+        transaction to fail.
        </para>
       </listitem>
      </varlistentry>
@@ -3725,7 +3736,7 @@ PSQL_EDITOR_LINENUMBER_ARG='--line '
    <term><filename>psqlrc</filename> and <filename>~/.psqlrc</filename></term>
    <listitem>
     <para>
-     Unless it is passed an <option>-X</option> or <option>-c</option> option,
+     Unless it is passed an <option>-X</option> option,
      <application>psql</application> attempts to read and execute commands
      from the system-wide startup file (<filename>psqlrc</filename>) and then
      the user's personal startup file (<filename>~/.psqlrc</filename>), after
@@ -3819,6 +3830,13 @@ PSQL_EDITOR_LINENUMBER_ARG='--line '
       </para>
       </listitem>
 
+      <listitem>
+      <para>
+       Before <productname>PostgreSQL</productname> 9.6, <option>-c</option>
+       used to imply <option>-X</option> and therefore it wouldn't
+       read <filename>psqlrc</filename> files, that is no longer the case.
+      </para>
+      </listitem>
     </itemizedlist>
  </refsect1>
 
-- 
2.6.2

diff --git a/doc/src/sgml/ref/psql-ref.sgml b/doc/src/sgml/ref/psql-ref.sgml
new file mode 100644
index 5899bb4..2928c92
*** a/doc/src/sgml/ref/psql-ref.sgml
--- b/doc/src/sgml/ref/psql-ref.sgml
*************** PostgreSQL documentation
*** 38,46 ****
       <productname>PostgreSQL</productname>. It enables you to type in
       queries interactively, issue them to
       <productname>PostgreSQL</productname>, and see the query results.
!      Alternatively, input can be from a file. In addition, it provides a
!      number of meta-commands and various shell-like features to
!      facilitate writing scripts and automating a wide variety of tasks.
      </para>
   </refsect1>
  
--- 38,47 ----
       <productname>PostgreSQL</productname>. It enables you to type in
       queries interactively, issue them to
       <productname>PostgreSQL</productname>, and see the query results.
!      Alternatively, input can be from a file or from command line
!      arguments. In addition, it provides a number of meta-commands and various
!      shell-like features to facilitate writing scripts and automating a wide
!      variety of tasks.
      </para>
   </refsect1>
  
*************** PostgreSQL documentation
*** 89,126 ****
        <term><option>--command=<replaceable class="parameter">command</replaceable></></term>
        <listitem>
        <para>
!       Specifies that <application>psql</application> is to execute one
!       command string, <replaceable class="parameter">command</replaceable>,
!       and then exit. This is useful in shell scripts. Start-up files
!       (<filename>psqlrc</filename> and <filename>~/.psqlrc</filename>) are
!       ignored with this option.
        </para>
        <para>
!       <replaceable class="parameter">command</replaceable> must be either
!       a command string that is completely parsable by the server (i.e.,
!       it contains no <application>psql</application>-specific features),
!       or a single backslash command. Thus you cannot mix
!       <acronym>SQL</acronym> and <application>psql</application>
!       meta-commands with this option. To achieve that, you could
!       pipe the string into <application>psql</application>, for example:
!       <literal>echo '\x \\ SELECT * FROM foo;' | psql</literal>.
        (<literal>\\</> is the separator meta-command.)
        </para>
        <para>
!        If the command string contains multiple SQL commands, they are
!        processed in a single transaction, unless there are explicit
!        <command>BEGIN</>/<command>COMMIT</> commands included in the
!        string to divide it into multiple transactions.  This is
!        different from the behavior when the same string is fed to
!        <application>psql</application>'s standard input.  Also, only
!        the result of the last SQL command is returned.
        </para>
        <para>
!        Because of these legacy behaviors, putting more than one command in
!        the <option>-c</option> string often has unexpected results.  It's
!        better to feed multiple commands to <application>psql</application>'s
!        standard input, either using <application>echo</application> as
!        illustrated above, or via a shell here-document, for example:
  <programlisting>
  psql &lt;&lt;EOF
  \x
--- 90,134 ----
        <term><option>--command=<replaceable class="parameter">command</replaceable></></term>
        <listitem>
        <para>
!       Specifies that <application>psql</application> is to execute the given
!       command string, <replaceable class="parameter">command</replaceable>.
!       This option can be repeated and combined in any order with
!       the <option>-f</option> option.
        </para>
        <para>
!       <replaceable class="parameter">command</replaceable> must be either a
!       command string that is completely parsable by the server (i.e., it
!       contains no <application>psql</application>-specific features), or a
!       single backslash command. Thus you cannot mix
!       <acronym>SQL</acronym> and <application>psql</application> meta-commands
!       with this option. To achieve that, you could use
!       repeated <option>-c</option> options or pipe the string
!       into <application>psql</application>, for example:
!       <literal>psql -c '\x' -c 'SELECT * FROM foo;'</literal> or
!       <literal>echo '\x \\ SELECT * FROM foo;' | psql</literal>
        (<literal>\\</> is the separator meta-command.)
        </para>
        <para>
!        Each command string passed to <option>-c</option> is sent to the server
!        as a single query. Because of this, the server executes it as a single
!        transaction, even if a command string contains
!        multiple <acronym>SQL</acronym> commands, unless there are
!        explicit <command>BEGIN</>/<command>COMMIT</> commands included in the
!        string to divide it into multiple transactions.  Also, the server only
!        returns the result of the last <acronym>SQL</acronym> command to the
!        client.  This is different from the behavior when the same string with
!        multiple <acronym>SQL</acronym> commands is fed
!        to <application>psql</application>'s standard input because
!        then <application>psql</application> sends each <acronym>SQL</acronym>
!        command separately.
        </para>
        <para>
!        Because of the execution as a single query, putting more than one
!        command in the <option>-c</option> string often has unexpected results.
!        It's better to use repeated <option>-c</option> commands or feed
!        multiple commands to <application>psql</application>'s standard input,
!        either using <application>echo</application> as illustrated above, or
!        via a shell here-document, for example:
  <programlisting>
  psql &lt;&lt;EOF
  \x
*************** EOF
*** 183,193 ****
        <term><option>--file=<replaceable class="parameter">filename</replaceable></></term>
        <listitem>
        <para>
!       Use the file <replaceable class="parameter">filename</replaceable>
!       as the source of commands instead of reading commands interactively.
!       After the file is processed, <application>psql</application>
!       terminates. This is in many ways equivalent to the meta-command
!       <command>\i</command>.
        </para>
  
        <para>
--- 191,203 ----
        <term><option>--file=<replaceable class="parameter">filename</replaceable></></term>
        <listitem>
        <para>
!       Use the file <replaceable class="parameter">filename</replaceable> as
!       the source of commands instead of reading commands interactively.  This
!       option can be repeated and combined in any order with
!       the <option>-c</option> option.  After the commands in
!       every <option>-c</option> command string and <option>-f</option> file
!       are processed, <application>psql</application> terminates.  This option
!       is in many ways equivalent to the meta-command <command>\i</command>.
        </para>
  
        <para>
*************** EOF
*** 539,558 ****
        <term><option>--single-transaction</option></term>
        <listitem>
         <para>
!         When <application>psql</application> executes a script, adding
!         this option wraps <command>BEGIN</>/<command>COMMIT</> around the
!         script to execute it as a single transaction.  This ensures that
!         either all the commands complete successfully, or no changes are
!         applied.
         </para>
  
         <para>
!         If the script itself uses <command>BEGIN</>, <command>COMMIT</>,
          or <command>ROLLBACK</>, this option will not have the desired
!         effects.
!         Also, if the script contains any command that cannot be executed
!         inside a transaction block, specifying this option will cause that
!         command (and hence the whole transaction) to fail.
         </para>
        </listitem>
       </varlistentry>
--- 549,569 ----
        <term><option>--single-transaction</option></term>
        <listitem>
         <para>
!         When <application>psql</application> executes commands from a script
!         and/or a <option>-c</option> option, adding this option
!         wraps <command>BEGIN</>/<command>COMMIT</> around all of those
!         commands as a whole to execute them as a single transaction.  This
!         ensures that either all the commands complete successfully, or no
!         changes are applied.
         </para>
  
         <para>
!         If the commands themselves
!         contain <command>BEGIN</>, <command>COMMIT</>,
          or <command>ROLLBACK</>, this option will not have the desired
!         effects.  Also, if an individual command cannot be executed inside a
!         transaction block, specifying this option will cause the whole
!         transaction to fail.
         </para>
        </listitem>
       </varlistentry>
*************** PSQL_EDITOR_LINENUMBER_ARG='--line '
*** 3725,3731 ****
     <term><filename>psqlrc</filename> and <filename>~/.psqlrc</filename></term>
     <listitem>
      <para>
!      Unless it is passed an <option>-X</option> or <option>-c</option> option,
       <application>psql</application> attempts to read and execute commands
       from the system-wide startup file (<filename>psqlrc</filename>) and then
       the user's personal startup file (<filename>~/.psqlrc</filename>), after
--- 3736,3742 ----
     <term><filename>psqlrc</filename> and <filename>~/.psqlrc</filename></term>
     <listitem>
      <para>
!      Unless it is passed an <option>-X</option> option,
       <application>psql</application> attempts to read and execute commands
       from the system-wide startup file (<filename>psqlrc</filename>) and then
       the user's personal startup file (<filename>~/.psqlrc</filename>), after
*************** PSQL_EDITOR_LINENUMBER_ARG='--line '
*** 3819,3824 ****
--- 3830,3842 ----
        </para>
        </listitem>
  
+       <listitem>
+       <para>
+        Before <productname>PostgreSQL</productname> 9.6, <option>-c</option>
+        used to imply <option>-X</option> and therefore it wouldn't
+        read <filename>psqlrc</filename> files, that is no longer the case.
+       </para>
+       </listitem>
      </itemizedlist>
   </refsect1>
  
diff --git a/src/bin/psql/command.c b/src/bin/psql/command.c
new file mode 100644
index 72c00c1..5e3b4ed
*** a/src/bin/psql/command.c
--- b/src/bin/psql/command.c
*************** exec_command(const char *cmd,
*** 918,924 ****
  			include_relative = (strcmp(cmd, "ir") == 0
  								|| strcmp(cmd, "include_relative") == 0);
  			expand_tilde(&fname);
! 			success = (process_file(fname, false, include_relative) == EXIT_SUCCESS);
  			free(fname);
  		}
  	}
--- 918,924 ----
  			include_relative = (strcmp(cmd, "ir") == 0
  								|| strcmp(cmd, "include_relative") == 0);
  			expand_tilde(&fname);
! 			success = (process_file(fname, include_relative) == EXIT_SUCCESS);
  			free(fname);
  		}
  	}
*************** do_edit(const char *filename_arg, PQExpB
*** 2287,2299 ****
   * the file from where the currently processed file (if any) is located.
   */
  int
! process_file(char *filename, bool single_txn, bool use_relative_path)
  {
  	FILE	   *fd;
  	int			result;
  	char	   *oldfilename;
  	char		relpath[MAXPGPATH];
- 	PGresult   *res;
  
  	if (!filename)
  	{
--- 2287,2298 ----
   * the file from where the currently processed file (if any) is located.
   */
  int
! process_file(char *filename, bool use_relative_path)
  {
  	FILE	   *fd;
  	int			result;
  	char	   *oldfilename;
  	char		relpath[MAXPGPATH];
  
  	if (!filename)
  	{
*************** process_file(char *filename, bool single
*** 2338,2374 ****
  	oldfilename = pset.inputfile;
  	pset.inputfile = filename;
  
- 	if (single_txn)
- 	{
- 		if ((res = PSQLexec("BEGIN")) == NULL)
- 		{
- 			if (pset.on_error_stop)
- 			{
- 				result = EXIT_USER;
- 				goto error;
- 			}
- 		}
- 		else
- 			PQclear(res);
- 	}
- 
  	result = MainLoop(fd);
  
- 	if (single_txn)
- 	{
- 		if ((res = PSQLexec("COMMIT")) == NULL)
- 		{
- 			if (pset.on_error_stop)
- 			{
- 				result = EXIT_USER;
- 				goto error;
- 			}
- 		}
- 		else
- 			PQclear(res);
- 	}
- 
- error:
  	if (fd != stdin)
  		fclose(fd);
  
--- 2337,2344 ----
diff --git a/src/bin/psql/command.h b/src/bin/psql/command.h
new file mode 100644
index 54385e8..c817600
*** a/src/bin/psql/command.h
--- b/src/bin/psql/command.h
*************** typedef enum _backslashResult
*** 27,33 ****
  extern backslashResult HandleSlashCmds(PsqlScanState scan_state,
  				PQExpBuffer query_buf);
  
! extern int	process_file(char *filename, bool single_txn, bool use_relative_path);
  
  extern bool do_pset(const char *param,
  		const char *value,
--- 27,33 ----
  extern backslashResult HandleSlashCmds(PsqlScanState scan_state,
  				PQExpBuffer query_buf);
  
! extern int	process_file(char *filename, bool use_relative_path);
  
  extern bool do_pset(const char *param,
  		const char *value,
diff --git a/src/bin/psql/common.c b/src/bin/psql/common.c
new file mode 100644
index 0e266a3..fff16c0
*** a/src/bin/psql/common.c
--- b/src/bin/psql/common.c
*************** recognized_connection_string(const char
*** 1886,1888 ****
--- 1886,1911 ----
  {
  	return uri_prefix_length(connstr) != 0 || strchr(connstr, '=') != NULL;
  }
+ 
+ /*
+  * Support for list of actions. The SimpleStringList cannot be used due possible
+  * combination different actions with the requirement to save the order.
+  */
+ void
+ simple_action_list_append(SimpleActionList *list, int atyp, const char *val)
+ {
+ 	SimpleActionListCell  *cell;
+ 
+ 	cell = (SimpleActionListCell *)
+ 		pg_malloc(offsetof(SimpleActionListCell, val) + strlen(val) + 1);
+ 
+ 	cell->next = NULL;
+ 	cell->atyp = atyp;
+ 	strcpy(cell->val, val);
+ 
+ 	if (list->tail)
+ 		list->tail->next = cell;
+ 	else
+ 		list->head = cell;
+ 	list->tail = cell;
+ }
diff --git a/src/bin/psql/common.h b/src/bin/psql/common.h
new file mode 100644
index caf31d1..0965c35
*** a/src/bin/psql/common.h
--- b/src/bin/psql/common.h
***************
*** 14,21 ****
--- 14,43 ----
  
  #include "print.h"
  
+ enum _atypes
+ {
+ 	ACT_SINGLE_QUERY,
+ 	ACT_SINGLE_SLASH,
+ 	ACT_FILE
+ };
+ 
+ typedef struct SimpleActionListCell
+ {
+ 	struct SimpleActionListCell *next;
+ 	int 		atyp;
+ 	char		val[FLEXIBLE_ARRAY_MEMBER];
+ } SimpleActionListCell;
+ 
+ typedef struct SimpleActionList
+ {
+ 	SimpleActionListCell *head;
+ 	SimpleActionListCell *tail;
+ } SimpleActionList;
+ 
  #define atooid(x)  ((Oid) strtoul((x), NULL, 10))
  
+ extern void simple_action_list_append(SimpleActionList *list, int atyp, const char *val);
+ 
  extern bool setQFout(const char *fname);
  
  extern void psql_error(const char *fmt,...) pg_attribute_printf(1, 2);
diff --git a/src/bin/psql/startup.c b/src/bin/psql/startup.c
new file mode 100644
index 7aa997d..eda779b
*** a/src/bin/psql/startup.c
--- b/src/bin/psql/startup.c
*************** PsqlSettings pset;
*** 51,60 ****
  enum _actions
  {
  	ACT_NOTHING = 0,
- 	ACT_SINGLE_SLASH,
  	ACT_LIST_DB,
! 	ACT_SINGLE_QUERY,
! 	ACT_FILE
  };
  
  struct adhoc_opts
--- 51,58 ----
  enum _actions
  {
  	ACT_NOTHING = 0,
  	ACT_LIST_DB,
! 	ACT_FILE_STDIN
  };
  
  struct adhoc_opts
*************** struct adhoc_opts
*** 69,74 ****
--- 67,73 ----
  	bool		no_readline;
  	bool		no_psqlrc;
  	bool		single_txn;
+ 	SimpleActionList	actions;
  };
  
  static void parse_psql_options(int argc, char *argv[],
*************** main(int argc, char *argv[])
*** 159,164 ****
--- 158,166 ----
  	SetVariable(pset.vars, "PROMPT2", DEFAULT_PROMPT2);
  	SetVariable(pset.vars, "PROMPT3", DEFAULT_PROMPT3);
  
+ 	options.actions.head = NULL;
+ 	options.actions.tail = NULL;
+ 
  	parse_psql_options(argc, argv, &options);
  
  	/*
*************** main(int argc, char *argv[])
*** 166,179 ****
  	 * as if the user had specified "-f -".  This lets single-transaction mode
  	 * work in this case.
  	 */
! 	if (options.action == ACT_NOTHING && pset.notty)
  	{
! 		options.action = ACT_FILE;
  		options.action_string = NULL;
  	}
  
  	/* Bail out if -1 was specified but will be ignored. */
! 	if (options.single_txn && options.action != ACT_FILE && options.action == ACT_NOTHING)
  	{
  		fprintf(stderr, _("%s: -1 can only be used in non-interactive mode\n"), pset.progname);
  		exit(EXIT_FAILURE);
--- 168,182 ----
  	 * as if the user had specified "-f -".  This lets single-transaction mode
  	 * work in this case.
  	 */
! 	if (options.action == ACT_NOTHING && options.actions.head == NULL && pset.notty)
  	{
! 		options.action = ACT_FILE_STDIN;
  		options.action_string = NULL;
  	}
  
  	/* Bail out if -1 was specified but will be ignored. */
! 	if (options.single_txn && options.action != ACT_FILE_STDIN && options.action == ACT_NOTHING
! 			&& options.actions.head == NULL)
  	{
  		fprintf(stderr, _("%s: -1 can only be used in non-interactive mode\n"), pset.progname);
  		exit(EXIT_FAILURE);
*************** main(int argc, char *argv[])
*** 282,332 ****
  	/*
  	 * Now find something to do
  	 */
! 
! 	/*
! 	 * process file given by -f
! 	 */
! 	if (options.action == ACT_FILE)
  	{
  		if (!options.no_psqlrc)
  			process_psqlrc(argv[0]);
  
! 		successResult = process_file(options.action_string, options.single_txn, false);
! 	}
  
! 	/*
! 	 * process slash command if one was given to -c
! 	 */
! 	else if (options.action == ACT_SINGLE_SLASH)
! 	{
! 		PsqlScanState scan_state;
  
! 		if (pset.echo == PSQL_ECHO_ALL)
! 			puts(options.action_string);
  
! 		scan_state = psql_scan_create();
! 		psql_scan_setup(scan_state,
! 						options.action_string,
! 						strlen(options.action_string));
  
! 		successResult = HandleSlashCmds(scan_state, NULL) != PSQL_CMD_ERROR
! 			? EXIT_SUCCESS : EXIT_FAILURE;
  
! 		psql_scan_destroy(scan_state);
! 	}
  
! 	/*
! 	 * If the query given to -c was a normal one, send it
! 	 */
! 	else if (options.action == ACT_SINGLE_QUERY)
! 	{
! 		if (pset.echo == PSQL_ECHO_ALL)
! 			puts(options.action_string);
  
! 		successResult = SendQuery(options.action_string)
! 			? EXIT_SUCCESS : EXIT_FAILURE;
! 	}
  
  	/*
  	 * or otherwise enter interactive main loop
  	 */
--- 285,368 ----
  	/*
  	 * Now find something to do
  	 */
! 	if (options.actions.head)
  	{
+ 		PGresult		*res;
+ 		SimpleActionListCell	*cell;
+ 
  		if (!options.no_psqlrc)
  			process_psqlrc(argv[0]);
  
! 		successResult = EXIT_SUCCESS;		/* be compiler quiete */
  
! 		if (options.single_txn)
! 		{
! 			if ((res = PSQLexec("BEGIN")) == NULL)
! 			{
! 				if (pset.on_error_stop)
! 				{
! 					successResult = EXIT_USER;
! 					goto error;
! 				}
! 			}
! 			else
! 				PQclear(res);
! 		}
  
! 		for (cell = options.actions.head; cell; cell = cell->next)
! 		{
! 			if (cell->atyp == ACT_SINGLE_QUERY)
! 			{
! 				if (pset.echo == PSQL_ECHO_ALL)
! 					puts(cell->val);
  
! 				successResult = SendQuery(cell->val)
! 					? EXIT_SUCCESS : EXIT_FAILURE;
! 			}
! 			else if (cell->atyp == ACT_SINGLE_SLASH)
! 			{
! 				PsqlScanState scan_state;
  
! 				if (pset.echo == PSQL_ECHO_ALL)
! 					puts(cell->val);
  
! 				scan_state = psql_scan_create();
! 				psql_scan_setup(scan_state,
! 							cell->val,
! 							strlen(cell->val));
  
! 				successResult = HandleSlashCmds(scan_state, NULL) != PSQL_CMD_ERROR
! 					? EXIT_SUCCESS : EXIT_FAILURE;
  
! 				psql_scan_destroy(scan_state);
! 			}
! 			else
! 			{
! 				/* ACT_FILE */
! 				successResult = process_file(cell->val, false);
! 			}
! 
! 			if (successResult != EXIT_SUCCESS && pset.on_error_stop)
! 				break;
! 		}
! 
! 		if (options.single_txn)
! 		{
! 			if ((res = PSQLexec("COMMIT")) == NULL)
! 			{
! 				if (pset.on_error_stop)
! 				{
! 					successResult = EXIT_USER;
! 					goto error;
! 				}
! 			}
! 			else
! 				PQclear(res);
! 		}
  
+ error:
+ 		;
+ 	}
  	/*
  	 * or otherwise enter interactive main loop
  	 */
*************** parse_psql_options(int argc, char *argv[
*** 419,432 ****
  				SetVariable(pset.vars, "ECHO", "errors");
  				break;
  			case 'c':
- 				options->action_string = pg_strdup(optarg);
  				if (optarg[0] == '\\')
! 				{
! 					options->action = ACT_SINGLE_SLASH;
! 					options->action_string++;
! 				}
  				else
! 					options->action = ACT_SINGLE_QUERY;
  				break;
  			case 'd':
  				options->dbname = pg_strdup(optarg);
--- 455,468 ----
  				SetVariable(pset.vars, "ECHO", "errors");
  				break;
  			case 'c':
  				if (optarg[0] == '\\')
! 					simple_action_list_append(&options->actions,
! 								    ACT_SINGLE_SLASH,
! 								    pstrdup(optarg + 1));
  				else
! 					simple_action_list_append(&options->actions,
! 								    ACT_SINGLE_QUERY,
! 								    pstrdup(optarg));
  				break;
  			case 'd':
  				options->dbname = pg_strdup(optarg);
*************** parse_psql_options(int argc, char *argv[
*** 438,445 ****
  				SetVariableBool(pset.vars, "ECHO_HIDDEN");
  				break;
  			case 'f':
! 				options->action = ACT_FILE;
! 				options->action_string = pg_strdup(optarg);
  				break;
  			case 'F':
  				pset.popt.topt.fieldSep.separator = pg_strdup(optarg);
--- 474,482 ----
  				SetVariableBool(pset.vars, "ECHO_HIDDEN");
  				break;
  			case 'f':
! 				simple_action_list_append(&options->actions,
! 								ACT_FILE,
! 									    pg_strdup(optarg));
  				break;
  			case 'F':
  				pset.popt.topt.fieldSep.separator = pg_strdup(optarg);
*************** process_psqlrc_file(char *filename)
*** 674,684 ****
  
  	/* check for minor version first, then major, then no version */
  	if (access(psqlrc_minor, R_OK) == 0)
! 		(void) process_file(psqlrc_minor, false, false);
  	else if (access(psqlrc_major, R_OK) == 0)
! 		(void) process_file(psqlrc_major, false, false);
  	else if (access(filename, R_OK) == 0)
! 		(void) process_file(filename, false, false);
  
  	free(psqlrc_minor);
  	free(psqlrc_major);
--- 711,721 ----
  
  	/* check for minor version first, then major, then no version */
  	if (access(psqlrc_minor, R_OK) == 0)
! 		(void) process_file(psqlrc_minor, false);
  	else if (access(psqlrc_major, R_OK) == 0)
! 		(void) process_file(psqlrc_major, false);
  	else if (access(filename, R_OK) == 0)
! 		(void) process_file(filename, false);
  
  	free(psqlrc_minor);
  	free(psqlrc_major);

diff --git a/doc/src/sgml/ref/psql-ref.sgml b/doc/src/sgml/ref/psql-ref.sgml
new file mode 100644
index 5899bb4..2928c92
*** a/doc/src/sgml/ref/psql-ref.sgml
--- b/doc/src/sgml/ref/psql-ref.sgml
*************** PostgreSQL documentation
*** 38,46 ****
       <productname>PostgreSQL</productname>. It enables you to type in
       queries interactively, issue them to
       <productname>PostgreSQL</productname>, and see the query results.
!      Alternatively, input can be from a file. In addition, it provides a
!      number of meta-commands and various shell-like features to
!      facilitate writing scripts and automating a wide variety of tasks.
      </para>
   </refsect1>
  
--- 38,47 ----
       <productname>PostgreSQL</productname>. It enables you to type in
       queries interactively, issue them to
       <productname>PostgreSQL</productname>, and see the query results.
!      Alternatively, input can be from a file or from command line
!      arguments. In addition, it provides a number of meta-commands and various
!      shell-like features to facilitate writing scripts and automating a wide
!      variety of tasks.
      </para>
   </refsect1>
  
*************** PostgreSQL documentation
*** 89,126 ****
        <term><option>--command=<replaceable class="parameter">command</replaceable></></term>
        <listitem>
        <para>
!       Specifies that <application>psql</application> is to execute one
!       command string, <replaceable class="parameter">command</replaceable>,
!       and then exit. This is useful in shell scripts. Start-up files
!       (<filename>psqlrc</filename> and <filename>~/.psqlrc</filename>) are
!       ignored with this option.
        </para>
        <para>
!       <replaceable class="parameter">command</replaceable> must be either
!       a command string that is completely parsable by the server (i.e.,
!       it contains no <application>psql</application>-specific features),
!       or a single backslash command. Thus you cannot mix
!       <acronym>SQL</acronym> and <application>psql</application>
!       meta-commands with this option. To achieve that, you could
!       pipe the string into <application>psql</application>, for example:
!       <literal>echo '\x \\ SELECT * FROM foo;' | psql</literal>.
        (<literal>\\</> is the separator meta-command.)
        </para>
        <para>
!        If the command string contains multiple SQL commands, they are
!        processed in a single transaction, unless there are explicit
!        <command>BEGIN</>/<command>COMMIT</> commands included in the
!        string to divide it into multiple transactions.  This is
!        different from the behavior when the same string is fed to
!        <application>psql</application>'s standard input.  Also, only
!        the result of the last SQL command is returned.
        </para>
        <para>
!        Because of these legacy behaviors, putting more than one command in
!        the <option>-c</option> string often has unexpected results.  It's
!        better to feed multiple commands to <application>psql</application>'s
!        standard input, either using <application>echo</application> as
!        illustrated above, or via a shell here-document, for example:
  <programlisting>
  psql &lt;&lt;EOF
  \x
--- 90,134 ----
        <term><option>--command=<replaceable class="parameter">command</replaceable></></term>
        <listitem>
        <para>
!       Specifies that <application>psql</application> is to execute the given
!       command string, <replaceable class="parameter">command</replaceable>.
!       This option can be repeated and combined in any order with
!       the <option>-f</option> option.
        </para>
        <para>
!       <replaceable class="parameter">command</replaceable> must be either a
!       command string that is completely parsable by the server (i.e., it
!       contains no <application>psql</application>-specific features), or a
!       single backslash command. Thus you cannot mix
!       <acronym>SQL</acronym> and <application>psql</application> meta-commands
!       with this option. To achieve that, you could use
!       repeated <option>-c</option> options or pipe the string
!       into <application>psql</application>, for example:
!       <literal>psql -c '\x' -c 'SELECT * FROM foo;'</literal> or
!       <literal>echo '\x \\ SELECT * FROM foo;' | psql</literal>
        (<literal>\\</> is the separator meta-command.)
        </para>
        <para>
!        Each command string passed to <option>-c</option> is sent to the server
!        as a single query. Because of this, the server executes it as a single
!        transaction, even if a command string contains
!        multiple <acronym>SQL</acronym> commands, unless there are
!        explicit <command>BEGIN</>/<command>COMMIT</> commands included in the
!        string to divide it into multiple transactions.  Also, the server only
!        returns the result of the last <acronym>SQL</acronym> command to the
!        client.  This is different from the behavior when the same string with
!        multiple <acronym>SQL</acronym> commands is fed
!        to <application>psql</application>'s standard input because
!        then <application>psql</application> sends each <acronym>SQL</acronym>
!        command separately.
        </para>
        <para>
!        Because of the execution as a single query, putting more than one
!        command in the <option>-c</option> string often has unexpected results.
!        It's better to use repeated <option>-c</option> commands or feed
!        multiple commands to <application>psql</application>'s standard input,
!        either using <application>echo</application> as illustrated above, or
!        via a shell here-document, for example:
  <programlisting>
  psql &lt;&lt;EOF
  \x
*************** EOF
*** 183,193 ****
        <term><option>--file=<replaceable class="parameter">filename</replaceable></></term>
        <listitem>
        <para>
!       Use the file <replaceable class="parameter">filename</replaceable>
!       as the source of commands instead of reading commands interactively.
!       After the file is processed, <application>psql</application>
!       terminates. This is in many ways equivalent to the meta-command
!       <command>\i</command>.
        </para>
  
        <para>
--- 191,203 ----
        <term><option>--file=<replaceable class="parameter">filename</replaceable></></term>
        <listitem>
        <para>
!       Use the file <replaceable class="parameter">filename</replaceable> as
!       the source of commands instead of reading commands interactively.  This
!       option can be repeated and combined in any order with
!       the <option>-c</option> option.  After the commands in
!       every <option>-c</option> command string and <option>-f</option> file
!       are processed, <application>psql</application> terminates.  This option
!       is in many ways equivalent to the meta-command <command>\i</command>.
        </para>
  
        <para>
*************** EOF
*** 539,558 ****
        <term><option>--single-transaction</option></term>
        <listitem>
         <para>
!         When <application>psql</application> executes a script, adding
!         this option wraps <command>BEGIN</>/<command>COMMIT</> around the
!         script to execute it as a single transaction.  This ensures that
!         either all the commands complete successfully, or no changes are
!         applied.
         </para>
  
         <para>
!         If the script itself uses <command>BEGIN</>, <command>COMMIT</>,
          or <command>ROLLBACK</>, this option will not have the desired
!         effects.
!         Also, if the script contains any command that cannot be executed
!         inside a transaction block, specifying this option will cause that
!         command (and hence the whole transaction) to fail.
         </para>
        </listitem>
       </varlistentry>
--- 549,569 ----
        <term><option>--single-transaction</option></term>
        <listitem>
         <para>
!         When <application>psql</application> executes commands from a script
!         and/or a <option>-c</option> option, adding this option
!         wraps <command>BEGIN</>/<command>COMMIT</> around all of those
!         commands as a whole to execute them as a single transaction.  This
!         ensures that either all the commands complete successfully, or no
!         changes are applied.
         </para>
  
         <para>
!         If the commands themselves
!         contain <command>BEGIN</>, <command>COMMIT</>,
          or <command>ROLLBACK</>, this option will not have the desired
!         effects.  Also, if an individual command cannot be executed inside a
!         transaction block, specifying this option will cause the whole
!         transaction to fail.
         </para>
        </listitem>
       </varlistentry>
*************** PSQL_EDITOR_LINENUMBER_ARG='--line '
*** 3725,3731 ****
     <term><filename>psqlrc</filename> and <filename>~/.psqlrc</filename></term>
     <listitem>
      <para>
!      Unless it is passed an <option>-X</option> or <option>-c</option> option,
       <application>psql</application> attempts to read and execute commands
       from the system-wide startup file (<filename>psqlrc</filename>) and then
       the user's personal startup file (<filename>~/.psqlrc</filename>), after
--- 3736,3742 ----
     <term><filename>psqlrc</filename> and <filename>~/.psqlrc</filename></term>
     <listitem>
      <para>
!      Unless it is passed an <option>-X</option> option,
       <application>psql</application> attempts to read and execute commands
       from the system-wide startup file (<filename>psqlrc</filename>) and then
       the user's personal startup file (<filename>~/.psqlrc</filename>), after
*************** PSQL_EDITOR_LINENUMBER_ARG='--line '
*** 3819,3824 ****
--- 3830,3842 ----
        </para>
        </listitem>
  
+       <listitem>
+       <para>
+        Before <productname>PostgreSQL</productname> 9.6, <option>-c</option>
+        used to imply <option>-X</option> and therefore it wouldn't
+        read <filename>psqlrc</filename> files, that is no longer the case.
+       </para>
+       </listitem>
      </itemizedlist>
   </refsect1>
  
diff --git a/src/bin/psql/command.c b/src/bin/psql/command.c
new file mode 100644
index 438a4ec..d642803
*** a/src/bin/psql/command.c
--- b/src/bin/psql/command.c
*************** exec_command(const char *cmd,
*** 916,922 ****
  			include_relative = (strcmp(cmd, "ir") == 0
  								|| strcmp(cmd, "include_relative") == 0);
  			expand_tilde(&fname);
! 			success = (process_file(fname, false, include_relative) == EXIT_SUCCESS);
  			free(fname);
  		}
  	}
--- 916,922 ----
  			include_relative = (strcmp(cmd, "ir") == 0
  								|| strcmp(cmd, "include_relative") == 0);
  			expand_tilde(&fname);
! 			success = (process_file(fname, include_relative) == EXIT_SUCCESS);
  			free(fname);
  		}
  	}
*************** do_edit(const char *filename_arg, PQExpB
*** 2284,2296 ****
   * the file from where the currently processed file (if any) is located.
   */
  int
! process_file(char *filename, bool single_txn, bool use_relative_path)
  {
  	FILE	   *fd;
  	int			result;
  	char	   *oldfilename;
  	char		relpath[MAXPGPATH];
- 	PGresult   *res;
  
  	if (!filename)
  	{
--- 2284,2295 ----
   * the file from where the currently processed file (if any) is located.
   */
  int
! process_file(char *filename, bool use_relative_path)
  {
  	FILE	   *fd;
  	int			result;
  	char	   *oldfilename;
  	char		relpath[MAXPGPATH];
  
  	if (!filename)
  	{
*************** process_file(char *filename, bool single
*** 2335,2371 ****
  	oldfilename = pset.inputfile;
  	pset.inputfile = filename;
  
- 	if (single_txn)
- 	{
- 		if ((res = PSQLexec("BEGIN")) == NULL)
- 		{
- 			if (pset.on_error_stop)
- 			{
- 				result = EXIT_USER;
- 				goto error;
- 			}
- 		}
- 		else
- 			PQclear(res);
- 	}
- 
  	result = MainLoop(fd);
  
- 	if (single_txn)
- 	{
- 		if ((res = PSQLexec("COMMIT")) == NULL)
- 		{
- 			if (pset.on_error_stop)
- 			{
- 				result = EXIT_USER;
- 				goto error;
- 			}
- 		}
- 		else
- 			PQclear(res);
- 	}
- 
- error:
  	if (fd != stdin)
  		fclose(fd);
  
--- 2334,2341 ----
diff --git a/src/bin/psql/command.h b/src/bin/psql/command.h
new file mode 100644
index 54385e8..c817600
*** a/src/bin/psql/command.h
--- b/src/bin/psql/command.h
*************** typedef enum _backslashResult
*** 27,33 ****
  extern backslashResult HandleSlashCmds(PsqlScanState scan_state,
  				PQExpBuffer query_buf);
  
! extern int	process_file(char *filename, bool single_txn, bool use_relative_path);
  
  extern bool do_pset(const char *param,
  		const char *value,
--- 27,33 ----
  extern backslashResult HandleSlashCmds(PsqlScanState scan_state,
  				PQExpBuffer query_buf);
  
! extern int	process_file(char *filename, bool use_relative_path);
  
  extern bool do_pset(const char *param,
  		const char *value,
diff --git a/src/bin/psql/common.c b/src/bin/psql/common.c
new file mode 100644
index 0e266a3..96e5225
*** a/src/bin/psql/common.c
--- b/src/bin/psql/common.c
*************** recognized_connection_string(const char
*** 1886,1888 ****
--- 1886,1911 ----
  {
  	return uri_prefix_length(connstr) != 0 || strchr(connstr, '=') != NULL;
  }
+ 
+ /*
+  * Support for list of actions. The SimpleStringList cannot be used due possible
+  * combination different actions with the requirement to save the order.
+  */
+ void
+ simple_action_list_append(SimpleActionList *list, int action, const char *val)
+ {
+ 	SimpleActionListCell  *cell;
+ 
+ 	cell = (SimpleActionListCell *)
+ 		pg_malloc(offsetof(SimpleActionListCell, val) + strlen(val) + 1);
+ 
+ 	cell->next = NULL;
+ 	cell->action = action;
+ 	strcpy(cell->val, val);
+ 
+ 	if (list->tail)
+ 		list->tail->next = cell;
+ 	else
+ 		list->head = cell;
+ 	list->tail = cell;
+ }
diff --git a/src/bin/psql/common.h b/src/bin/psql/common.h
new file mode 100644
index caf31d1..6bdee98
*** a/src/bin/psql/common.h
--- b/src/bin/psql/common.h
***************
*** 14,21 ****
--- 14,44 ----
  
  #include "print.h"
  
+ enum _actions
+ {
+ 	ACT_LIST_DB,
+ 	ACT_SINGLE_QUERY,
+ 	ACT_SINGLE_SLASH,
+ 	ACT_FILE
+ };
+ 
+ typedef struct SimpleActionListCell
+ {
+ 	struct SimpleActionListCell *next;
+ 	int 		action;
+ 	char		val[FLEXIBLE_ARRAY_MEMBER];
+ } SimpleActionListCell;
+ 
+ typedef struct SimpleActionList
+ {
+ 	SimpleActionListCell *head;
+ 	SimpleActionListCell *tail;
+ } SimpleActionList;
+ 
  #define atooid(x)  ((Oid) strtoul((x), NULL, 10))
  
+ extern void simple_action_list_append(SimpleActionList *list, int action, const char *val);
+ 
  extern bool setQFout(const char *fname);
  
  extern void psql_error(const char *fmt,...) pg_attribute_printf(1, 2);
diff --git a/src/bin/psql/startup.c b/src/bin/psql/startup.c
new file mode 100644
index 7aa997d..3f909df
*** a/src/bin/psql/startup.c
--- b/src/bin/psql/startup.c
*************** PsqlSettings pset;
*** 44,62 ****
  #define PSQLRC		"psqlrc.conf"
  #endif
  
- /*
-  * Structures to pass information between the option parsing routine
-  * and the main function
-  */
- enum _actions
- {
- 	ACT_NOTHING = 0,
- 	ACT_SINGLE_SLASH,
- 	ACT_LIST_DB,
- 	ACT_SINGLE_QUERY,
- 	ACT_FILE
- };
- 
  struct adhoc_opts
  {
  	char	   *dbname;
--- 44,49 ----
*************** struct adhoc_opts
*** 64,76 ****
  	char	   *port;
  	char	   *username;
  	char	   *logfilename;
- 	enum _actions action;
  	char	   *action_string;
  	bool		no_readline;
  	bool		no_psqlrc;
  	bool		single_txn;
  };
  
  static void parse_psql_options(int argc, char *argv[],
  				   struct adhoc_opts * options);
  static void process_psqlrc(char *argv0);
--- 51,65 ----
  	char	   *port;
  	char	   *username;
  	char	   *logfilename;
  	char	   *action_string;
  	bool		no_readline;
  	bool		no_psqlrc;
  	bool		single_txn;
+ 	bool		use_stdin;
+ 	SimpleActionList	actions;
  };
  
+ static bool use_default_dbname(struct adhoc_opts *options);
  static void parse_psql_options(int argc, char *argv[],
  				   struct adhoc_opts * options);
  static void process_psqlrc(char *argv0);
*************** main(int argc, char *argv[])
*** 159,164 ****
--- 148,157 ----
  	SetVariable(pset.vars, "PROMPT2", DEFAULT_PROMPT2);
  	SetVariable(pset.vars, "PROMPT3", DEFAULT_PROMPT3);
  
+ 	options.actions.head = NULL;
+ 	options.actions.tail = NULL;
+ 	options.use_stdin = false;
+ 
  	parse_psql_options(argc, argv, &options);
  
  	/*
*************** main(int argc, char *argv[])
*** 166,179 ****
  	 * as if the user had specified "-f -".  This lets single-transaction mode
  	 * work in this case.
  	 */
! 	if (options.action == ACT_NOTHING && pset.notty)
! 	{
! 		options.action = ACT_FILE;
! 		options.action_string = NULL;
! 	}
  
  	/* Bail out if -1 was specified but will be ignored. */
! 	if (options.single_txn && options.action != ACT_FILE && options.action == ACT_NOTHING)
  	{
  		fprintf(stderr, _("%s: -1 can only be used in non-interactive mode\n"), pset.progname);
  		exit(EXIT_FAILURE);
--- 159,168 ----
  	 * as if the user had specified "-f -".  This lets single-transaction mode
  	 * work in this case.
  	 */
! 	options.use_stdin = options.actions.head == NULL && pset.notty;
  
  	/* Bail out if -1 was specified but will be ignored. */
! 	if (options.single_txn && !options.use_stdin && options.actions.head == NULL)
  	{
  		fprintf(stderr, _("%s: -1 can only be used in non-interactive mode\n"), pset.progname);
  		exit(EXIT_FAILURE);
*************** main(int argc, char *argv[])
*** 217,224 ****
  		keywords[3] = "password";
  		values[3] = password;
  		keywords[4] = "dbname";
! 		values[4] = (options.action == ACT_LIST_DB &&
! 					 options.dbname == NULL) ?
  			"postgres" : options.dbname;
  		keywords[5] = "fallback_application_name";
  		values[5] = pset.progname;
--- 206,212 ----
  		keywords[3] = "password";
  		values[3] = password;
  		keywords[4] = "dbname";
! 		values[4] = use_default_dbname(&options) ?
  			"postgres" : options.dbname;
  		keywords[5] = "fallback_application_name";
  		values[5] = pset.progname;
*************** main(int argc, char *argv[])
*** 259,276 ****
  
  	SyncVariables();
  
- 	if (options.action == ACT_LIST_DB)
- 	{
- 		int			success;
- 
- 		if (!options.no_psqlrc)
- 			process_psqlrc(argv[0]);
- 
- 		success = listAllDbs(NULL, false);
- 		PQfinish(pset.db);
- 		exit(success ? EXIT_SUCCESS : EXIT_FAILURE);
- 	}
- 
  	if (options.logfilename)
  	{
  		pset.logfile = fopen(options.logfilename, "a");
--- 247,252 ----
*************** main(int argc, char *argv[])
*** 279,332 ****
  					pset.progname, options.logfilename, strerror(errno));
  	}
  
! 	/*
! 	 * Now find something to do
! 	 */
  
  	/*
! 	 * process file given by -f
  	 */
! 	if (options.action == ACT_FILE)
  	{
! 		if (!options.no_psqlrc)
! 			process_psqlrc(argv[0]);
  
! 		successResult = process_file(options.action_string, options.single_txn, false);
! 	}
  
! 	/*
! 	 * process slash command if one was given to -c
! 	 */
! 	else if (options.action == ACT_SINGLE_SLASH)
! 	{
! 		PsqlScanState scan_state;
  
! 		if (pset.echo == PSQL_ECHO_ALL)
! 			puts(options.action_string);
  
! 		scan_state = psql_scan_create();
! 		psql_scan_setup(scan_state,
! 						options.action_string,
! 						strlen(options.action_string));
  
! 		successResult = HandleSlashCmds(scan_state, NULL) != PSQL_CMD_ERROR
! 			? EXIT_SUCCESS : EXIT_FAILURE;
  
! 		psql_scan_destroy(scan_state);
! 	}
  
! 	/*
! 	 * If the query given to -c was a normal one, send it
! 	 */
! 	else if (options.action == ACT_SINGLE_QUERY)
! 	{
! 		if (pset.echo == PSQL_ECHO_ALL)
! 			puts(options.action_string);
  
! 		successResult = SendQuery(options.action_string)
! 			? EXIT_SUCCESS : EXIT_FAILURE;
! 	}
  
  	/*
  	 * or otherwise enter interactive main loop
  	 */
--- 255,348 ----
  					pset.progname, options.logfilename, strerror(errno));
  	}
  
! 	if (!options.no_psqlrc)
! 		process_psqlrc(argv[0]);
  
  	/*
! 	 * Now find something to do
  	 */
! 	if (options.actions.head)
  	{
! 		PGresult		*res;
! 		SimpleActionListCell	*cell;
  
! 		successResult = EXIT_SUCCESS;		/* be compiler quiete */
  
! 		if (options.single_txn)
! 		{
! 			if ((res = PSQLexec("BEGIN")) == NULL)
! 			{
! 				if (pset.on_error_stop)
! 				{
! 					successResult = EXIT_USER;
! 					goto error;
! 				}
! 			}
! 			else
! 				PQclear(res);
! 		}
  
! 		for (cell = options.actions.head; cell; cell = cell->next)
! 		{
! 			if (cell->action == ACT_LIST_DB)
! 			{
! 				successResult = listAllDbs(NULL, false);
! 			}
! 			else if (cell->action == ACT_SINGLE_QUERY)
! 			{
! 				if (pset.echo == PSQL_ECHO_ALL)
! 					puts(cell->val);
  
! 				successResult = SendQuery(cell->val)
! 					? EXIT_SUCCESS : EXIT_FAILURE;
! 			}
! 			else if (cell->action == ACT_SINGLE_SLASH)
! 			{
! 				PsqlScanState scan_state;
  
! 				if (pset.echo == PSQL_ECHO_ALL)
! 					puts(cell->val);
  
! 				scan_state = psql_scan_create();
! 				psql_scan_setup(scan_state,
! 							cell->val,
! 							strlen(cell->val));
  
! 				successResult = HandleSlashCmds(scan_state, NULL) != PSQL_CMD_ERROR
! 					? EXIT_SUCCESS : EXIT_FAILURE;
  
! 				psql_scan_destroy(scan_state);
! 			}
! 			else
! 			{
! 				/* ACT_FILE */
! 				successResult = process_file(cell->val, false);
! 			}
! 
! 			if (successResult != EXIT_SUCCESS && pset.on_error_stop)
! 				break;
! 		}
! 
! 		if (options.use_stdin)
! 			successResult = process_file(NULL, false);
! 
! 		if (options.single_txn)
! 		{
! 			if ((res = PSQLexec("COMMIT")) == NULL)
! 			{
! 				if (pset.on_error_stop)
! 				{
! 					successResult = EXIT_USER;
! 					goto error;
! 				}
! 			}
! 			else
! 				PQclear(res);
! 		}
  
+ error:
+ 		;
+ 	}
  	/*
  	 * or otherwise enter interactive main loop
  	 */
*************** main(int argc, char *argv[])
*** 351,356 ****
--- 367,392 ----
  	return successResult;
  }
  
+ /*
+  * Default dbname "postgres" can be used when no other dbname
+  * is entered and when only action ACT_LIST_DB is used
+  */
+ static bool
+ use_default_dbname(struct adhoc_opts *options)
+ {
+ 	SimpleActionListCell	*cell;
+ 
+ 	if (options->dbname != NULL)
+ 		return false;
+ 
+ 	for (cell = options->actions.head; cell; cell = cell->next)
+ 	{
+ 		if (cell->action != ACT_LIST_DB)
+ 			return false;
+ 	}
+ 
+ 	return true;
+ }
  
  /*
   * Parse command line options
*************** parse_psql_options(int argc, char *argv[
*** 419,432 ****
  				SetVariable(pset.vars, "ECHO", "errors");
  				break;
  			case 'c':
- 				options->action_string = pg_strdup(optarg);
  				if (optarg[0] == '\\')
! 				{
! 					options->action = ACT_SINGLE_SLASH;
! 					options->action_string++;
! 				}
  				else
! 					options->action = ACT_SINGLE_QUERY;
  				break;
  			case 'd':
  				options->dbname = pg_strdup(optarg);
--- 455,468 ----
  				SetVariable(pset.vars, "ECHO", "errors");
  				break;
  			case 'c':
  				if (optarg[0] == '\\')
! 					simple_action_list_append(&options->actions,
! 								    ACT_SINGLE_SLASH,
! 								    pstrdup(optarg + 1));
  				else
! 					simple_action_list_append(&options->actions,
! 								    ACT_SINGLE_QUERY,
! 								    pstrdup(optarg));
  				break;
  			case 'd':
  				options->dbname = pg_strdup(optarg);
*************** parse_psql_options(int argc, char *argv[
*** 438,445 ****
  				SetVariableBool(pset.vars, "ECHO_HIDDEN");
  				break;
  			case 'f':
! 				options->action = ACT_FILE;
! 				options->action_string = pg_strdup(optarg);
  				break;
  			case 'F':
  				pset.popt.topt.fieldSep.separator = pg_strdup(optarg);
--- 474,482 ----
  				SetVariableBool(pset.vars, "ECHO_HIDDEN");
  				break;
  			case 'f':
! 				simple_action_list_append(&options->actions,
! 								ACT_FILE,
! 									    pg_strdup(optarg));
  				break;
  			case 'F':
  				pset.popt.topt.fieldSep.separator = pg_strdup(optarg);
*************** parse_psql_options(int argc, char *argv[
*** 452,458 ****
  				pset.popt.topt.format = PRINT_HTML;
  				break;
  			case 'l':
! 				options->action = ACT_LIST_DB;
  				break;
  			case 'L':
  				options->logfilename = pg_strdup(optarg);
--- 489,497 ----
  				pset.popt.topt.format = PRINT_HTML;
  				break;
  			case 'l':
! 				simple_action_list_append(&options->actions,
! 								ACT_LIST_DB,
! 									    pg_strdup(""));
  				break;
  			case 'L':
  				options->logfilename = pg_strdup(optarg);
*************** process_psqlrc_file(char *filename)
*** 674,684 ****
  
  	/* check for minor version first, then major, then no version */
  	if (access(psqlrc_minor, R_OK) == 0)
! 		(void) process_file(psqlrc_minor, false, false);
  	else if (access(psqlrc_major, R_OK) == 0)
! 		(void) process_file(psqlrc_major, false, false);
  	else if (access(filename, R_OK) == 0)
! 		(void) process_file(filename, false, false);
  
  	free(psqlrc_minor);
  	free(psqlrc_major);
--- 713,723 ----
  
  	/* check for minor version first, then major, then no version */
  	if (access(psqlrc_minor, R_OK) == 0)
! 		(void) process_file(psqlrc_minor, false);
  	else if (access(psqlrc_major, R_OK) == 0)
! 		(void) process_file(psqlrc_major, false);
  	else if (access(filename, R_OK) == 0)
! 		(void) process_file(filename, false);
  
  	free(psqlrc_minor);
  	free(psqlrc_major);

diff --git a/doc/src/sgml/ref/psql-ref.sgml b/doc/src/sgml/ref/psql-ref.sgml
index 5899bb4..2928c92 100644
--- a/doc/src/sgml/ref/psql-ref.sgml
+++ b/doc/src/sgml/ref/psql-ref.sgml
@@ -38,9 +38,10 @@ PostgreSQL documentation
      <productname>PostgreSQL</productname>. It enables you to type in
      queries interactively, issue them to
      <productname>PostgreSQL</productname>, and see the query results.
-     Alternatively, input can be from a file. In addition, it provides a
-     number of meta-commands and various shell-like features to
-     facilitate writing scripts and automating a wide variety of tasks.
+     Alternatively, input can be from a file or from command line
+     arguments. In addition, it provides a number of meta-commands and various
+     shell-like features to facilitate writing scripts and automating a wide
+     variety of tasks.
     </para>
  </refsect1>
 
@@ -89,38 +90,45 @@ PostgreSQL documentation
       <term><option>--command=<replaceable class="parameter">command</replaceable></></term>
       <listitem>
       <para>
-      Specifies that <application>psql</application> is to execute one
-      command string, <replaceable class="parameter">command</replaceable>,
-      and then exit. This is useful in shell scripts. Start-up files
-      (<filename>psqlrc</filename> and <filename>~/.psqlrc</filename>) are
-      ignored with this option.
+      Specifies that <application>psql</application> is to execute the given
+      command string, <replaceable class="parameter">command</replaceable>.
+      This option can be repeated and combined in any order with
+      the <option>-f</option> option.
       </para>
       <para>
-      <replaceable class="parameter">command</replaceable> must be either
-      a command string that is completely parsable by the server (i.e.,
-      it contains no <application>psql</application>-specific features),
-      or a single backslash command. Thus you cannot mix
-      <acronym>SQL</acronym> and <application>psql</application>
-      meta-commands with this option. To achieve that, you could
-      pipe the string into <application>psql</application>, for example:
-      <literal>echo '\x \\ SELECT * FROM foo;' | psql</literal>.
+      <replaceable class="parameter">command</replaceable> must be either a
+      command string that is completely parsable by the server (i.e., it
+      contains no <application>psql</application>-specific features), or a
+      single backslash command. Thus you cannot mix
+      <acronym>SQL</acronym> and <application>psql</application> meta-commands
+      with this option. To achieve that, you could use
+      repeated <option>-c</option> options or pipe the string
+      into <application>psql</application>, for example:
+      <literal>psql -c '\x' -c 'SELECT * FROM foo;'</literal> or
+      <literal>echo '\x \\ SELECT * FROM foo;' | psql</literal>
       (<literal>\\</> is the separator meta-command.)
       </para>
       <para>
-       If the command string contains multiple SQL commands, they are
-       processed in a single transaction, unless there are explicit
-       <command>BEGIN</>/<command>COMMIT</> commands included in the
-       string to divide it into multiple transactions.  This is
-       different from the behavior when the same string is fed to
-       <application>psql</application>'s standard input.  Also, only
-       the result of the last SQL command is returned.
+       Each command string passed to <option>-c</option> is sent to the server
+       as a single query. Because of this, the server executes it as a single
+       transaction, even if a command string contains
+       multiple <acronym>SQL</acronym> commands, unless there are
+       explicit <command>BEGIN</>/<command>COMMIT</> commands included in the
+       string to divide it into multiple transactions.  Also, the server only
+       returns the result of the last <acronym>SQL</acronym> command to the
+       client.  This is different from the behavior when the same string with
+       multiple <acronym>SQL</acronym> commands is fed
+       to <application>psql</application>'s standard input because
+       then <application>psql</application> sends each <acronym>SQL</acronym>
+       command separately.
       </para>
       <para>
-       Because of these legacy behaviors, putting more than one command in
-       the <option>-c</option> string often has unexpected results.  It's
-       better to feed multiple commands to <application>psql</application>'s
-       standard input, either using <application>echo</application> as
-       illustrated above, or via a shell here-document, for example:
+       Because of the execution as a single query, putting more than one
+       command in the <option>-c</option> string often has unexpected results.
+       It's better to use repeated <option>-c</option> commands or feed
+       multiple commands to <application>psql</application>'s standard input,
+       either using <application>echo</application> as illustrated above, or
+       via a shell here-document, for example:
 <programlisting>
 psql &lt;&lt;EOF
 \x
@@ -183,11 +191,13 @@ EOF
       <term><option>--file=<replaceable class="parameter">filename</replaceable></></term>
       <listitem>
       <para>
-      Use the file <replaceable class="parameter">filename</replaceable>
-      as the source of commands instead of reading commands interactively.
-      After the file is processed, <application>psql</application>
-      terminates. This is in many ways equivalent to the meta-command
-      <command>\i</command>.
+      Use the file <replaceable class="parameter">filename</replaceable> as
+      the source of commands instead of reading commands interactively.  This
+      option can be repeated and combined in any order with
+      the <option>-c</option> option.  After the commands in
+      every <option>-c</option> command string and <option>-f</option> file
+      are processed, <application>psql</application> terminates.  This option
+      is in many ways equivalent to the meta-command <command>\i</command>.
       </para>
 
       <para>
@@ -539,20 +549,21 @@ EOF
       <term><option>--single-transaction</option></term>
       <listitem>
        <para>
-        When <application>psql</application> executes a script, adding
-        this option wraps <command>BEGIN</>/<command>COMMIT</> around the
-        script to execute it as a single transaction.  This ensures that
-        either all the commands complete successfully, or no changes are
-        applied.
+        When <application>psql</application> executes commands from a script
+        and/or a <option>-c</option> option, adding this option
+        wraps <command>BEGIN</>/<command>COMMIT</> around all of those
+        commands as a whole to execute them as a single transaction.  This
+        ensures that either all the commands complete successfully, or no
+        changes are applied.
        </para>
 
        <para>
-        If the script itself uses <command>BEGIN</>, <command>COMMIT</>,
+        If the commands themselves
+        contain <command>BEGIN</>, <command>COMMIT</>,
         or <command>ROLLBACK</>, this option will not have the desired
-        effects.
-        Also, if the script contains any command that cannot be executed
-        inside a transaction block, specifying this option will cause that
-        command (and hence the whole transaction) to fail.
+        effects.  Also, if an individual command cannot be executed inside a
+        transaction block, specifying this option will cause the whole
+        transaction to fail.
        </para>
       </listitem>
      </varlistentry>
@@ -3725,7 +3736,7 @@ PSQL_EDITOR_LINENUMBER_ARG='--line '
    <term><filename>psqlrc</filename> and <filename>~/.psqlrc</filename></term>
    <listitem>
     <para>
-     Unless it is passed an <option>-X</option> or <option>-c</option> option,
+     Unless it is passed an <option>-X</option> option,
      <application>psql</application> attempts to read and execute commands
      from the system-wide startup file (<filename>psqlrc</filename>) and then
      the user's personal startup file (<filename>~/.psqlrc</filename>), after
@@ -3819,6 +3830,13 @@ PSQL_EDITOR_LINENUMBER_ARG='--line '
       </para>
       </listitem>
 
+      <listitem>
+      <para>
+       Before <productname>PostgreSQL</productname> 9.6, <option>-c</option>
+       used to imply <option>-X</option> and therefore it wouldn't
+       read <filename>psqlrc</filename> files, that is no longer the case.
+      </para>
+      </listitem>
     </itemizedlist>
  </refsect1>
 
diff --git a/src/bin/psql/command.c b/src/bin/psql/command.c
index 438a4ec..d642803 100644
--- a/src/bin/psql/command.c
+++ b/src/bin/psql/command.c
@@ -916,7 +916,7 @@ exec_command(const char *cmd,
 			include_relative = (strcmp(cmd, "ir") == 0
 								|| strcmp(cmd, "include_relative") == 0);
 			expand_tilde(&fname);
-			success = (process_file(fname, false, include_relative) == EXIT_SUCCESS);
+			success = (process_file(fname, include_relative) == EXIT_SUCCESS);
 			free(fname);
 		}
 	}
@@ -2284,13 +2284,12 @@ do_edit(const char *filename_arg, PQExpBuffer query_buf,
  * the file from where the currently processed file (if any) is located.
  */
 int
-process_file(char *filename, bool single_txn, bool use_relative_path)
+process_file(char *filename, bool use_relative_path)
 {
 	FILE	   *fd;
 	int			result;
 	char	   *oldfilename;
 	char		relpath[MAXPGPATH];
-	PGresult   *res;
 
 	if (!filename)
 	{
@@ -2335,37 +2334,8 @@ process_file(char *filename, bool single_txn, bool use_relative_path)
 	oldfilename = pset.inputfile;
 	pset.inputfile = filename;
 
-	if (single_txn)
-	{
-		if ((res = PSQLexec("BEGIN")) == NULL)
-		{
-			if (pset.on_error_stop)
-			{
-				result = EXIT_USER;
-				goto error;
-			}
-		}
-		else
-			PQclear(res);
-	}
-
 	result = MainLoop(fd);
 
-	if (single_txn)
-	{
-		if ((res = PSQLexec("COMMIT")) == NULL)
-		{
-			if (pset.on_error_stop)
-			{
-				result = EXIT_USER;
-				goto error;
-			}
-		}
-		else
-			PQclear(res);
-	}
-
-error:
 	if (fd != stdin)
 		fclose(fd);
 
diff --git a/src/bin/psql/command.h b/src/bin/psql/command.h
index 54385e8..c817600 100644
--- a/src/bin/psql/command.h
+++ b/src/bin/psql/command.h
@@ -27,7 +27,7 @@ typedef enum _backslashResult
 extern backslashResult HandleSlashCmds(PsqlScanState scan_state,
 				PQExpBuffer query_buf);
 
-extern int	process_file(char *filename, bool single_txn, bool use_relative_path);
+extern int	process_file(char *filename, bool use_relative_path);
 
 extern bool do_pset(const char *param,
 		const char *value,
diff --git a/src/bin/psql/startup.c b/src/bin/psql/startup.c
index 7aa997d..5869eef 100644
--- a/src/bin/psql/startup.c
+++ b/src/bin/psql/startup.c
@@ -50,13 +50,24 @@ PsqlSettings pset;
  */
 enum _actions
 {
-	ACT_NOTHING = 0,
-	ACT_SINGLE_SLASH,
-	ACT_LIST_DB,
 	ACT_SINGLE_QUERY,
+	ACT_SINGLE_SLASH,
 	ACT_FILE
 };
 
+typedef struct SimpleActionListCell
+{
+	struct SimpleActionListCell *next;
+	int         action;
+	char        val[FLEXIBLE_ARRAY_MEMBER];
+} SimpleActionListCell;
+
+typedef struct SimpleActionList
+{
+	SimpleActionListCell *head;
+	SimpleActionListCell *tail;
+} SimpleActionList;
+
 struct adhoc_opts
 {
 	char	   *dbname;
@@ -64,11 +75,11 @@ struct adhoc_opts
 	char	   *port;
 	char	   *username;
 	char	   *logfilename;
-	enum _actions action;
-	char	   *action_string;
 	bool		no_readline;
 	bool		no_psqlrc;
 	bool		single_txn;
+	bool		list_dbs;
+	SimpleActionList actions;
 };
 
 static void parse_psql_options(int argc, char *argv[],
@@ -76,6 +87,8 @@ static void parse_psql_options(int argc, char *argv[],
 static void process_psqlrc(char *argv0);
 static void process_psqlrc_file(char *filename);
 static void showVersion(void);
+static void simple_action_list_append(SimpleActionList *list,
+									  int action, const char *val);
 static void EstablishVariableSpace(void);
 
 #define NOPAGER		0
@@ -159,6 +172,9 @@ main(int argc, char *argv[])
 	SetVariable(pset.vars, "PROMPT2", DEFAULT_PROMPT2);
 	SetVariable(pset.vars, "PROMPT3", DEFAULT_PROMPT3);
 
+	options.actions.head = NULL;
+	options.actions.tail = NULL;
+
 	parse_psql_options(argc, argv, &options);
 
 	/*
@@ -166,14 +182,11 @@ main(int argc, char *argv[])
 	 * as if the user had specified "-f -".  This lets single-transaction mode
 	 * work in this case.
 	 */
-	if (options.action == ACT_NOTHING && pset.notty)
-	{
-		options.action = ACT_FILE;
-		options.action_string = NULL;
-	}
+	 if (options.actions.head == NULL && pset.notty)
+		 simple_action_list_append(&options.actions, ACT_FILE, "-");
 
 	/* Bail out if -1 was specified but will be ignored. */
-	if (options.single_txn && options.action != ACT_FILE && options.action == ACT_NOTHING)
+	if (options.single_txn && options.actions.head == NULL)
 	{
 		fprintf(stderr, _("%s: -1 can only be used in non-interactive mode\n"), pset.progname);
 		exit(EXIT_FAILURE);
@@ -217,8 +230,7 @@ main(int argc, char *argv[])
 		keywords[3] = "password";
 		values[3] = password;
 		keywords[4] = "dbname";
-		values[4] = (options.action == ACT_LIST_DB &&
-					 options.dbname == NULL) ?
+		values[4] = (options.list_dbs && options.dbname == NULL) ?
 			"postgres" : options.dbname;
 		keywords[5] = "fallback_application_name";
 		values[5] = pset.progname;
@@ -259,7 +271,7 @@ main(int argc, char *argv[])
 
 	SyncVariables();
 
-	if (options.action == ACT_LIST_DB)
+	if (options.list_dbs)
 	{
 		int			success;
 
@@ -280,51 +292,90 @@ main(int argc, char *argv[])
 	}
 
 	/*
-	 * Now find something to do
-	 */
-
-	/*
-	 * process file given by -f
+	 * Now find something to do, process any actions given by caller,
+	 * respecting their order of reception.
 	 */
-	if (options.action == ACT_FILE)
+	if (options.actions.head != NULL)
 	{
-		if (!options.no_psqlrc)
-			process_psqlrc(argv[0]);
-
-		successResult = process_file(options.action_string, options.single_txn, false);
-	}
-
-	/*
-	 * process slash command if one was given to -c
-	 */
-	else if (options.action == ACT_SINGLE_SLASH)
-	{
-		PsqlScanState scan_state;
+		PGresult		*res;
+		SimpleActionListCell	*cell;
 
-		if (pset.echo == PSQL_ECHO_ALL)
-			puts(options.action_string);
+		successResult = EXIT_SUCCESS;		/* be compiler quiete */
 
-		scan_state = psql_scan_create();
-		psql_scan_setup(scan_state,
-						options.action_string,
-						strlen(options.action_string));
+		if (!options.no_psqlrc)
+			process_psqlrc(argv[0]);
 
-		successResult = HandleSlashCmds(scan_state, NULL) != PSQL_CMD_ERROR
-			? EXIT_SUCCESS : EXIT_FAILURE;
+		if (options.single_txn)
+		{
+			if ((res = PSQLexec("BEGIN")) == NULL)
+			{
+				if (pset.on_error_stop)
+				{
+					successResult = EXIT_USER;
+					goto error;
+				}
+			}
+			else
+				PQclear(res);
+		}
 
-		psql_scan_destroy(scan_state);
-	}
+		for (cell = options.actions.head; cell; cell = cell->next)
+		{
+			if (cell->action == ACT_SINGLE_QUERY)
+			{
+				if (pset.echo == PSQL_ECHO_ALL)
+					puts(cell->val);
+
+				successResult = SendQuery(cell->val)
+					? EXIT_SUCCESS : EXIT_FAILURE;
+			}
+			else if (cell->action == ACT_SINGLE_SLASH)
+			{
+				PsqlScanState scan_state;
+
+				if (pset.echo == PSQL_ECHO_ALL)
+					puts(cell->val);
+
+				scan_state = psql_scan_create();
+				psql_scan_setup(scan_state,
+							cell->val,
+							strlen(cell->val));
+
+				successResult = HandleSlashCmds(scan_state, NULL) != PSQL_CMD_ERROR
+					? EXIT_SUCCESS : EXIT_FAILURE;
+
+				psql_scan_destroy(scan_state);
+			}
+			else if (cell->action == ACT_FILE)
+			{
+				successResult = process_file(cell->val, false);
+			}
+			else
+			{
+				/* should never come here */
+				Assert(0);
+			}
+
+			if (successResult != EXIT_SUCCESS && pset.on_error_stop)
+				break;
+		}
 
-	/*
-	 * If the query given to -c was a normal one, send it
-	 */
-	else if (options.action == ACT_SINGLE_QUERY)
-	{
-		if (pset.echo == PSQL_ECHO_ALL)
-			puts(options.action_string);
+		if (options.single_txn)
+		{
+			if ((res = PSQLexec("COMMIT")) == NULL)
+			{
+				if (pset.on_error_stop)
+				{
+					successResult = EXIT_USER;
+					goto error;
+				}
+			}
+			else
+				PQclear(res);
+		}
 
-		successResult = SendQuery(options.action_string)
-			? EXIT_SUCCESS : EXIT_FAILURE;
+error:
+		;
 	}
 
 	/*
@@ -419,14 +470,14 @@ parse_psql_options(int argc, char *argv[], struct adhoc_opts * options)
 				SetVariable(pset.vars, "ECHO", "errors");
 				break;
 			case 'c':
-				options->action_string = pg_strdup(optarg);
 				if (optarg[0] == '\\')
-				{
-					options->action = ACT_SINGLE_SLASH;
-					options->action_string++;
-				}
+					simple_action_list_append(&options->actions,
+											  ACT_SINGLE_SLASH,
+											  pstrdup(optarg + 1));
 				else
-					options->action = ACT_SINGLE_QUERY;
+					simple_action_list_append(&options->actions,
+											  ACT_SINGLE_QUERY,
+											  pstrdup(optarg));
 				break;
 			case 'd':
 				options->dbname = pg_strdup(optarg);
@@ -438,8 +489,9 @@ parse_psql_options(int argc, char *argv[], struct adhoc_opts * options)
 				SetVariableBool(pset.vars, "ECHO_HIDDEN");
 				break;
 			case 'f':
-				options->action = ACT_FILE;
-				options->action_string = pg_strdup(optarg);
+				simple_action_list_append(&options->actions,
+									ACT_FILE,
+									pg_strdup(optarg));
 				break;
 			case 'F':
 				pset.popt.topt.fieldSep.separator = pg_strdup(optarg);
@@ -452,7 +504,7 @@ parse_psql_options(int argc, char *argv[], struct adhoc_opts * options)
 				pset.popt.topt.format = PRINT_HTML;
 				break;
 			case 'l':
-				options->action = ACT_LIST_DB;
+				options->list_dbs = true;
 				break;
 			case 'L':
 				options->logfilename = pg_strdup(optarg);
@@ -674,11 +726,11 @@ process_psqlrc_file(char *filename)
 
 	/* check for minor version first, then major, then no version */
 	if (access(psqlrc_minor, R_OK) == 0)
-		(void) process_file(psqlrc_minor, false, false);
+		(void) process_file(psqlrc_minor, false);
 	else if (access(psqlrc_major, R_OK) == 0)
-		(void) process_file(psqlrc_major, false, false);
+		(void) process_file(psqlrc_major, false);
 	else if (access(filename, R_OK) == 0)
-		(void) process_file(filename, false, false);
+		(void) process_file(filename, false);
 
 	free(psqlrc_minor);
 	free(psqlrc_major);
@@ -892,6 +944,29 @@ show_context_hook(const char *newval)
 }
 
 
+/*
+ * Support for list of actions. SimpleStringList cannot be used due possible
+ * combination different actions with the requirement to save the order.
+ */
+static void
+simple_action_list_append(SimpleActionList *list, int action, const char *val)
+{
+	SimpleActionListCell   *cell;
+
+	cell = (SimpleActionListCell *)
+		pg_malloc(offsetof(SimpleActionListCell, val) + strlen(val) + 1);
+
+	cell->next = NULL;
+	cell->action = action;
+	strcpy(cell->val, val);
+
+	if (list->tail)
+		list->tail->next = cell;
+	else
+		list->head = cell;
+	list->tail = cell;
+}
+
 static void
 EstablishVariableSpace(void)
 {

diff --git a/doc/src/sgml/ref/psql-ref.sgml b/doc/src/sgml/ref/psql-ref.sgml
index 5899bb4..2928c92 100644
--- a/doc/src/sgml/ref/psql-ref.sgml
+++ b/doc/src/sgml/ref/psql-ref.sgml
@@ -38,9 +38,10 @@ PostgreSQL documentation
      <productname>PostgreSQL</productname>. It enables you to type in
      queries interactively, issue them to
      <productname>PostgreSQL</productname>, and see the query results.
-     Alternatively, input can be from a file. In addition, it provides a
-     number of meta-commands and various shell-like features to
-     facilitate writing scripts and automating a wide variety of tasks.
+     Alternatively, input can be from a file or from command line
+     arguments. In addition, it provides a number of meta-commands and various
+     shell-like features to facilitate writing scripts and automating a wide
+     variety of tasks.
     </para>
  </refsect1>
 
@@ -89,38 +90,45 @@ PostgreSQL documentation
       <term><option>--command=<replaceable class="parameter">command</replaceable></></term>
       <listitem>
       <para>
-      Specifies that <application>psql</application> is to execute one
-      command string, <replaceable class="parameter">command</replaceable>,
-      and then exit. This is useful in shell scripts. Start-up files
-      (<filename>psqlrc</filename> and <filename>~/.psqlrc</filename>) are
-      ignored with this option.
+      Specifies that <application>psql</application> is to execute the given
+      command string, <replaceable class="parameter">command</replaceable>.
+      This option can be repeated and combined in any order with
+      the <option>-f</option> option.
       </para>
       <para>
-      <replaceable class="parameter">command</replaceable> must be either
-      a command string that is completely parsable by the server (i.e.,
-      it contains no <application>psql</application>-specific features),
-      or a single backslash command. Thus you cannot mix
-      <acronym>SQL</acronym> and <application>psql</application>
-      meta-commands with this option. To achieve that, you could
-      pipe the string into <application>psql</application>, for example:
-      <literal>echo '\x \\ SELECT * FROM foo;' | psql</literal>.
+      <replaceable class="parameter">command</replaceable> must be either a
+      command string that is completely parsable by the server (i.e., it
+      contains no <application>psql</application>-specific features), or a
+      single backslash command. Thus you cannot mix
+      <acronym>SQL</acronym> and <application>psql</application> meta-commands
+      with this option. To achieve that, you could use
+      repeated <option>-c</option> options or pipe the string
+      into <application>psql</application>, for example:
+      <literal>psql -c '\x' -c 'SELECT * FROM foo;'</literal> or
+      <literal>echo '\x \\ SELECT * FROM foo;' | psql</literal>
       (<literal>\\</> is the separator meta-command.)
       </para>
       <para>
-       If the command string contains multiple SQL commands, they are
-       processed in a single transaction, unless there are explicit
-       <command>BEGIN</>/<command>COMMIT</> commands included in the
-       string to divide it into multiple transactions.  This is
-       different from the behavior when the same string is fed to
-       <application>psql</application>'s standard input.  Also, only
-       the result of the last SQL command is returned.
+       Each command string passed to <option>-c</option> is sent to the server
+       as a single query. Because of this, the server executes it as a single
+       transaction, even if a command string contains
+       multiple <acronym>SQL</acronym> commands, unless there are
+       explicit <command>BEGIN</>/<command>COMMIT</> commands included in the
+       string to divide it into multiple transactions.  Also, the server only
+       returns the result of the last <acronym>SQL</acronym> command to the
+       client.  This is different from the behavior when the same string with
+       multiple <acronym>SQL</acronym> commands is fed
+       to <application>psql</application>'s standard input because
+       then <application>psql</application> sends each <acronym>SQL</acronym>
+       command separately.
       </para>
       <para>
-       Because of these legacy behaviors, putting more than one command in
-       the <option>-c</option> string often has unexpected results.  It's
-       better to feed multiple commands to <application>psql</application>'s
-       standard input, either using <application>echo</application> as
-       illustrated above, or via a shell here-document, for example:
+       Because of the execution as a single query, putting more than one
+       command in the <option>-c</option> string often has unexpected results.
+       It's better to use repeated <option>-c</option> commands or feed
+       multiple commands to <application>psql</application>'s standard input,
+       either using <application>echo</application> as illustrated above, or
+       via a shell here-document, for example:
 <programlisting>
 psql &lt;&lt;EOF
 \x
@@ -183,11 +191,13 @@ EOF
       <term><option>--file=<replaceable class="parameter">filename</replaceable></></term>
       <listitem>
       <para>
-      Use the file <replaceable class="parameter">filename</replaceable>
-      as the source of commands instead of reading commands interactively.
-      After the file is processed, <application>psql</application>
-      terminates. This is in many ways equivalent to the meta-command
-      <command>\i</command>.
+      Use the file <replaceable class="parameter">filename</replaceable> as
+      the source of commands instead of reading commands interactively.  This
+      option can be repeated and combined in any order with
+      the <option>-c</option> option.  After the commands in
+      every <option>-c</option> command string and <option>-f</option> file
+      are processed, <application>psql</application> terminates.  This option
+      is in many ways equivalent to the meta-command <command>\i</command>.
       </para>
 
       <para>
@@ -539,20 +549,21 @@ EOF
       <term><option>--single-transaction</option></term>
       <listitem>
        <para>
-        When <application>psql</application> executes a script, adding
-        this option wraps <command>BEGIN</>/<command>COMMIT</> around the
-        script to execute it as a single transaction.  This ensures that
-        either all the commands complete successfully, or no changes are
-        applied.
+        When <application>psql</application> executes commands from a script
+        and/or a <option>-c</option> option, adding this option
+        wraps <command>BEGIN</>/<command>COMMIT</> around all of those
+        commands as a whole to execute them as a single transaction.  This
+        ensures that either all the commands complete successfully, or no
+        changes are applied.
        </para>
 
        <para>
-        If the script itself uses <command>BEGIN</>, <command>COMMIT</>,
+        If the commands themselves
+        contain <command>BEGIN</>, <command>COMMIT</>,
         or <command>ROLLBACK</>, this option will not have the desired
-        effects.
-        Also, if the script contains any command that cannot be executed
-        inside a transaction block, specifying this option will cause that
-        command (and hence the whole transaction) to fail.
+        effects.  Also, if an individual command cannot be executed inside a
+        transaction block, specifying this option will cause the whole
+        transaction to fail.
        </para>
       </listitem>
      </varlistentry>
@@ -3725,7 +3736,7 @@ PSQL_EDITOR_LINENUMBER_ARG='--line '
    <term><filename>psqlrc</filename> and <filename>~/.psqlrc</filename></term>
    <listitem>
     <para>
-     Unless it is passed an <option>-X</option> or <option>-c</option> option,
+     Unless it is passed an <option>-X</option> option,
      <application>psql</application> attempts to read and execute commands
      from the system-wide startup file (<filename>psqlrc</filename>) and then
      the user's personal startup file (<filename>~/.psqlrc</filename>), after
@@ -3819,6 +3830,13 @@ PSQL_EDITOR_LINENUMBER_ARG='--line '
       </para>
       </listitem>
 
+      <listitem>
+      <para>
+       Before <productname>PostgreSQL</productname> 9.6, <option>-c</option>
+       used to imply <option>-X</option> and therefore it wouldn't
+       read <filename>psqlrc</filename> files, that is no longer the case.
+      </para>
+      </listitem>
     </itemizedlist>
  </refsect1>
 
diff --git a/src/bin/psql/command.c b/src/bin/psql/command.c
index 72c00c1..5e3b4ed 100644
--- a/src/bin/psql/command.c
+++ b/src/bin/psql/command.c
@@ -918,7 +918,7 @@ exec_command(const char *cmd,
 			include_relative = (strcmp(cmd, "ir") == 0
 								|| strcmp(cmd, "include_relative") == 0);
 			expand_tilde(&fname);
-			success = (process_file(fname, false, include_relative) == EXIT_SUCCESS);
+			success = (process_file(fname, include_relative) == EXIT_SUCCESS);
 			free(fname);
 		}
 	}
@@ -2287,13 +2287,12 @@ do_edit(const char *filename_arg, PQExpBuffer query_buf,
  * the file from where the currently processed file (if any) is located.
  */
 int
-process_file(char *filename, bool single_txn, bool use_relative_path)
+process_file(char *filename, bool use_relative_path)
 {
 	FILE	   *fd;
 	int			result;
 	char	   *oldfilename;
 	char		relpath[MAXPGPATH];
-	PGresult   *res;
 
 	if (!filename)
 	{
@@ -2338,37 +2337,8 @@ process_file(char *filename, bool single_txn, bool use_relative_path)
 	oldfilename = pset.inputfile;
 	pset.inputfile = filename;
 
-	if (single_txn)
-	{
-		if ((res = PSQLexec("BEGIN")) == NULL)
-		{
-			if (pset.on_error_stop)
-			{
-				result = EXIT_USER;
-				goto error;
-			}
-		}
-		else
-			PQclear(res);
-	}
-
 	result = MainLoop(fd);
 
-	if (single_txn)
-	{
-		if ((res = PSQLexec("COMMIT")) == NULL)
-		{
-			if (pset.on_error_stop)
-			{
-				result = EXIT_USER;
-				goto error;
-			}
-		}
-		else
-			PQclear(res);
-	}
-
-error:
 	if (fd != stdin)
 		fclose(fd);
 
diff --git a/src/bin/psql/command.h b/src/bin/psql/command.h
index 54385e8..c817600 100644
--- a/src/bin/psql/command.h
+++ b/src/bin/psql/command.h
@@ -27,7 +27,7 @@ typedef enum _backslashResult
 extern backslashResult HandleSlashCmds(PsqlScanState scan_state,
 				PQExpBuffer query_buf);
 
-extern int	process_file(char *filename, bool single_txn, bool use_relative_path);
+extern int	process_file(char *filename, bool use_relative_path);
 
 extern bool do_pset(const char *param,
 		const char *value,
diff --git a/src/bin/psql/startup.c b/src/bin/psql/startup.c
index 7aa997d..c3585c0 100644
--- a/src/bin/psql/startup.c
+++ b/src/bin/psql/startup.c
@@ -50,13 +50,24 @@ PsqlSettings pset;
  */
 enum _actions
 {
-	ACT_NOTHING = 0,
-	ACT_SINGLE_SLASH,
-	ACT_LIST_DB,
 	ACT_SINGLE_QUERY,
+	ACT_SINGLE_SLASH,
 	ACT_FILE
 };
 
+typedef struct SimpleActionListCell
+{
+	struct SimpleActionListCell *next;
+	int         action;
+	char        val[FLEXIBLE_ARRAY_MEMBER];
+} SimpleActionListCell;
+
+typedef struct SimpleActionList
+{
+	SimpleActionListCell *head;
+	SimpleActionListCell *tail;
+} SimpleActionList;
+
 struct adhoc_opts
 {
 	char	   *dbname;
@@ -64,11 +75,11 @@ struct adhoc_opts
 	char	   *port;
 	char	   *username;
 	char	   *logfilename;
-	enum _actions action;
-	char	   *action_string;
 	bool		no_readline;
 	bool		no_psqlrc;
 	bool		single_txn;
+	bool		list_dbs;
+	SimpleActionList actions;
 };
 
 static void parse_psql_options(int argc, char *argv[],
@@ -76,6 +87,8 @@ static void parse_psql_options(int argc, char *argv[],
 static void process_psqlrc(char *argv0);
 static void process_psqlrc_file(char *filename);
 static void showVersion(void);
+static void simple_action_list_append(SimpleActionList *list,
+									  int action, const char *val);
 static void EstablishVariableSpace(void);
 
 #define NOPAGER		0
@@ -159,6 +172,9 @@ main(int argc, char *argv[])
 	SetVariable(pset.vars, "PROMPT2", DEFAULT_PROMPT2);
 	SetVariable(pset.vars, "PROMPT3", DEFAULT_PROMPT3);
 
+	options.actions.head = NULL;
+	options.actions.tail = NULL;
+
 	parse_psql_options(argc, argv, &options);
 
 	/*
@@ -166,14 +182,11 @@ main(int argc, char *argv[])
 	 * as if the user had specified "-f -".  This lets single-transaction mode
 	 * work in this case.
 	 */
-	if (options.action == ACT_NOTHING && pset.notty)
-	{
-		options.action = ACT_FILE;
-		options.action_string = NULL;
-	}
+	 if (options.actions.head == NULL && pset.notty)
+		 simple_action_list_append(&options.actions, ACT_FILE, "-");
 
 	/* Bail out if -1 was specified but will be ignored. */
-	if (options.single_txn && options.action != ACT_FILE && options.action == ACT_NOTHING)
+	if (options.single_txn && options.actions.head == NULL)
 	{
 		fprintf(stderr, _("%s: -1 can only be used in non-interactive mode\n"), pset.progname);
 		exit(EXIT_FAILURE);
@@ -217,8 +230,7 @@ main(int argc, char *argv[])
 		keywords[3] = "password";
 		values[3] = password;
 		keywords[4] = "dbname";
-		values[4] = (options.action == ACT_LIST_DB &&
-					 options.dbname == NULL) ?
+		values[4] = (options.list_dbs && options.dbname == NULL) ?
 			"postgres" : options.dbname;
 		keywords[5] = "fallback_application_name";
 		values[5] = pset.progname;
@@ -259,7 +271,7 @@ main(int argc, char *argv[])
 
 	SyncVariables();
 
-	if (options.action == ACT_LIST_DB)
+	if (options.list_dbs)
 	{
 		int			success;
 
@@ -280,51 +292,90 @@ main(int argc, char *argv[])
 	}
 
 	/*
-	 * Now find something to do
-	 */
-
-	/*
-	 * process file given by -f
+	 * Now find something to do, process any actions given by caller,
+	 * respecting their order of reception.
 	 */
-	if (options.action == ACT_FILE)
+	if (options.actions.head != NULL)
 	{
-		if (!options.no_psqlrc)
-			process_psqlrc(argv[0]);
-
-		successResult = process_file(options.action_string, options.single_txn, false);
-	}
-
-	/*
-	 * process slash command if one was given to -c
-	 */
-	else if (options.action == ACT_SINGLE_SLASH)
-	{
-		PsqlScanState scan_state;
+		PGresult		*res;
+		SimpleActionListCell	*cell;
 
-		if (pset.echo == PSQL_ECHO_ALL)
-			puts(options.action_string);
+		successResult = EXIT_SUCCESS;	/* silence compiler */
 
-		scan_state = psql_scan_create();
-		psql_scan_setup(scan_state,
-						options.action_string,
-						strlen(options.action_string));
+		if (!options.no_psqlrc)
+			process_psqlrc(argv[0]);
 
-		successResult = HandleSlashCmds(scan_state, NULL) != PSQL_CMD_ERROR
-			? EXIT_SUCCESS : EXIT_FAILURE;
+		if (options.single_txn)
+		{
+			if ((res = PSQLexec("BEGIN")) == NULL)
+			{
+				if (pset.on_error_stop)
+				{
+					successResult = EXIT_USER;
+					goto error;
+				}
+			}
+			else
+				PQclear(res);
+		}
 
-		psql_scan_destroy(scan_state);
-	}
+		for (cell = options.actions.head; cell; cell = cell->next)
+		{
+			if (cell->action == ACT_SINGLE_QUERY)
+			{
+				if (pset.echo == PSQL_ECHO_ALL)
+					puts(cell->val);
+
+				successResult = SendQuery(cell->val)
+					? EXIT_SUCCESS : EXIT_FAILURE;
+			}
+			else if (cell->action == ACT_SINGLE_SLASH)
+			{
+				PsqlScanState scan_state;
+
+				if (pset.echo == PSQL_ECHO_ALL)
+					puts(cell->val);
+
+				scan_state = psql_scan_create();
+				psql_scan_setup(scan_state,
+							cell->val,
+							strlen(cell->val));
+
+				successResult = HandleSlashCmds(scan_state, NULL) != PSQL_CMD_ERROR
+					? EXIT_SUCCESS : EXIT_FAILURE;
+
+				psql_scan_destroy(scan_state);
+			}
+			else if (cell->action == ACT_FILE)
+			{
+				successResult = process_file(cell->val, false);
+			}
+			else
+			{
+				/* should never come here */
+				Assert(0);
+			}
+
+			if (successResult != EXIT_SUCCESS && pset.on_error_stop)
+				break;
+		}
 
-	/*
-	 * If the query given to -c was a normal one, send it
-	 */
-	else if (options.action == ACT_SINGLE_QUERY)
-	{
-		if (pset.echo == PSQL_ECHO_ALL)
-			puts(options.action_string);
+		if (options.single_txn)
+		{
+			if ((res = PSQLexec("COMMIT")) == NULL)
+			{
+				if (pset.on_error_stop)
+				{
+					successResult = EXIT_USER;
+					goto error;
+				}
+			}
+			else
+				PQclear(res);
+		}
 
-		successResult = SendQuery(options.action_string)
-			? EXIT_SUCCESS : EXIT_FAILURE;
+error:
+		;
 	}
 
 	/*
@@ -419,14 +470,14 @@ parse_psql_options(int argc, char *argv[], struct adhoc_opts * options)
 				SetVariable(pset.vars, "ECHO", "errors");
 				break;
 			case 'c':
-				options->action_string = pg_strdup(optarg);
 				if (optarg[0] == '\\')
-				{
-					options->action = ACT_SINGLE_SLASH;
-					options->action_string++;
-				}
+					simple_action_list_append(&options->actions,
+											  ACT_SINGLE_SLASH,
+											  pstrdup(optarg + 1));
 				else
-					options->action = ACT_SINGLE_QUERY;
+					simple_action_list_append(&options->actions,
+											  ACT_SINGLE_QUERY,
+											  pstrdup(optarg));
 				break;
 			case 'd':
 				options->dbname = pg_strdup(optarg);
@@ -438,8 +489,9 @@ parse_psql_options(int argc, char *argv[], struct adhoc_opts * options)
 				SetVariableBool(pset.vars, "ECHO_HIDDEN");
 				break;
 			case 'f':
-				options->action = ACT_FILE;
-				options->action_string = pg_strdup(optarg);
+				simple_action_list_append(&options->actions,
+									ACT_FILE,
+									pg_strdup(optarg));
 				break;
 			case 'F':
 				pset.popt.topt.fieldSep.separator = pg_strdup(optarg);
@@ -452,7 +504,7 @@ parse_psql_options(int argc, char *argv[], struct adhoc_opts * options)
 				pset.popt.topt.format = PRINT_HTML;
 				break;
 			case 'l':
-				options->action = ACT_LIST_DB;
+				options->list_dbs = true;
 				break;
 			case 'L':
 				options->logfilename = pg_strdup(optarg);
@@ -674,11 +726,11 @@ process_psqlrc_file(char *filename)
 
 	/* check for minor version first, then major, then no version */
 	if (access(psqlrc_minor, R_OK) == 0)
-		(void) process_file(psqlrc_minor, false, false);
+		(void) process_file(psqlrc_minor, false);
 	else if (access(psqlrc_major, R_OK) == 0)
-		(void) process_file(psqlrc_major, false, false);
+		(void) process_file(psqlrc_major, false);
 	else if (access(filename, R_OK) == 0)
-		(void) process_file(filename, false, false);
+		(void) process_file(filename, false);
 
 	free(psqlrc_minor);
 	free(psqlrc_major);
@@ -892,6 +944,29 @@ show_context_hook(const char *newval)
 }
 
 
+/*
+ * Support for list of actions. SimpleStringList cannot be used due possible
+ * combination different actions with the requirement to save the order.
+ */
+static void
+simple_action_list_append(SimpleActionList *list, int action, const char *val)
+{
+	SimpleActionListCell   *cell;
+
+	cell = (SimpleActionListCell *)
+		pg_malloc(offsetof(SimpleActionListCell, val) + strlen(val) + 1);
+
+	cell->next = NULL;
+	cell->action = action;
+	strcpy(cell->val, val);
+
+	if (list->tail)
+		list->tail->next = cell;
+	else
+		list->head = cell;
+	list->tail = cell;
+}
+
 static void
 EstablishVariableSpace(void)
 {

diff --git a/doc/src/sgml/ref/psql-ref.sgml b/doc/src/sgml/ref/psql-ref.sgml
index e4f72a8..47e9da2 100644
--- a/doc/src/sgml/ref/psql-ref.sgml
+++ b/doc/src/sgml/ref/psql-ref.sgml
@@ -38,9 +38,10 @@ PostgreSQL documentation
      <productname>PostgreSQL</productname>. It enables you to type in
      queries interactively, issue them to
      <productname>PostgreSQL</productname>, and see the query results.
-     Alternatively, input can be from a file. In addition, it provides a
-     number of meta-commands and various shell-like features to
-     facilitate writing scripts and automating a wide variety of tasks.
+     Alternatively, input can be from a file or from command line
+     arguments. In addition, it provides a number of meta-commands and various
+     shell-like features to facilitate writing scripts and automating a wide
+     variety of tasks.
     </para>
  </refsect1>
 
@@ -89,11 +90,10 @@ PostgreSQL documentation
       <term><option>--command=<replaceable class="parameter">command</replaceable></></term>
       <listitem>
       <para>
-      Specifies that <application>psql</application> is to execute one
-      command string, <replaceable class="parameter">command</replaceable>,
-      and then exit. This is useful in shell scripts. Start-up files
-      (<filename>psqlrc</filename> and <filename>~/.psqlrc</filename>) are
-      ignored with this option.
+      Specifies that <application>psql</application> is to execute the given
+      command string, <replaceable class="parameter">command</replaceable>.
+      This option can be repeated and combined in any order with
+      the <option>-f</option> option.
       </para>
       <para>
       <replaceable class="parameter">command</replaceable> must be either
@@ -102,25 +102,34 @@ PostgreSQL documentation
       or a single backslash command. Thus you cannot mix
       <acronym>SQL</acronym> and <application>psql</application>
       meta-commands with this option. To achieve that, you could
-      pipe the string into <application>psql</application>, for example:
+      use repeated <option>-c</option> options or pipe the string
+      into <application>psql</application>, for example:
+      <literal>psql -c '\x' -c 'SELECT * FROM foo;'</literal> or
       <literal>echo '\x \\ SELECT * FROM foo;' | psql</literal>.
       (<literal>\\</> is the separator meta-command.)
       </para>
       <para>
-       If the command string contains multiple SQL commands, they are
-       processed in a single transaction, unless there are explicit
-       <command>BEGIN</>/<command>COMMIT</> commands included in the
-       string to divide it into multiple transactions.  This is
-       different from the behavior when the same string is fed to
-       <application>psql</application>'s standard input.  Also, only
-       the result of the last SQL command is returned.
+       Each command string passed to <option>-c</option> is sent to the server
+       as a single query. Because of this, the server executes it as a single
+       transaction, even if a command string contains
+       multiple <acronym>SQL</acronym> commands, unless there are
+       explicit <command>BEGIN</>/<command>COMMIT</> commands included in the
+       string to divide it into multiple transactions.  Also, the server only
+       returns the result of the last <acronym>SQL</acronym> command to the
+       client.  This is different from the behavior when the same string with
+       multiple <acronym>SQL</acronym> commands is fed
+       to <application>psql</application>'s standard input because
+       then <application>psql</application> sends each <acronym>SQL</acronym>
+       command separately.
       </para>
       <para>
-       Because of these legacy behaviors, putting more than one command in
-       the <option>-c</option> string often has unexpected results.  It's
-       better to feed multiple commands to <application>psql</application>'s
-       standard input, either using <application>echo</application> as
-       illustrated above, or via a shell here-document, for example:
+       Putting more than one command in the <option>-c</option> string often
+       has unexpected results.  This is a result of the fact that the whole
+       string is sent to the server as a single query.
+       It's better to use repeated <option>-c</option> commands or feed
+       multiple commands to <application>psql</application>'s standard input,
+       either using <application>echo</application> as illustrated above, or
+       via a shell here-document, for example:
 <programlisting>
 psql &lt;&lt;EOF
 \x
@@ -185,9 +194,11 @@ EOF
       <para>
       Use the file <replaceable class="parameter">filename</replaceable>
       as the source of commands instead of reading commands interactively.
-      After the file is processed, <application>psql</application>
-      terminates. This is in many ways equivalent to the meta-command
-      <command>\i</command>.
+      This option can be repeated and combined in any order with
+      the <option>-c</option> option.  After the commands in
+      every <option>-c</option> command string and <option>-f</option> file
+      are processed, <application>psql</application> terminates.  This option
+      is in many ways equivalent to the meta-command <command>\i</command>.
       </para>
 
       <para>
@@ -539,20 +550,21 @@ EOF
       <term><option>--single-transaction</option></term>
       <listitem>
        <para>
-        When <application>psql</application> executes a script, adding
-        this option wraps <command>BEGIN</>/<command>COMMIT</> around the
-        script to execute it as a single transaction.  This ensures that
-        either all the commands complete successfully, or no changes are
-        applied.
+        When <application>psql</application> executes commands from a script
+        and/or a <option>-c</option> option, adding this option
+        wraps <command>BEGIN</>/<command>COMMIT</> around all of those
+        commands as a whole to execute them as a single transaction.  This
+        ensures that either all the commands complete successfully, or no
+        changes are applied.
        </para>
 
        <para>
-        If the script itself uses <command>BEGIN</>, <command>COMMIT</>,
+        If the commands themselves
+        contain <command>BEGIN</>, <command>COMMIT</>,
         or <command>ROLLBACK</>, this option will not have the desired
-        effects.
-        Also, if the script contains any command that cannot be executed
-        inside a transaction block, specifying this option will cause that
-        command (and hence the whole transaction) to fail.
+        effects.  Also, if an individual command cannot be executed inside a
+        transaction block, specifying this option will cause the whole
+        transaction to fail.
        </para>
       </listitem>
      </varlistentry>
@@ -3725,7 +3737,7 @@ PSQL_EDITOR_LINENUMBER_ARG='--line '
    <term><filename>psqlrc</filename> and <filename>~/.psqlrc</filename></term>
    <listitem>
     <para>
-     Unless it is passed an <option>-X</option> or <option>-c</option> option,
+     Unless it is passed an <option>-X</option> option,
      <application>psql</application> attempts to read and execute commands
      from the system-wide startup file (<filename>psqlrc</filename>) and then
      the user's personal startup file (<filename>~/.psqlrc</filename>), after
@@ -3819,6 +3831,12 @@ PSQL_EDITOR_LINENUMBER_ARG='--line '
       </para>
       </listitem>
 
+      <listitem>
+      <para>
+       Before <productname>PostgreSQL</productname> 9.6, <option>-c</option>
+       implied <option>-X</option>; this is no longer the case.
+      </para>
+      </listitem>
     </itemizedlist>
  </refsect1>
 
diff --git a/src/bin/psql/command.c b/src/bin/psql/command.c
index 6e8c623..cf6876b 100644
--- a/src/bin/psql/command.c
+++ b/src/bin/psql/command.c
@@ -916,7 +916,7 @@ exec_command(const char *cmd,
 			include_relative = (strcmp(cmd, "ir") == 0
 								|| strcmp(cmd, "include_relative") == 0);
 			expand_tilde(&fname);
-			success = (process_file(fname, false, include_relative) == EXIT_SUCCESS);
+			success = (process_file(fname, include_relative) == EXIT_SUCCESS);
 			free(fname);
 		}
 	}
@@ -2288,13 +2288,12 @@ do_edit(const char *filename_arg, PQExpBuffer query_buf,
  * the file from where the currently processed file (if any) is located.
  */
 int
-process_file(char *filename, bool single_txn, bool use_relative_path)
+process_file(char *filename, bool use_relative_path)
 {
 	FILE	   *fd;
 	int			result;
 	char	   *oldfilename;
 	char		relpath[MAXPGPATH];
-	PGresult   *res;
 
 	if (!filename)
 	{
@@ -2339,37 +2338,8 @@ process_file(char *filename, bool single_txn, bool use_relative_path)
 	oldfilename = pset.inputfile;
 	pset.inputfile = filename;
 
-	if (single_txn)
-	{
-		if ((res = PSQLexec("BEGIN")) == NULL)
-		{
-			if (pset.on_error_stop)
-			{
-				result = EXIT_USER;
-				goto error;
-			}
-		}
-		else
-			PQclear(res);
-	}
-
 	result = MainLoop(fd);
 
-	if (single_txn)
-	{
-		if ((res = PSQLexec("COMMIT")) == NULL)
-		{
-			if (pset.on_error_stop)
-			{
-				result = EXIT_USER;
-				goto error;
-			}
-		}
-		else
-			PQclear(res);
-	}
-
-error:
 	if (fd != stdin)
 		fclose(fd);
 
diff --git a/src/bin/psql/command.h b/src/bin/psql/command.h
index 54385e8..c817600 100644
--- a/src/bin/psql/command.h
+++ b/src/bin/psql/command.h
@@ -27,7 +27,7 @@ typedef enum _backslashResult
 extern backslashResult HandleSlashCmds(PsqlScanState scan_state,
 				PQExpBuffer query_buf);
 
-extern int	process_file(char *filename, bool single_txn, bool use_relative_path);
+extern int	process_file(char *filename, bool use_relative_path);
 
 extern bool do_pset(const char *param,
 		const char *value,
diff --git a/src/bin/psql/startup.c b/src/bin/psql/startup.c
index 4e5021a..dbfd20f 100644
--- a/src/bin/psql/startup.c
+++ b/src/bin/psql/startup.c
@@ -50,13 +50,24 @@ PsqlSettings pset;
  */
 enum _actions
 {
-	ACT_NOTHING = 0,
-	ACT_SINGLE_SLASH,
-	ACT_LIST_DB,
 	ACT_SINGLE_QUERY,
+	ACT_SINGLE_SLASH,
 	ACT_FILE
 };
 
+typedef struct SimpleActionListCell
+{
+	struct SimpleActionListCell *next;
+	int         action;
+	char        val[FLEXIBLE_ARRAY_MEMBER];
+} SimpleActionListCell;
+
+typedef struct SimpleActionList
+{
+	SimpleActionListCell *head;
+	SimpleActionListCell *tail;
+} SimpleActionList;
+
 struct adhoc_opts
 {
 	char	   *dbname;
@@ -64,11 +75,11 @@ struct adhoc_opts
 	char	   *port;
 	char	   *username;
 	char	   *logfilename;
-	enum _actions action;
-	char	   *action_string;
 	bool		no_readline;
 	bool		no_psqlrc;
 	bool		single_txn;
+	bool		list_dbs;
+	SimpleActionList actions;
 };
 
 static void parse_psql_options(int argc, char *argv[],
@@ -76,6 +87,8 @@ static void parse_psql_options(int argc, char *argv[],
 static void process_psqlrc(char *argv0);
 static void process_psqlrc_file(char *filename);
 static void showVersion(void);
+static void simple_action_list_append(SimpleActionList *list,
+									  int action, const char *val);
 static void EstablishVariableSpace(void);
 
 #define NOPAGER		0
@@ -159,6 +172,9 @@ main(int argc, char *argv[])
 	SetVariable(pset.vars, "PROMPT2", DEFAULT_PROMPT2);
 	SetVariable(pset.vars, "PROMPT3", DEFAULT_PROMPT3);
 
+	options.actions.head = NULL;
+	options.actions.tail = NULL;
+
 	parse_psql_options(argc, argv, &options);
 
 	/*
@@ -166,14 +182,11 @@ main(int argc, char *argv[])
 	 * as if the user had specified "-f -".  This lets single-transaction mode
 	 * work in this case.
 	 */
-	if (options.action == ACT_NOTHING && pset.notty)
-	{
-		options.action = ACT_FILE;
-		options.action_string = NULL;
-	}
+	if (options.actions.head == NULL && pset.notty)
+		simple_action_list_append(&options.actions, ACT_FILE, "-");
 
 	/* Bail out if -1 was specified but will be ignored. */
-	if (options.single_txn && options.action != ACT_FILE && options.action == ACT_NOTHING)
+	if (options.single_txn && options.actions.head == NULL)
 	{
 		fprintf(stderr, _("%s: -1 can only be used in non-interactive mode\n"), pset.progname);
 		exit(EXIT_FAILURE);
@@ -217,8 +230,7 @@ main(int argc, char *argv[])
 		keywords[3] = "password";
 		values[3] = password;
 		keywords[4] = "dbname";
-		values[4] = (options.action == ACT_LIST_DB &&
-					 options.dbname == NULL) ?
+		values[4] = (options.list_dbs && options.dbname == NULL) ?
 			"postgres" : options.dbname;
 		keywords[5] = "fallback_application_name";
 		values[5] = pset.progname;
@@ -259,7 +271,7 @@ main(int argc, char *argv[])
 
 	SyncVariables();
 
-	if (options.action == ACT_LIST_DB)
+	if (options.list_dbs)
 	{
 		int			success;
 
@@ -279,52 +291,91 @@ main(int argc, char *argv[])
 					pset.progname, options.logfilename, strerror(errno));
 	}
 
-	/*
-	 * Now find something to do
-	 */
+	if (!options.no_psqlrc)
+		process_psqlrc(argv[0]);
 
 	/*
-	 * process file given by -f
+	 * If any actions were given by caller, process them in the order in
+	 * which they were specified.
 	 */
-	if (options.action == ACT_FILE)
+	if (options.actions.head != NULL)
 	{
-		if (!options.no_psqlrc)
-			process_psqlrc(argv[0]);
+		PGresult		*res;
+		SimpleActionListCell	*cell;
 
-		successResult = process_file(options.action_string, options.single_txn, false);
-	}
-
-	/*
-	 * process slash command if one was given to -c
-	 */
-	else if (options.action == ACT_SINGLE_SLASH)
-	{
-		PsqlScanState scan_state;
-
-		if (pset.echo == PSQL_ECHO_ALL)
-			puts(options.action_string);
+		successResult = EXIT_SUCCESS;	/* silence compiler */
 
-		scan_state = psql_scan_create();
-		psql_scan_setup(scan_state,
-						options.action_string,
-						strlen(options.action_string));
-
-		successResult = HandleSlashCmds(scan_state, NULL) != PSQL_CMD_ERROR
-			? EXIT_SUCCESS : EXIT_FAILURE;
+		if (options.single_txn)
+		{
+			if ((res = PSQLexec("BEGIN")) == NULL)
+			{
+				if (pset.on_error_stop)
+				{
+					successResult = EXIT_USER;
+					goto error;
+				}
+			}
+			else
+				PQclear(res);
+		}
 
-		psql_scan_destroy(scan_state);
-	}
+		for (cell = options.actions.head; cell; cell = cell->next)
+		{
+			if (cell->action == ACT_SINGLE_QUERY)
+			{
+				if (pset.echo == PSQL_ECHO_ALL)
+					puts(cell->val);
+
+				successResult = SendQuery(cell->val)
+					? EXIT_SUCCESS : EXIT_FAILURE;
+			}
+			else if (cell->action == ACT_SINGLE_SLASH)
+			{
+				PsqlScanState scan_state;
+
+				if (pset.echo == PSQL_ECHO_ALL)
+					puts(cell->val);
+
+				scan_state = psql_scan_create();
+				psql_scan_setup(scan_state,
+							cell->val,
+							strlen(cell->val));
+
+				successResult = HandleSlashCmds(scan_state, NULL) != PSQL_CMD_ERROR
+					? EXIT_SUCCESS : EXIT_FAILURE;
+
+				psql_scan_destroy(scan_state);
+			}
+			else if (cell->action == ACT_FILE)
+			{
+				successResult = process_file(cell->val, false);
+			}
+			else
+			{
+				/* should never come here */
+				Assert(0);
+			}
+
+			if (successResult != EXIT_SUCCESS && pset.on_error_stop)
+				break;
+		}
 
-	/*
-	 * If the query given to -c was a normal one, send it
-	 */
-	else if (options.action == ACT_SINGLE_QUERY)
-	{
-		if (pset.echo == PSQL_ECHO_ALL)
-			puts(options.action_string);
+		if (options.single_txn)
+		{
+			if ((res = PSQLexec("COMMIT")) == NULL)
+			{
+				if (pset.on_error_stop)
+				{
+					successResult = EXIT_USER;
+					goto error;
+				}
+			}
+			else
+				PQclear(res);
+		}
 
-		successResult = SendQuery(options.action_string)
-			? EXIT_SUCCESS : EXIT_FAILURE;
+error:
+		;
 	}
 
 	/*
@@ -332,9 +383,6 @@ main(int argc, char *argv[])
 	 */
 	else
 	{
-		if (!options.no_psqlrc)
-			process_psqlrc(argv[0]);
-
 		connection_warnings(true);
 		if (!pset.quiet)
 			printf(_("Type \"help\" for help.\n\n"));
@@ -419,14 +467,14 @@ parse_psql_options(int argc, char *argv[], struct adhoc_opts * options)
 				SetVariable(pset.vars, "ECHO", "errors");
 				break;
 			case 'c':
-				options->action_string = pg_strdup(optarg);
 				if (optarg[0] == '\\')
-				{
-					options->action = ACT_SINGLE_SLASH;
-					options->action_string++;
-				}
+					simple_action_list_append(&options->actions,
+											  ACT_SINGLE_SLASH,
+											  pstrdup(optarg + 1));
 				else
-					options->action = ACT_SINGLE_QUERY;
+					simple_action_list_append(&options->actions,
+											  ACT_SINGLE_QUERY,
+											  pstrdup(optarg));
 				break;
 			case 'd':
 				options->dbname = pg_strdup(optarg);
@@ -438,8 +486,9 @@ parse_psql_options(int argc, char *argv[], struct adhoc_opts * options)
 				SetVariableBool(pset.vars, "ECHO_HIDDEN");
 				break;
 			case 'f':
-				options->action = ACT_FILE;
-				options->action_string = pg_strdup(optarg);
+				simple_action_list_append(&options->actions,
+									ACT_FILE,
+									pg_strdup(optarg));
 				break;
 			case 'F':
 				pset.popt.topt.fieldSep.separator = pg_strdup(optarg);
@@ -452,7 +501,7 @@ parse_psql_options(int argc, char *argv[], struct adhoc_opts * options)
 				pset.popt.topt.format = PRINT_HTML;
 				break;
 			case 'l':
-				options->action = ACT_LIST_DB;
+				options->list_dbs = true;
 				break;
 			case 'L':
 				options->logfilename = pg_strdup(optarg);
@@ -675,11 +724,11 @@ process_psqlrc_file(char *filename)
 
 	/* check for minor version first, then major, then no version */
 	if (access(psqlrc_minor, R_OK) == 0)
-		(void) process_file(psqlrc_minor, false, false);
+		(void) process_file(psqlrc_minor, false);
 	else if (access(psqlrc_major, R_OK) == 0)
-		(void) process_file(psqlrc_major, false, false);
+		(void) process_file(psqlrc_major, false);
 	else if (access(filename, R_OK) == 0)
-		(void) process_file(filename, false, false);
+		(void) process_file(filename, false);
 
 	free(psqlrc_minor);
 	free(psqlrc_major);
@@ -893,6 +942,29 @@ show_context_hook(const char *newval)
 }
 
 
+/*
+ * Support for list of actions. SimpleStringList cannot be used due possible
+ * combination different actions with the requirement to save the order.
+ */
+static void
+simple_action_list_append(SimpleActionList *list, int action, const char *val)
+{
+	SimpleActionListCell   *cell;
+
+	cell = (SimpleActionListCell *)
+		pg_malloc(offsetof(SimpleActionListCell, val) + strlen(val) + 1);
+
+	cell->next = NULL;
+	cell->action = action;
+	strcpy(cell->val, val);
+
+	if (list->tail)
+		list->tail->next = cell;
+	else
+		list->head = cell;
+	list->tail = cell;
+}
+
 static void
 EstablishVariableSpace(void)
 {

diff --git a/doc/src/sgml/ref/psql-ref.sgml b/doc/src/sgml/ref/psql-ref.sgml
index e4f72a8..47e9da2 100644
--- a/doc/src/sgml/ref/psql-ref.sgml
+++ b/doc/src/sgml/ref/psql-ref.sgml
@@ -38,9 +38,10 @@ PostgreSQL documentation
      <productname>PostgreSQL</productname>. It enables you to type in
      queries interactively, issue them to
      <productname>PostgreSQL</productname>, and see the query results.
-     Alternatively, input can be from a file. In addition, it provides a
-     number of meta-commands and various shell-like features to
-     facilitate writing scripts and automating a wide variety of tasks.
+     Alternatively, input can be from a file or from command line
+     arguments. In addition, it provides a number of meta-commands and various
+     shell-like features to facilitate writing scripts and automating a wide
+     variety of tasks.
     </para>
  </refsect1>
 
@@ -89,11 +90,10 @@ PostgreSQL documentation
       <term><option>--command=<replaceable class="parameter">command</replaceable></></term>
       <listitem>
       <para>
-      Specifies that <application>psql</application> is to execute one
-      command string, <replaceable class="parameter">command</replaceable>,
-      and then exit. This is useful in shell scripts. Start-up files
-      (<filename>psqlrc</filename> and <filename>~/.psqlrc</filename>) are
-      ignored with this option.
+      Specifies that <application>psql</application> is to execute the given
+      command string, <replaceable class="parameter">command</replaceable>.
+      This option can be repeated and combined in any order with
+      the <option>-f</option> option.
       </para>
       <para>
       <replaceable class="parameter">command</replaceable> must be either
@@ -102,25 +102,34 @@ PostgreSQL documentation
       or a single backslash command. Thus you cannot mix
       <acronym>SQL</acronym> and <application>psql</application>
       meta-commands with this option. To achieve that, you could
-      pipe the string into <application>psql</application>, for example:
+      use repeated <option>-c</option> options or pipe the string
+      into <application>psql</application>, for example:
+      <literal>psql -c '\x' -c 'SELECT * FROM foo;'</literal> or
       <literal>echo '\x \\ SELECT * FROM foo;' | psql</literal>.
       (<literal>\\</> is the separator meta-command.)
       </para>
       <para>
-       If the command string contains multiple SQL commands, they are
-       processed in a single transaction, unless there are explicit
-       <command>BEGIN</>/<command>COMMIT</> commands included in the
-       string to divide it into multiple transactions.  This is
-       different from the behavior when the same string is fed to
-       <application>psql</application>'s standard input.  Also, only
-       the result of the last SQL command is returned.
+       Each command string passed to <option>-c</option> is sent to the server
+       as a single query. Because of this, the server executes it as a single
+       transaction, even if a command string contains
+       multiple <acronym>SQL</acronym> commands, unless there are
+       explicit <command>BEGIN</>/<command>COMMIT</> commands included in the
+       string to divide it into multiple transactions.  Also, the server only
+       returns the result of the last <acronym>SQL</acronym> command to the
+       client.  This is different from the behavior when the same string with
+       multiple <acronym>SQL</acronym> commands is fed
+       to <application>psql</application>'s standard input because
+       then <application>psql</application> sends each <acronym>SQL</acronym>
+       command separately.
       </para>
       <para>
-       Because of these legacy behaviors, putting more than one command in
-       the <option>-c</option> string often has unexpected results.  It's
-       better to feed multiple commands to <application>psql</application>'s
-       standard input, either using <application>echo</application> as
-       illustrated above, or via a shell here-document, for example:
+       Putting more than one command in the <option>-c</option> string often
+       has unexpected results.  This is a result of the fact that the whole
+       string is sent to the server as a single query.
+       It's better to use repeated <option>-c</option> commands or feed
+       multiple commands to <application>psql</application>'s standard input,
+       either using <application>echo</application> as illustrated above, or
+       via a shell here-document, for example:
 <programlisting>
 psql &lt;&lt;EOF
 \x
@@ -185,9 +194,11 @@ EOF
       <para>
       Use the file <replaceable class="parameter">filename</replaceable>
       as the source of commands instead of reading commands interactively.
-      After the file is processed, <application>psql</application>
-      terminates. This is in many ways equivalent to the meta-command
-      <command>\i</command>.
+      This option can be repeated and combined in any order with
+      the <option>-c</option> option.  After the commands in
+      every <option>-c</option> command string and <option>-f</option> file
+      are processed, <application>psql</application> terminates.  This option
+      is in many ways equivalent to the meta-command <command>\i</command>.
       </para>
 
       <para>
@@ -539,20 +550,21 @@ EOF
       <term><option>--single-transaction</option></term>
       <listitem>
        <para>
-        When <application>psql</application> executes a script, adding
-        this option wraps <command>BEGIN</>/<command>COMMIT</> around the
-        script to execute it as a single transaction.  This ensures that
-        either all the commands complete successfully, or no changes are
-        applied.
+        When <application>psql</application> executes commands from a script
+        and/or a <option>-c</option> option, adding this option
+        wraps <command>BEGIN</>/<command>COMMIT</> around all of those
+        commands as a whole to execute them as a single transaction.  This
+        ensures that either all the commands complete successfully, or no
+        changes are applied.
        </para>
 
        <para>
-        If the script itself uses <command>BEGIN</>, <command>COMMIT</>,
+        If the commands themselves
+        contain <command>BEGIN</>, <command>COMMIT</>,
         or <command>ROLLBACK</>, this option will not have the desired
-        effects.
-        Also, if the script contains any command that cannot be executed
-        inside a transaction block, specifying this option will cause that
-        command (and hence the whole transaction) to fail.
+        effects.  Also, if an individual command cannot be executed inside a
+        transaction block, specifying this option will cause the whole
+        transaction to fail.
        </para>
       </listitem>
      </varlistentry>
@@ -3725,7 +3737,7 @@ PSQL_EDITOR_LINENUMBER_ARG='--line '
    <term><filename>psqlrc</filename> and <filename>~/.psqlrc</filename></term>
    <listitem>
     <para>
-     Unless it is passed an <option>-X</option> or <option>-c</option> option,
+     Unless it is passed an <option>-X</option> option,
      <application>psql</application> attempts to read and execute commands
      from the system-wide startup file (<filename>psqlrc</filename>) and then
      the user's personal startup file (<filename>~/.psqlrc</filename>), after
@@ -3819,6 +3831,12 @@ PSQL_EDITOR_LINENUMBER_ARG='--line '
       </para>
       </listitem>
 
+      <listitem>
+      <para>
+       Before <productname>PostgreSQL</productname> 9.6, <option>-c</option>
+       implied <option>-X</option>; this is no longer the case.
+      </para>
+      </listitem>
     </itemizedlist>
  </refsect1>
 
diff --git a/src/bin/psql/command.c b/src/bin/psql/command.c
index 6e8c623..cf6876b 100644
--- a/src/bin/psql/command.c
+++ b/src/bin/psql/command.c
@@ -916,7 +916,7 @@ exec_command(const char *cmd,
 			include_relative = (strcmp(cmd, "ir") == 0
 								|| strcmp(cmd, "include_relative") == 0);
 			expand_tilde(&fname);
-			success = (process_file(fname, false, include_relative) == EXIT_SUCCESS);
+			success = (process_file(fname, include_relative) == EXIT_SUCCESS);
 			free(fname);
 		}
 	}
@@ -2288,13 +2288,12 @@ do_edit(const char *filename_arg, PQExpBuffer query_buf,
  * the file from where the currently processed file (if any) is located.
  */
 int
-process_file(char *filename, bool single_txn, bool use_relative_path)
+process_file(char *filename, bool use_relative_path)
 {
 	FILE	   *fd;
 	int			result;
 	char	   *oldfilename;
 	char		relpath[MAXPGPATH];
-	PGresult   *res;
 
 	if (!filename)
 	{
@@ -2339,37 +2338,8 @@ process_file(char *filename, bool single_txn, bool use_relative_path)
 	oldfilename = pset.inputfile;
 	pset.inputfile = filename;
 
-	if (single_txn)
-	{
-		if ((res = PSQLexec("BEGIN")) == NULL)
-		{
-			if (pset.on_error_stop)
-			{
-				result = EXIT_USER;
-				goto error;
-			}
-		}
-		else
-			PQclear(res);
-	}
-
 	result = MainLoop(fd);
 
-	if (single_txn)
-	{
-		if ((res = PSQLexec("COMMIT")) == NULL)
-		{
-			if (pset.on_error_stop)
-			{
-				result = EXIT_USER;
-				goto error;
-			}
-		}
-		else
-			PQclear(res);
-	}
-
-error:
 	if (fd != stdin)
 		fclose(fd);
 
diff --git a/src/bin/psql/command.h b/src/bin/psql/command.h
index 54385e8..c817600 100644
--- a/src/bin/psql/command.h
+++ b/src/bin/psql/command.h
@@ -27,7 +27,7 @@ typedef enum _backslashResult
 extern backslashResult HandleSlashCmds(PsqlScanState scan_state,
 				PQExpBuffer query_buf);
 
-extern int	process_file(char *filename, bool single_txn, bool use_relative_path);
+extern int	process_file(char *filename, bool use_relative_path);
 
 extern bool do_pset(const char *param,
 		const char *value,
diff --git a/src/bin/psql/startup.c b/src/bin/psql/startup.c
index 4e5021a..7af38fb 100644
--- a/src/bin/psql/startup.c
+++ b/src/bin/psql/startup.c
@@ -50,13 +50,24 @@ PsqlSettings pset;
  */
 enum _actions
 {
-	ACT_NOTHING = 0,
-	ACT_SINGLE_SLASH,
-	ACT_LIST_DB,
 	ACT_SINGLE_QUERY,
+	ACT_SINGLE_SLASH,
 	ACT_FILE
 };
 
+typedef struct SimpleActionListCell
+{
+	struct SimpleActionListCell *next;
+	int         action;
+	char       *val;
+} SimpleActionListCell;
+
+typedef struct SimpleActionList
+{
+	SimpleActionListCell *head;
+	SimpleActionListCell *tail;
+} SimpleActionList;
+
 struct adhoc_opts
 {
 	char	   *dbname;
@@ -64,11 +75,11 @@ struct adhoc_opts
 	char	   *port;
 	char	   *username;
 	char	   *logfilename;
-	enum _actions action;
-	char	   *action_string;
 	bool		no_readline;
 	bool		no_psqlrc;
 	bool		single_txn;
+	bool		list_dbs;
+	SimpleActionList actions;
 };
 
 static void parse_psql_options(int argc, char *argv[],
@@ -76,6 +87,8 @@ static void parse_psql_options(int argc, char *argv[],
 static void process_psqlrc(char *argv0);
 static void process_psqlrc_file(char *filename);
 static void showVersion(void);
+static void simple_action_list_append(SimpleActionList *list,
+									  int action, const char *val);
 static void EstablishVariableSpace(void);
 
 #define NOPAGER		0
@@ -159,6 +172,9 @@ main(int argc, char *argv[])
 	SetVariable(pset.vars, "PROMPT2", DEFAULT_PROMPT2);
 	SetVariable(pset.vars, "PROMPT3", DEFAULT_PROMPT3);
 
+	options.actions.head = NULL;
+	options.actions.tail = NULL;
+
 	parse_psql_options(argc, argv, &options);
 
 	/*
@@ -166,14 +182,11 @@ main(int argc, char *argv[])
 	 * as if the user had specified "-f -".  This lets single-transaction mode
 	 * work in this case.
 	 */
-	if (options.action == ACT_NOTHING && pset.notty)
-	{
-		options.action = ACT_FILE;
-		options.action_string = NULL;
-	}
+	if (options.actions.head == NULL && pset.notty)
+		simple_action_list_append(&options.actions, ACT_FILE, NULL);
 
 	/* Bail out if -1 was specified but will be ignored. */
-	if (options.single_txn && options.action != ACT_FILE && options.action == ACT_NOTHING)
+	if (options.single_txn && options.actions.head == NULL)
 	{
 		fprintf(stderr, _("%s: -1 can only be used in non-interactive mode\n"), pset.progname);
 		exit(EXIT_FAILURE);
@@ -217,8 +230,7 @@ main(int argc, char *argv[])
 		keywords[3] = "password";
 		values[3] = password;
 		keywords[4] = "dbname";
-		values[4] = (options.action == ACT_LIST_DB &&
-					 options.dbname == NULL) ?
+		values[4] = (options.list_dbs && options.dbname == NULL) ?
 			"postgres" : options.dbname;
 		keywords[5] = "fallback_application_name";
 		values[5] = pset.progname;
@@ -259,7 +271,7 @@ main(int argc, char *argv[])
 
 	SyncVariables();
 
-	if (options.action == ACT_LIST_DB)
+	if (options.list_dbs)
 	{
 		int			success;
 
@@ -279,52 +291,91 @@ main(int argc, char *argv[])
 					pset.progname, options.logfilename, strerror(errno));
 	}
 
-	/*
-	 * Now find something to do
-	 */
+	if (!options.no_psqlrc)
+		process_psqlrc(argv[0]);
 
 	/*
-	 * process file given by -f
+	 * If any actions were given by caller, process them in the order in
+	 * which they were specified.
 	 */
-	if (options.action == ACT_FILE)
+	if (options.actions.head != NULL)
 	{
-		if (!options.no_psqlrc)
-			process_psqlrc(argv[0]);
+		PGresult		*res;
+		SimpleActionListCell	*cell;
 
-		successResult = process_file(options.action_string, options.single_txn, false);
-	}
+		successResult = EXIT_SUCCESS;	/* silence compiler */
 
-	/*
-	 * process slash command if one was given to -c
-	 */
-	else if (options.action == ACT_SINGLE_SLASH)
-	{
-		PsqlScanState scan_state;
-
-		if (pset.echo == PSQL_ECHO_ALL)
-			puts(options.action_string);
-
-		scan_state = psql_scan_create();
-		psql_scan_setup(scan_state,
-						options.action_string,
-						strlen(options.action_string));
-
-		successResult = HandleSlashCmds(scan_state, NULL) != PSQL_CMD_ERROR
-			? EXIT_SUCCESS : EXIT_FAILURE;
+		if (options.single_txn)
+		{
+			if ((res = PSQLexec("BEGIN")) == NULL)
+			{
+				if (pset.on_error_stop)
+				{
+					successResult = EXIT_USER;
+					goto error;
+				}
+			}
+			else
+				PQclear(res);
+		}
 
-		psql_scan_destroy(scan_state);
-	}
+		for (cell = options.actions.head; cell; cell = cell->next)
+		{
+			if (cell->action == ACT_SINGLE_QUERY)
+			{
+				if (pset.echo == PSQL_ECHO_ALL)
+					puts(cell->val);
+
+				successResult = SendQuery(cell->val)
+					? EXIT_SUCCESS : EXIT_FAILURE;
+			}
+			else if (cell->action == ACT_SINGLE_SLASH)
+			{
+				PsqlScanState scan_state;
+
+				if (pset.echo == PSQL_ECHO_ALL)
+					puts(cell->val);
+
+				scan_state = psql_scan_create();
+				psql_scan_setup(scan_state,
+							cell->val,
+							strlen(cell->val));
+
+				successResult = HandleSlashCmds(scan_state, NULL) != PSQL_CMD_ERROR
+					? EXIT_SUCCESS : EXIT_FAILURE;
+
+				psql_scan_destroy(scan_state);
+			}
+			else if (cell->action == ACT_FILE)
+			{
+				successResult = process_file(cell->val, false);
+			}
+			else
+			{
+				/* should never come here */
+				Assert(0);
+			}
+
+			if (successResult != EXIT_SUCCESS && pset.on_error_stop)
+				break;
+		}
 
-	/*
-	 * If the query given to -c was a normal one, send it
-	 */
-	else if (options.action == ACT_SINGLE_QUERY)
-	{
-		if (pset.echo == PSQL_ECHO_ALL)
-			puts(options.action_string);
+		if (options.single_txn)
+		{
+			if ((res = PSQLexec("COMMIT")) == NULL)
+			{
+				if (pset.on_error_stop)
+				{
+					successResult = EXIT_USER;
+					goto error;
+				}
+			}
+			else
+				PQclear(res);
+		}
 
-		successResult = SendQuery(options.action_string)
-			? EXIT_SUCCESS : EXIT_FAILURE;
+error:
+		;
 	}
 
 	/*
@@ -332,9 +383,6 @@ main(int argc, char *argv[])
 	 */
 	else
 	{
-		if (!options.no_psqlrc)
-			process_psqlrc(argv[0]);
-
 		connection_warnings(true);
 		if (!pset.quiet)
 			printf(_("Type \"help\" for help.\n\n"));
@@ -419,14 +467,14 @@ parse_psql_options(int argc, char *argv[], struct adhoc_opts * options)
 				SetVariable(pset.vars, "ECHO", "errors");
 				break;
 			case 'c':
-				options->action_string = pg_strdup(optarg);
 				if (optarg[0] == '\\')
-				{
-					options->action = ACT_SINGLE_SLASH;
-					options->action_string++;
-				}
+					simple_action_list_append(&options->actions,
+											  ACT_SINGLE_SLASH,
+											  pstrdup(optarg + 1));
 				else
-					options->action = ACT_SINGLE_QUERY;
+					simple_action_list_append(&options->actions,
+											  ACT_SINGLE_QUERY,
+											  pstrdup(optarg));
 				break;
 			case 'd':
 				options->dbname = pg_strdup(optarg);
@@ -438,8 +486,9 @@ parse_psql_options(int argc, char *argv[], struct adhoc_opts * options)
 				SetVariableBool(pset.vars, "ECHO_HIDDEN");
 				break;
 			case 'f':
-				options->action = ACT_FILE;
-				options->action_string = pg_strdup(optarg);
+				simple_action_list_append(&options->actions,
+									ACT_FILE,
+									pg_strdup(optarg));
 				break;
 			case 'F':
 				pset.popt.topt.fieldSep.separator = pg_strdup(optarg);
@@ -452,7 +501,7 @@ parse_psql_options(int argc, char *argv[], struct adhoc_opts * options)
 				pset.popt.topt.format = PRINT_HTML;
 				break;
 			case 'l':
-				options->action = ACT_LIST_DB;
+				options->list_dbs = true;
 				break;
 			case 'L':
 				options->logfilename = pg_strdup(optarg);
@@ -675,11 +724,11 @@ process_psqlrc_file(char *filename)
 
 	/* check for minor version first, then major, then no version */
 	if (access(psqlrc_minor, R_OK) == 0)
-		(void) process_file(psqlrc_minor, false, false);
+		(void) process_file(psqlrc_minor, false);
 	else if (access(psqlrc_major, R_OK) == 0)
-		(void) process_file(psqlrc_major, false, false);
+		(void) process_file(psqlrc_major, false);
 	else if (access(filename, R_OK) == 0)
-		(void) process_file(filename, false, false);
+		(void) process_file(filename, false);
 
 	free(psqlrc_minor);
 	free(psqlrc_major);
@@ -893,6 +942,39 @@ show_context_hook(const char *newval)
 }
 
 
+/*
+ * Support for list of actions. SimpleStringList cannot be used due possible
+ * combination different actions with the requirement to save the order.
+ */
+static void
+simple_action_list_append(SimpleActionList *list, int action, const char *val)
+{
+	SimpleActionListCell   *cell;
+	size_t					vallen = 0;
+
+	if (val)
+		vallen = strlen(val);
+
+	cell = (SimpleActionListCell *)
+		pg_malloc(offsetof(SimpleActionListCell, val) + vallen + 1);
+
+	cell->next = NULL;
+	cell->action = action;
+	if (val)
+	{
+		cell->val = pg_malloc(vallen + 1);
+		strcpy(cell->val, val);
+	}
+	else
+		cell->val = NULL;
+
+	if (list->tail)
+		list->tail->next = cell;
+	else
+		list->head = cell;
+	list->tail = cell;
+}
+
 static void
 EstablishVariableSpace(void)
 {

diff --git a/doc/src/sgml/ref/psql-ref.sgml b/doc/src/sgml/ref/psql-ref.sgml
index e4f72a8..47e9da2 100644
--- a/doc/src/sgml/ref/psql-ref.sgml
+++ b/doc/src/sgml/ref/psql-ref.sgml
@@ -38,9 +38,10 @@ PostgreSQL documentation
      <productname>PostgreSQL</productname>. It enables you to type in
      queries interactively, issue them to
      <productname>PostgreSQL</productname>, and see the query results.
-     Alternatively, input can be from a file. In addition, it provides a
-     number of meta-commands and various shell-like features to
-     facilitate writing scripts and automating a wide variety of tasks.
+     Alternatively, input can be from a file or from command line
+     arguments. In addition, it provides a number of meta-commands and various
+     shell-like features to facilitate writing scripts and automating a wide
+     variety of tasks.
     </para>
  </refsect1>
 
@@ -89,11 +90,10 @@ PostgreSQL documentation
       <term><option>--command=<replaceable class="parameter">command</replaceable></></term>
       <listitem>
       <para>
-      Specifies that <application>psql</application> is to execute one
-      command string, <replaceable class="parameter">command</replaceable>,
-      and then exit. This is useful in shell scripts. Start-up files
-      (<filename>psqlrc</filename> and <filename>~/.psqlrc</filename>) are
-      ignored with this option.
+      Specifies that <application>psql</application> is to execute the given
+      command string, <replaceable class="parameter">command</replaceable>.
+      This option can be repeated and combined in any order with
+      the <option>-f</option> option.
       </para>
       <para>
       <replaceable class="parameter">command</replaceable> must be either
@@ -102,25 +102,34 @@ PostgreSQL documentation
       or a single backslash command. Thus you cannot mix
       <acronym>SQL</acronym> and <application>psql</application>
       meta-commands with this option. To achieve that, you could
-      pipe the string into <application>psql</application>, for example:
+      use repeated <option>-c</option> options or pipe the string
+      into <application>psql</application>, for example:
+      <literal>psql -c '\x' -c 'SELECT * FROM foo;'</literal> or
       <literal>echo '\x \\ SELECT * FROM foo;' | psql</literal>.
       (<literal>\\</> is the separator meta-command.)
       </para>
       <para>
-       If the command string contains multiple SQL commands, they are
-       processed in a single transaction, unless there are explicit
-       <command>BEGIN</>/<command>COMMIT</> commands included in the
-       string to divide it into multiple transactions.  This is
-       different from the behavior when the same string is fed to
-       <application>psql</application>'s standard input.  Also, only
-       the result of the last SQL command is returned.
+       Each command string passed to <option>-c</option> is sent to the server
+       as a single query. Because of this, the server executes it as a single
+       transaction, even if a command string contains
+       multiple <acronym>SQL</acronym> commands, unless there are
+       explicit <command>BEGIN</>/<command>COMMIT</> commands included in the
+       string to divide it into multiple transactions.  Also, the server only
+       returns the result of the last <acronym>SQL</acronym> command to the
+       client.  This is different from the behavior when the same string with
+       multiple <acronym>SQL</acronym> commands is fed
+       to <application>psql</application>'s standard input because
+       then <application>psql</application> sends each <acronym>SQL</acronym>
+       command separately.
       </para>
       <para>
-       Because of these legacy behaviors, putting more than one command in
-       the <option>-c</option> string often has unexpected results.  It's
-       better to feed multiple commands to <application>psql</application>'s
-       standard input, either using <application>echo</application> as
-       illustrated above, or via a shell here-document, for example:
+       Putting more than one command in the <option>-c</option> string often
+       has unexpected results.  This is a result of the fact that the whole
+       string is sent to the server as a single query.
+       It's better to use repeated <option>-c</option> commands or feed
+       multiple commands to <application>psql</application>'s standard input,
+       either using <application>echo</application> as illustrated above, or
+       via a shell here-document, for example:
 <programlisting>
 psql &lt;&lt;EOF
 \x
@@ -185,9 +194,11 @@ EOF
       <para>
       Use the file <replaceable class="parameter">filename</replaceable>
       as the source of commands instead of reading commands interactively.
-      After the file is processed, <application>psql</application>
-      terminates. This is in many ways equivalent to the meta-command
-      <command>\i</command>.
+      This option can be repeated and combined in any order with
+      the <option>-c</option> option.  After the commands in
+      every <option>-c</option> command string and <option>-f</option> file
+      are processed, <application>psql</application> terminates.  This option
+      is in many ways equivalent to the meta-command <command>\i</command>.
       </para>
 
       <para>
@@ -539,20 +550,21 @@ EOF
       <term><option>--single-transaction</option></term>
       <listitem>
        <para>
-        When <application>psql</application> executes a script, adding
-        this option wraps <command>BEGIN</>/<command>COMMIT</> around the
-        script to execute it as a single transaction.  This ensures that
-        either all the commands complete successfully, or no changes are
-        applied.
+        When <application>psql</application> executes commands from a script
+        and/or a <option>-c</option> option, adding this option
+        wraps <command>BEGIN</>/<command>COMMIT</> around all of those
+        commands as a whole to execute them as a single transaction.  This
+        ensures that either all the commands complete successfully, or no
+        changes are applied.
        </para>
 
        <para>
-        If the script itself uses <command>BEGIN</>, <command>COMMIT</>,
+        If the commands themselves
+        contain <command>BEGIN</>, <command>COMMIT</>,
         or <command>ROLLBACK</>, this option will not have the desired
-        effects.
-        Also, if the script contains any command that cannot be executed
-        inside a transaction block, specifying this option will cause that
-        command (and hence the whole transaction) to fail.
+        effects.  Also, if an individual command cannot be executed inside a
+        transaction block, specifying this option will cause the whole
+        transaction to fail.
        </para>
       </listitem>
      </varlistentry>
@@ -3725,7 +3737,7 @@ PSQL_EDITOR_LINENUMBER_ARG='--line '
    <term><filename>psqlrc</filename> and <filename>~/.psqlrc</filename></term>
    <listitem>
     <para>
-     Unless it is passed an <option>-X</option> or <option>-c</option> option,
+     Unless it is passed an <option>-X</option> option,
      <application>psql</application> attempts to read and execute commands
      from the system-wide startup file (<filename>psqlrc</filename>) and then
      the user's personal startup file (<filename>~/.psqlrc</filename>), after
@@ -3819,6 +3831,12 @@ PSQL_EDITOR_LINENUMBER_ARG='--line '
       </para>
       </listitem>
 
+      <listitem>
+      <para>
+       Before <productname>PostgreSQL</productname> 9.6, <option>-c</option>
+       implied <option>-X</option>; this is no longer the case.
+      </para>
+      </listitem>
     </itemizedlist>
  </refsect1>
 
diff --git a/src/bin/psql/command.c b/src/bin/psql/command.c
index 6e8c623..cf6876b 100644
--- a/src/bin/psql/command.c
+++ b/src/bin/psql/command.c
@@ -916,7 +916,7 @@ exec_command(const char *cmd,
 			include_relative = (strcmp(cmd, "ir") == 0
 								|| strcmp(cmd, "include_relative") == 0);
 			expand_tilde(&fname);
-			success = (process_file(fname, false, include_relative) == EXIT_SUCCESS);
+			success = (process_file(fname, include_relative) == EXIT_SUCCESS);
 			free(fname);
 		}
 	}
@@ -2288,13 +2288,12 @@ do_edit(const char *filename_arg, PQExpBuffer query_buf,
  * the file from where the currently processed file (if any) is located.
  */
 int
-process_file(char *filename, bool single_txn, bool use_relative_path)
+process_file(char *filename, bool use_relative_path)
 {
 	FILE	   *fd;
 	int			result;
 	char	   *oldfilename;
 	char		relpath[MAXPGPATH];
-	PGresult   *res;
 
 	if (!filename)
 	{
@@ -2339,37 +2338,8 @@ process_file(char *filename, bool single_txn, bool use_relative_path)
 	oldfilename = pset.inputfile;
 	pset.inputfile = filename;
 
-	if (single_txn)
-	{
-		if ((res = PSQLexec("BEGIN")) == NULL)
-		{
-			if (pset.on_error_stop)
-			{
-				result = EXIT_USER;
-				goto error;
-			}
-		}
-		else
-			PQclear(res);
-	}
-
 	result = MainLoop(fd);
 
-	if (single_txn)
-	{
-		if ((res = PSQLexec("COMMIT")) == NULL)
-		{
-			if (pset.on_error_stop)
-			{
-				result = EXIT_USER;
-				goto error;
-			}
-		}
-		else
-			PQclear(res);
-	}
-
-error:
 	if (fd != stdin)
 		fclose(fd);
 
diff --git a/src/bin/psql/command.h b/src/bin/psql/command.h
index 54385e8..c817600 100644
--- a/src/bin/psql/command.h
+++ b/src/bin/psql/command.h
@@ -27,7 +27,7 @@ typedef enum _backslashResult
 extern backslashResult HandleSlashCmds(PsqlScanState scan_state,
 				PQExpBuffer query_buf);
 
-extern int	process_file(char *filename, bool single_txn, bool use_relative_path);
+extern int	process_file(char *filename, bool use_relative_path);
 
 extern bool do_pset(const char *param,
 		const char *value,
diff --git a/src/bin/psql/startup.c b/src/bin/psql/startup.c
index 4e5021a..7af38fb 100644
--- a/src/bin/psql/startup.c
+++ b/src/bin/psql/startup.c
@@ -50,13 +50,24 @@ PsqlSettings pset;
  */
 enum _actions
 {
-	ACT_NOTHING = 0,
-	ACT_SINGLE_SLASH,
-	ACT_LIST_DB,
 	ACT_SINGLE_QUERY,
+	ACT_SINGLE_SLASH,
 	ACT_FILE
 };
 
+typedef struct SimpleActionListCell
+{
+	struct SimpleActionListCell *next;
+	int         action;
+	char       *val;
+} SimpleActionListCell;
+
+typedef struct SimpleActionList
+{
+	SimpleActionListCell *head;
+	SimpleActionListCell *tail;
+} SimpleActionList;
+
 struct adhoc_opts
 {
 	char	   *dbname;
@@ -64,11 +75,11 @@ struct adhoc_opts
 	char	   *port;
 	char	   *username;
 	char	   *logfilename;
-	enum _actions action;
-	char	   *action_string;
 	bool		no_readline;
 	bool		no_psqlrc;
 	bool		single_txn;
+	bool		list_dbs;
+	SimpleActionList actions;
 };
 
 static void parse_psql_options(int argc, char *argv[],
@@ -76,6 +87,8 @@ static void parse_psql_options(int argc, char *argv[],
 static void process_psqlrc(char *argv0);
 static void process_psqlrc_file(char *filename);
 static void showVersion(void);
+static void simple_action_list_append(SimpleActionList *list,
+									  int action, const char *val);
 static void EstablishVariableSpace(void);
 
 #define NOPAGER		0
@@ -159,6 +172,9 @@ main(int argc, char *argv[])
 	SetVariable(pset.vars, "PROMPT2", DEFAULT_PROMPT2);
 	SetVariable(pset.vars, "PROMPT3", DEFAULT_PROMPT3);
 
+	options.actions.head = NULL;
+	options.actions.tail = NULL;
+
 	parse_psql_options(argc, argv, &options);
 
 	/*
@@ -166,14 +182,11 @@ main(int argc, char *argv[])
 	 * as if the user had specified "-f -".  This lets single-transaction mode
 	 * work in this case.
 	 */
-	if (options.action == ACT_NOTHING && pset.notty)
-	{
-		options.action = ACT_FILE;
-		options.action_string = NULL;
-	}
+	if (options.actions.head == NULL && pset.notty)
+		simple_action_list_append(&options.actions, ACT_FILE, NULL);
 
 	/* Bail out if -1 was specified but will be ignored. */
-	if (options.single_txn && options.action != ACT_FILE && options.action == ACT_NOTHING)
+	if (options.single_txn && options.actions.head == NULL)
 	{
 		fprintf(stderr, _("%s: -1 can only be used in non-interactive mode\n"), pset.progname);
 		exit(EXIT_FAILURE);
@@ -217,8 +230,7 @@ main(int argc, char *argv[])
 		keywords[3] = "password";
 		values[3] = password;
 		keywords[4] = "dbname";
-		values[4] = (options.action == ACT_LIST_DB &&
-					 options.dbname == NULL) ?
+		values[4] = (options.list_dbs && options.dbname == NULL) ?
 			"postgres" : options.dbname;
 		keywords[5] = "fallback_application_name";
 		values[5] = pset.progname;
@@ -259,7 +271,7 @@ main(int argc, char *argv[])
 
 	SyncVariables();
 
-	if (options.action == ACT_LIST_DB)
+	if (options.list_dbs)
 	{
 		int			success;
 
@@ -279,52 +291,91 @@ main(int argc, char *argv[])
 					pset.progname, options.logfilename, strerror(errno));
 	}
 
-	/*
-	 * Now find something to do
-	 */
+	if (!options.no_psqlrc)
+		process_psqlrc(argv[0]);
 
 	/*
-	 * process file given by -f
+	 * If any actions were given by caller, process them in the order in
+	 * which they were specified.
 	 */
-	if (options.action == ACT_FILE)
+	if (options.actions.head != NULL)
 	{
-		if (!options.no_psqlrc)
-			process_psqlrc(argv[0]);
+		PGresult		*res;
+		SimpleActionListCell	*cell;
 
-		successResult = process_file(options.action_string, options.single_txn, false);
-	}
+		successResult = EXIT_SUCCESS;	/* silence compiler */
 
-	/*
-	 * process slash command if one was given to -c
-	 */
-	else if (options.action == ACT_SINGLE_SLASH)
-	{
-		PsqlScanState scan_state;
-
-		if (pset.echo == PSQL_ECHO_ALL)
-			puts(options.action_string);
-
-		scan_state = psql_scan_create();
-		psql_scan_setup(scan_state,
-						options.action_string,
-						strlen(options.action_string));
-
-		successResult = HandleSlashCmds(scan_state, NULL) != PSQL_CMD_ERROR
-			? EXIT_SUCCESS : EXIT_FAILURE;
+		if (options.single_txn)
+		{
+			if ((res = PSQLexec("BEGIN")) == NULL)
+			{
+				if (pset.on_error_stop)
+				{
+					successResult = EXIT_USER;
+					goto error;
+				}
+			}
+			else
+				PQclear(res);
+		}
 
-		psql_scan_destroy(scan_state);
-	}
+		for (cell = options.actions.head; cell; cell = cell->next)
+		{
+			if (cell->action == ACT_SINGLE_QUERY)
+			{
+				if (pset.echo == PSQL_ECHO_ALL)
+					puts(cell->val);
+
+				successResult = SendQuery(cell->val)
+					? EXIT_SUCCESS : EXIT_FAILURE;
+			}
+			else if (cell->action == ACT_SINGLE_SLASH)
+			{
+				PsqlScanState scan_state;
+
+				if (pset.echo == PSQL_ECHO_ALL)
+					puts(cell->val);
+
+				scan_state = psql_scan_create();
+				psql_scan_setup(scan_state,
+							cell->val,
+							strlen(cell->val));
+
+				successResult = HandleSlashCmds(scan_state, NULL) != PSQL_CMD_ERROR
+					? EXIT_SUCCESS : EXIT_FAILURE;
+
+				psql_scan_destroy(scan_state);
+			}
+			else if (cell->action == ACT_FILE)
+			{
+				successResult = process_file(cell->val, false);
+			}
+			else
+			{
+				/* should never come here */
+				Assert(0);
+			}
+
+			if (successResult != EXIT_SUCCESS && pset.on_error_stop)
+				break;
+		}
 
-	/*
-	 * If the query given to -c was a normal one, send it
-	 */
-	else if (options.action == ACT_SINGLE_QUERY)
-	{
-		if (pset.echo == PSQL_ECHO_ALL)
-			puts(options.action_string);
+		if (options.single_txn)
+		{
+			if ((res = PSQLexec("COMMIT")) == NULL)
+			{
+				if (pset.on_error_stop)
+				{
+					successResult = EXIT_USER;
+					goto error;
+				}
+			}
+			else
+				PQclear(res);
+		}
 
-		successResult = SendQuery(options.action_string)
-			? EXIT_SUCCESS : EXIT_FAILURE;
+error:
+		;
 	}
 
 	/*
@@ -332,9 +383,6 @@ main(int argc, char *argv[])
 	 */
 	else
 	{
-		if (!options.no_psqlrc)
-			process_psqlrc(argv[0]);
-
 		connection_warnings(true);
 		if (!pset.quiet)
 			printf(_("Type \"help\" for help.\n\n"));
@@ -419,14 +467,14 @@ parse_psql_options(int argc, char *argv[], struct adhoc_opts * options)
 				SetVariable(pset.vars, "ECHO", "errors");
 				break;
 			case 'c':
-				options->action_string = pg_strdup(optarg);
 				if (optarg[0] == '\\')
-				{
-					options->action = ACT_SINGLE_SLASH;
-					options->action_string++;
-				}
+					simple_action_list_append(&options->actions,
+											  ACT_SINGLE_SLASH,
+											  pstrdup(optarg + 1));
 				else
-					options->action = ACT_SINGLE_QUERY;
+					simple_action_list_append(&options->actions,
+											  ACT_SINGLE_QUERY,
+											  pstrdup(optarg));
 				break;
 			case 'd':
 				options->dbname = pg_strdup(optarg);
@@ -438,8 +486,9 @@ parse_psql_options(int argc, char *argv[], struct adhoc_opts * options)
 				SetVariableBool(pset.vars, "ECHO_HIDDEN");
 				break;
 			case 'f':
-				options->action = ACT_FILE;
-				options->action_string = pg_strdup(optarg);
+				simple_action_list_append(&options->actions,
+									ACT_FILE,
+									pg_strdup(optarg));
 				break;
 			case 'F':
 				pset.popt.topt.fieldSep.separator = pg_strdup(optarg);
@@ -452,7 +501,7 @@ parse_psql_options(int argc, char *argv[], struct adhoc_opts * options)
 				pset.popt.topt.format = PRINT_HTML;
 				break;
 			case 'l':
-				options->action = ACT_LIST_DB;
+				options->list_dbs = true;
 				break;
 			case 'L':
 				options->logfilename = pg_strdup(optarg);
@@ -675,11 +724,11 @@ process_psqlrc_file(char *filename)
 
 	/* check for minor version first, then major, then no version */
 	if (access(psqlrc_minor, R_OK) == 0)
-		(void) process_file(psqlrc_minor, false, false);
+		(void) process_file(psqlrc_minor, false);
 	else if (access(psqlrc_major, R_OK) == 0)
-		(void) process_file(psqlrc_major, false, false);
+		(void) process_file(psqlrc_major, false);
 	else if (access(filename, R_OK) == 0)
-		(void) process_file(filename, false, false);
+		(void) process_file(filename, false);
 
 	free(psqlrc_minor);
 	free(psqlrc_major);
@@ -893,6 +942,39 @@ show_context_hook(const char *newval)
 }
 
 
+/*
+ * Support for list of actions. SimpleStringList cannot be used due possible
+ * combination different actions with the requirement to save the order.
+ */
+static void
+simple_action_list_append(SimpleActionList *list, int action, const char *val)
+{
+	SimpleActionListCell   *cell;
+	size_t					vallen = 0;
+
+	if (val)
+		vallen = strlen(val);
+
+	cell = (SimpleActionListCell *)
+		pg_malloc(offsetof(SimpleActionListCell, val) + vallen + 1);
+
+	cell->next = NULL;
+	cell->action = action;
+	if (val)
+	{
+		cell->val = pg_malloc(vallen + 1);
+		strcpy(cell->val, val);
+	}
+	else
+		cell->val = NULL;
+
+	if (list->tail)
+		list->tail->next = cell;
+	else
+		list->head = cell;
+	list->tail = cell;
+}
+
 static void
 EstablishVariableSpace(void)
 {
diff --git a/src/test/perl/PostgresNode.pm b/src/test/perl/PostgresNode.pm
index aa7a00c..0ac1846 100644
--- a/src/test/perl/PostgresNode.pm
+++ b/src/test/perl/PostgresNode.pm
@@ -404,7 +404,7 @@ sub poll_query_until
 	while ($attempts < $max_attempts)
 	{
 		my $cmd =
-		  [ 'psql', '-At', '-c', $query, '-d', $self->connstr($dbname) ];
+		  [ 'psql', '-XAt', '-c', $query, '-d', $self->connstr($dbname) ];
 		my $result = IPC::Run::run $cmd, '>', \$stdout, '2>', \$stderr;
 
 		chomp($stdout);