pg.ddx.io  pgsql-hackers@postgresql.org mailing list archive  

help / color / mirror / Atom feed

\if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
232+ messages / 12 participants
[nested] [flat]

* \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-01-22 23:56  Corey Huinker <corey.huinker@gmail.com>
  0 siblings, 1 reply; 232+ messages in thread

From: Corey Huinker @ 2017-01-22 23:56 UTC (permalink / raw)
  To: Michael Paquier <michael.paquier@gmail.com>; +Cc: Robert Haas <robertmhaas@gmail.com>; Tom Lane <tgl@sss.pgh.pa.us>; Pavel Stehule <pavel.stehule@gmail.com>; David G. Johnston <david.g.johnston@gmail.com>; Alvaro Herrera <alvherre@2ndquadrant.com>; Fabien COELHO <coelho@cri.ensmp.fr>; Andrew Dunstan <andrew@dunslane.net>; pgsql-hackers

>
>
> Fabien is pressed for time, so I've been speaking with him out-of-thread
> about how I should go about implementing it.
>
> The v1 patch will be \if <expr>, \elseif <expr>, \else, \endif, where
> <expr> will be naively evaluated via ParseVariableBool().
>
> \ifs and \endifs must be in the same "file" (each MainLoop will start a
> new if-stack). This is partly for sanity (you can see the pairings unless
> the programmer is off in \gset meta-land), partly for ease  of design (data
> structures live in MainLoop), but mostly because it would an absolute
> requirement if we ever got around to doing \while.
>
> I hope to have something ready for the next commitfest.
>
> As for the fate of \quit_if, I can see it both ways. On the one hand,
> it's super-simple, already written, and handy.
>
> On the other hand, it's easily replaced by
>
> \if <expr>
>     \q
> \endif
>
>
> So I'll leave that as a separate reviewable patch.
>
> As for loops, I don't think anyone was pushing for implementing \while
> now, only to have a decision about what it would look like and how it would
> work. There's a whole lot of recording infrastructure (the input could be a
> stream) needed to make it happen. Moreover, I think \gexec scratched a
> lot of the itches that would have been solved via a psql looping structure.
>


And here's the patch. I've changed the subject line and will be submitting
a new entry to the commitfest.
diff --git a/doc/src/sgml/ref/psql-ref.sgml b/doc/src/sgml/ref/psql-ref.sgml
index 9915731..2c3fccd 100644
--- a/doc/src/sgml/ref/psql-ref.sgml
+++ b/doc/src/sgml/ref/psql-ref.sgml
@@ -2007,6 +2007,83 @@ hello 10
         </listitem>
       </varlistentry>
 
+      <varlistentry>
+        <term><literal>\if</literal> <replaceable class="parameter">expr</replaceable></term>
+        <term><literal>\elseif</literal> <replaceable class="parameter">expr</replaceable></term>
+        <term><literal>\else</literal></term>
+        <term><literal>\endif</literal></term>
+        <listitem>
+        <para>
+        This group of commands implements nestable conditional blocks, like
+        this:
+        </para>
+<programlisting>
+\if true
+    \if 1
+        \if yes
+            \if on
+                \echo 'all true'
+all true
+            \endif
+        \endif
+    \endif
+\endif
+\if false
+\elseif 0
+\elseif no
+\elseif off
+\else
+    \echo 'all false'
+all false
+\endif
+\if true
+\else
+    \echo 'should not print #1'
+\endif
+\if false
+\elseif true
+\else
+    \echo 'should not print #2'
+\endif
+</programlisting>
+        <para>
+        Conditional blocks must begin with a <command>\if</command> and end
+        with an <command>\endif</command>, and the pairs must be found in
+        the same source file. If an EOF is reached on the main file or an
+        <command>\include</command>-ed file before all 
+        <command>\if</command>-<command>\endif</command> are matched, then
+        psql will raise an error.
+        </para>
+        <para>
+        The <command>\if</command> and <command>\elseif</command> commands
+        read the rest of the line and evaluate it as a boolean expression.
+        Currently, expressions are limited to the same values allowed for
+        other option booleans (true, false, 1, 0, on, off, yes, no, etc).
+        </para>
+        <para>
+        Queries within a false branch of a conditional block will not be
+        sent to the server.
+        </para>
+        <para>
+        Non-conditional <command>\</command>-commands within a false branch
+        of a conditional block will not be evaluated for correctness. The
+        command will be ignored along with all remaining input to the end
+        of the line.
+        </para>
+        <para>
+        Expressions on <command>\if</command> and <command>\elseif</command>
+        commands within a false branch of a conditional block will not be
+        evaluated.
+        </para>
+        <para>
+        A conditional block can at most one <command>\else</command> command.
+        </para>
+        <para>
+        The <command>\elseif</command> command cannot follow the
+        <command>\else</command> command.
+        </para>
+        </listitem>
+      </varlistentry>
 
       <varlistentry>
         <term><literal>\ir</literal> or <literal>\include_relative</literal> <replaceable class="parameter">filename</replaceable></term>
diff --git a/src/bin/psql/command.c b/src/bin/psql/command.c
index 4139b77..d4e0bb8 100644
--- a/src/bin/psql/command.c
+++ b/src/bin/psql/command.c
@@ -49,6 +49,7 @@
 #include "psqlscanslash.h"
 #include "settings.h"
 #include "variables.h"
+#include "fe_utils/psqlscan_int.h"
 
 /*
  * Editable database object types.
@@ -132,7 +133,7 @@ HandleSlashCmds(PsqlScanState scan_state,
 		status = PSQL_CMD_ERROR;
 	}
 
-	if (status != PSQL_CMD_ERROR)
+	if ((status != PSQL_CMD_ERROR) && psqlscan_branch_active(scan_state))
 	{
 		/* eat any remaining arguments after a valid command */
 		/* note we suppress evaluation of backticks here */
@@ -194,6 +195,32 @@ read_connect_arg(PsqlScanState scan_state)
 	return result;
 }
 
+/*
+ * Read and interpret argument as a boolean expression.
+ */
+static bool
+read_boolean_expression(PsqlScanState scan_state, const char *action)
+{
+	bool	result = false;
+	char	*expr = psql_scan_slash_option(scan_state,
+											OT_NORMAL, NULL, false);
+	if (expr)
+	{
+		if (ParseVariableBool(expr, action))
+			result = true;
+		free(expr);
+	}
+	return result;
+}
+
+static bool
+is_branching_command(const char *cmd)
+{
+	return ((strcmp(cmd, "if") == 0 || \
+			strcmp(cmd, "elseif") == 0 || \
+			strcmp(cmd, "else") == 0 || \
+			strcmp(cmd, "endif") == 0));
+}
 
 /*
  * Subroutine to actually try to execute a backslash command.
@@ -207,6 +234,14 @@ exec_command(const char *cmd,
 								 * failed */
 	backslashResult status = PSQL_CMD_SKIP_LINE;
 
+	if (!psqlscan_branch_active(scan_state) && !is_branching_command(cmd) )
+	{
+		/* Continue with an empty buffer as if the command were never read */
+		resetPQExpBuffer(query_buf); /* TODO: is this needed? */
+		psql_scan_reset(scan_state); /* TODO: is this needed or just for interactive? */
+		return status;
+	}
+
 	/*
 	 * \a -- toggle field alignment This makes little sense but we keep it
 	 * around.
@@ -984,6 +1019,84 @@ exec_command(const char *cmd,
 		}
 	}
 
+	else if (strcmp(cmd, "if") == 0)
+	{
+		ifState new_if_state = IFSTATE_IGNORED;
+		if (psqlscan_branch_active(scan_state))
+		{
+			if (read_boolean_expression(scan_state, "\\if"))
+				new_if_state = IFSTATE_TRUE;
+			else
+				new_if_state = IFSTATE_FALSE;
+		}
+		psqlscan_branch_push(scan_state,new_if_state);
+		psql_scan_reset(scan_state);
+	}
+
+	else if (strcmp(cmd, "elseif") == 0)
+	{
+		if (psqlscan_branch_empty(scan_state))
+			psql_error("encountered un-matched \\elseif\n");
+
+		switch (psqlscan_branch_get_state(scan_state))
+		{
+			case IFSTATE_IGNORED:
+				/* inactive branch, do nothing */
+				break;
+			case IFSTATE_TRUE:
+				/* just finished true section of active branch */
+				psqlscan_branch_set_state(scan_state, IFSTATE_IGNORED);
+				break;
+			case IFSTATE_FALSE:
+				/* determine if this section is true or not */
+				if (read_boolean_expression(scan_state, "\\elseif"))
+					psqlscan_branch_set_state(scan_state, IFSTATE_TRUE);
+				break;
+			case IFSTATE_ELSE_TRUE:
+			case IFSTATE_ELSE_FALSE:
+				psql_error("encountered \\elseif after \\else\n");
+				break;
+			default:
+				break;
+		}
+		psql_scan_reset(scan_state);
+	}
+
+	else if (strcmp(cmd, "else") == 0)
+	{
+		if (psqlscan_branch_empty(scan_state))
+			psql_error("encountered un-matched \\else\n");
+
+		switch (psqlscan_branch_get_state(scan_state))
+		{
+			case IFSTATE_TRUE:
+				/* just finished true section of active branch */
+			case IFSTATE_IGNORED:
+				/* whole branch was inactive */
+				psqlscan_branch_set_state(scan_state, IFSTATE_ELSE_FALSE);
+				break;
+			case IFSTATE_FALSE:
+				/* just finished true section of active branch */
+				psqlscan_branch_set_state(scan_state, IFSTATE_ELSE_TRUE);
+				break;
+			case IFSTATE_ELSE_TRUE:
+			case IFSTATE_ELSE_FALSE:
+				psql_error("encountered \\else after \\else\n");
+				break;
+			default:
+				break;
+		}
+		psql_scan_reset(scan_state);
+	}
+
+	else if (strcmp(cmd, "endif") == 0)
+	{
+		if (psqlscan_branch_empty(scan_state))
+			psql_error("encountered un-matched \\endif\n");
+		psqlscan_branch_end_state(scan_state);
+		psql_scan_reset(scan_state);
+	}
+
 	/* \l is list databases */
 	else if (strcmp(cmd, "l") == 0 || strcmp(cmd, "list") == 0 ||
 			 strcmp(cmd, "l+") == 0 || strcmp(cmd, "list+") == 0)
diff --git a/src/bin/psql/mainloop.c b/src/bin/psql/mainloop.c
index bb306a4..8f12e55 100644
--- a/src/bin/psql/mainloop.c
+++ b/src/bin/psql/mainloop.c
@@ -15,7 +15,7 @@
 #include "settings.h"
 
 #include "mb/pg_wchar.h"
-
+#include "fe_utils/psqlscan_int.h"
 
 /* callback functions for our flex lexer */
 const PsqlScanCallbacks psqlscan_callbacks = {
@@ -23,7 +23,6 @@ const PsqlScanCallbacks psqlscan_callbacks = {
 	psql_error
 };
 
-
 /*
  * Main processing loop for reading lines of input
  *	and sending them to the backend.
@@ -51,6 +50,9 @@ MainLoop(FILE *source)
 	volatile int count_eof = 0;
 	volatile bool die_on_error = false;
 
+	/* only needed at the end to detect unbalanced ifs in scan_state */
+	bool if_endifs_balanced = true;
+
 	/* Save the prior command source */
 	FILE	   *prev_cmd_source;
 	bool		prev_cmd_interactive;
@@ -285,21 +287,28 @@ MainLoop(FILE *source)
 			if (scan_result == PSCAN_SEMICOLON ||
 				(scan_result == PSCAN_EOL && pset.singleline))
 			{
-				/*
-				 * Save query in history.  We use history_buf to accumulate
-				 * multi-line queries into a single history entry.
-				 */
-				if (pset.cur_cmd_interactive && !line_saved_in_history)
+				if (psqlscan_branch_active(scan_state))
 				{
-					pg_append_history(line, history_buf);
-					pg_send_history(history_buf);
-					line_saved_in_history = true;
+					/*
+					 * Save query in history.  We use history_buf to accumulate
+					 * multi-line queries into a single history entry.
+					 */
+					if (pset.cur_cmd_interactive && !line_saved_in_history)
+					{
+						pg_append_history(line, history_buf);
+						pg_send_history(history_buf);
+						line_saved_in_history = true;
+					}
+
+					/* execute query */
+					success = SendQuery(query_buf->data);
 				}
+				else
+					success = true;
 
-				/* execute query */
-				success = SendQuery(query_buf->data);
 				slashCmdStatus = success ? PSQL_CMD_SEND : PSQL_CMD_ERROR;
 				pset.stmt_lineno = 1;
+				slashCmdStatus = success ? PSQL_CMD_SEND : PSQL_CMD_ERROR;
 
 				/* transfer query to previous_buf by pointer-swapping */
 				{
@@ -352,21 +361,28 @@ MainLoop(FILE *source)
 				if ((slashCmdStatus == PSQL_CMD_SEND || slashCmdStatus == PSQL_CMD_NEWEDIT) &&
 					query_buf->len == 0)
 				{
+					/* TODO check if-then-skip-state */
 					/* copy previous buffer to current for handling */
 					appendPQExpBufferStr(query_buf, previous_buf->data);
 				}
 
 				if (slashCmdStatus == PSQL_CMD_SEND)
 				{
-					success = SendQuery(query_buf->data);
-
-					/* transfer query to previous_buf by pointer-swapping */
+					if (psqlscan_branch_active(scan_state))
 					{
-						PQExpBuffer swap_buf = previous_buf;
+						success = SendQuery(query_buf->data);
 
-						previous_buf = query_buf;
-						query_buf = swap_buf;
+						/* transfer query to previous_buf by pointer-swapping */
+						{
+							PQExpBuffer swap_buf = previous_buf;
+
+							previous_buf = query_buf;
+							query_buf = swap_buf;
+						}
 					}
+					else
+						success = true;
+
 					resetPQExpBuffer(query_buf);
 
 					/* flush any paren nesting info after forced send */
@@ -425,12 +441,17 @@ MainLoop(FILE *source)
 	if (query_buf->len > 0 && !pset.cur_cmd_interactive &&
 		successResult == EXIT_SUCCESS)
 	{
-		/* save query in history */
-		if (pset.cur_cmd_interactive)
-			pg_send_history(history_buf);
+		if (psqlscan_branch_active(scan_state))
+		{
+			/* save query in history */
+			if (pset.cur_cmd_interactive)
+				pg_send_history(history_buf);
 
-		/* execute query */
-		success = SendQuery(query_buf->data);
+			/* execute query */
+			success = SendQuery(query_buf->data);
+		}
+		else
+			success = true;
 
 		if (!success && die_on_error)
 			successResult = EXIT_USER;
@@ -451,11 +472,17 @@ MainLoop(FILE *source)
 	destroyPQExpBuffer(previous_buf);
 	destroyPQExpBuffer(history_buf);
 
+	if (slashCmdStatus != PSQL_CMD_TERMINATE)
+		if_endifs_balanced = psqlscan_branch_empty(scan_state);
+
 	psql_scan_destroy(scan_state);
 
 	pset.cur_cmd_source = prev_cmd_source;
 	pset.cur_cmd_interactive = prev_cmd_interactive;
 	pset.lineno = prev_lineno;
 
+	if (! if_endifs_balanced )
+		psql_error("found EOF before closing \\endif(s)\n");
+
 	return successResult;
 }	/* MainLoop() */
diff --git a/src/bin/psql/mainloop.h b/src/bin/psql/mainloop.h
index 228a5e0..47f4c32 100644
--- a/src/bin/psql/mainloop.h
+++ b/src/bin/psql/mainloop.h
@@ -14,4 +14,5 @@ extern const PsqlScanCallbacks psqlscan_callbacks;
 
 extern int	MainLoop(FILE *source);
 
+
 #endif   /* MAINLOOP_H */
diff --git a/src/fe_utils/psqlscan.l b/src/fe_utils/psqlscan.l
index 1b29341..881c4f8 100644
--- a/src/fe_utils/psqlscan.l
+++ b/src/fe_utils/psqlscan.l
@@ -904,6 +904,9 @@ psql_scan_create(const PsqlScanCallbacks *callbacks)
 
 	psql_scan_reset(state);
 
+	state->branch_stack = NULL;
+	state->branch_block_active = true;
+
 	return state;
 }
 
@@ -919,6 +922,13 @@ psql_scan_destroy(PsqlScanState state)
 
 	yylex_destroy(state->scanner);
 
+	while (state->branch_stack != NULL)
+	{
+		IfStackElem *p = state->branch_stack;
+		state->branch_stack = state->branch_stack->next;
+		free(p);
+	}
+
 	free(state);
 }
 
@@ -1426,3 +1436,103 @@ psqlscan_escape_variable(PsqlScanState state, const char *txt, int len,
 		psqlscan_emit(state, txt, len);
 	}
 }
+
+/*
+ * psqlscan_branch_empty
+ *
+ * True if there are no active \if-structures
+ */
+bool
+psqlscan_branch_empty(PsqlScanState state)
+{
+	return (state->branch_stack == NULL);
+}
+
+/*
+ * psqlscan_branch_active
+ *
+ * True if the current \if-block (if any) is true and queries/commands
+ * should be executed.
+ */
+bool
+psqlscan_branch_active(PsqlScanState state)
+{
+	return state->branch_block_active;
+}
+
+/*
+ * Fetch the current state of the top of the stack
+ */
+ifState
+psqlscan_branch_get_state(PsqlScanState state)
+{
+	if (psqlscan_branch_empty(state))
+		return IFSTATE_NONE;
+	return state->branch_stack->if_state;
+}
+
+/*
+ * psqlscan_branch_update_active
+ *
+ * Scan the branch_stack to determine whether the next statements
+ * can execute or should be skipped. Cache this result in
+ * branch_block_active.
+ */
+static void
+psqlscan_branch_update_active(PsqlScanState state)
+{
+	ifState s = psqlscan_branch_get_state(state);
+	state->branch_block_active  = ( (s == IFSTATE_NONE) ||
+									(s == IFSTATE_TRUE) ||
+									(s == IFSTATE_ELSE_TRUE));
+}
+
+/*
+ * psqlscan_branch_push
+ *
+ * Create a new \if branch.
+ */
+bool
+psqlscan_branch_push(PsqlScanState state, ifState new_state)
+{
+	IfStackElem *p = pg_malloc0(sizeof(IfStackElem));
+	p->if_state = new_state;
+	p->next = state->branch_stack;
+	state->branch_stack = p;
+	psqlscan_branch_update_active(state);
+	return true;
+}
+
+/*
+ * psqlscan_branch_set_state
+ *
+ * Change the state of the topmost branch.
+ * Returns false if there was branch state to set.
+ */
+bool
+psqlscan_branch_set_state(PsqlScanState state, ifState new_state)
+{
+	if (psqlscan_branch_empty(state))
+		return false;
+	state->branch_stack->if_state = new_state;
+	psqlscan_branch_update_active(state);
+	return true;
+}
+
+/*
+ * psqlscan_branch_end_state
+ * 
+ * Destroy the topmost branch because and \endif was encountered.
+ * Returns false if there was no branch to end.
+ */
+bool
+psqlscan_branch_end_state(PsqlScanState state)
+{
+	IfStackElem *p = state->branch_stack;
+	if (!p)
+		return false;
+	state->branch_stack = state->branch_stack->next;
+	free(p);
+	psqlscan_branch_update_active(state);
+	return true;
+}
diff --git a/src/include/fe_utils/psqlscan_int.h b/src/include/fe_utils/psqlscan_int.h
index 0fddc7a..e9773ca 100644
--- a/src/include/fe_utils/psqlscan_int.h
+++ b/src/include/fe_utils/psqlscan_int.h
@@ -75,6 +75,30 @@ typedef struct StackElem
 	struct StackElem *next;
 } StackElem;
 
+typedef enum _ifState
+{
+	IFSTATE_NONE = 0,	/* Not currently in an \if block */
+	IFSTATE_TRUE,		/* currently in an \if or \elseif which is true
+						 * and all parent branches (if any) are true */
+	IFSTATE_FALSE,		/* currently in an \if or \elseif which is false
+						 * but no true branch has yet been seen,
+						 * and all parent branches (if any) are true */
+	IFSTATE_IGNORED,	/* currently in an \elseif which follows a true \if
+						 * or the whole \if is a child of a false parent */
+	IFSTATE_ELSE_TRUE,	/* currently in an \else which is true
+						 * and all parent branches (if any) are true */
+	IFSTATE_ELSE_FALSE	/* currently in an \else which is false or ignored */
+} ifState;
+
+/*
+ * The state of nested ifs is stored in a stack.
+ */
+typedef struct IfStackElem
+{
+	ifState		if_state;
+	struct IfStackElem *next;
+} IfStackElem;
+
 /*
  * All working state of the lexer must be stored in PsqlScanStateData
  * between calls.  This allows us to have multiple open lexer operations,
@@ -118,6 +142,12 @@ typedef struct PsqlScanStateData
 	 * Callback functions provided by the program making use of the lexer.
 	 */
 	const PsqlScanCallbacks *callbacks;
+
+	/*
+	 * \if branch state variables
+	 */
+	IfStackElem *branch_stack;
+	bool branch_block_active;
 } PsqlScanStateData;
 
 
@@ -141,4 +171,21 @@ extern void psqlscan_escape_variable(PsqlScanState state,
 						 const char *txt, int len,
 						 bool as_ident);
 
+/*
+ * branching commands
+ */
+extern bool psqlscan_branch_empty(PsqlScanState state);
+
+extern bool psqlscan_branch_active(PsqlScanState state);
+
+extern ifState psqlscan_branch_get_state(PsqlScanState state);
+
+extern bool psqlscan_branch_push(PsqlScanState state,
+									ifState new_state);
+
+extern bool psqlscan_branch_set_state(PsqlScanState state,
+									ifState new_state);
+
+extern bool psqlscan_branch_end_state(PsqlScanState state);
+
 #endif   /* PSQLSCAN_INT_H */
diff --git a/src/test/regress/expected/psql.out b/src/test/regress/expected/psql.out
index 464436a..7492a92 100644
--- a/src/test/regress/expected/psql.out
+++ b/src/test/regress/expected/psql.out
@@ -2686,6 +2686,33 @@ deallocate q;
 \pset format aligned
 \pset expanded off
 \pset border 1
+\if true
+	\if 1
+		\if yes
+			\if on
+				\echo 'all true'
+all true
+			\endif
+		\endif
+	\endif
+\endif
+\if false
+\elseif 0
+\elseif no
+\elseif off
+\else
+	\echo 'all false'
+all false
+\endif
+\if true
+\else
+	\echo 'should not print #1'
+\endif
+\if false
+\elseif true
+\else
+	\echo 'should not print #2'
+\endif
 -- SHOW_CONTEXT
 \set SHOW_CONTEXT never
 do $$
diff --git a/src/test/regress/sql/psql.sql b/src/test/regress/sql/psql.sql
index 900aa7e..ef1be30 100644
--- a/src/test/regress/sql/psql.sql
+++ b/src/test/regress/sql/psql.sql
@@ -357,6 +357,36 @@ deallocate q;
 \pset expanded off
 \pset border 1
 
+\if true
+	\if 1
+		\if yes
+			\if on
+				\echo 'all true'
+			\endif
+		\endif
+	\endif
+\endif
+
+\if false
+\elseif 0
+\elseif no
+\elseif off
+\else
+	\echo 'all false'
+\endif
+
+\if true
+\else
+	\echo 'should not print #1'
+\endif
+
+\if false
+\elseif true
+\else
+	\echo 'should not print #2'
+\endif
+
+
 -- SHOW_CONTEXT
 
 \set SHOW_CONTEXT never


-- 
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers

Attachments:

  [text/plain] 0001.if_endif.diff (17.8K, ../../CADkLM=c94OSRTnat=LX0ivNq4pxDNeoomFfYvBKM5N_xfmLtAA@mail.gmail.com/3-0001.if_endif.diff)
  download | inline diff:
diff --git a/doc/src/sgml/ref/psql-ref.sgml b/doc/src/sgml/ref/psql-ref.sgml
index 9915731..2c3fccd 100644
--- a/doc/src/sgml/ref/psql-ref.sgml
+++ b/doc/src/sgml/ref/psql-ref.sgml
@@ -2007,6 +2007,83 @@ hello 10
         </listitem>
       </varlistentry>
 
+      <varlistentry>
+        <term><literal>\if</literal> <replaceable class="parameter">expr</replaceable></term>
+        <term><literal>\elseif</literal> <replaceable class="parameter">expr</replaceable></term>
+        <term><literal>\else</literal></term>
+        <term><literal>\endif</literal></term>
+        <listitem>
+        <para>
+        This group of commands implements nestable conditional blocks, like
+        this:
+        </para>
+<programlisting>
+\if true
+    \if 1
+        \if yes
+            \if on
+                \echo 'all true'
+all true
+            \endif
+        \endif
+    \endif
+\endif
+\if false
+\elseif 0
+\elseif no
+\elseif off
+\else
+    \echo 'all false'
+all false
+\endif
+\if true
+\else
+    \echo 'should not print #1'
+\endif
+\if false
+\elseif true
+\else
+    \echo 'should not print #2'
+\endif
+</programlisting>
+        <para>
+        Conditional blocks must begin with a <command>\if</command> and end
+        with an <command>\endif</command>, and the pairs must be found in
+        the same source file. If an EOF is reached on the main file or an
+        <command>\include</command>-ed file before all 
+        <command>\if</command>-<command>\endif</command> are matched, then
+        psql will raise an error.
+        </para>
+        <para>
+        The <command>\if</command> and <command>\elseif</command> commands
+        read the rest of the line and evaluate it as a boolean expression.
+        Currently, expressions are limited to the same values allowed for
+        other option booleans (true, false, 1, 0, on, off, yes, no, etc).
+        </para>
+        <para>
+        Queries within a false branch of a conditional block will not be
+        sent to the server.
+        </para>
+        <para>
+        Non-conditional <command>\</command>-commands within a false branch
+        of a conditional block will not be evaluated for correctness. The
+        command will be ignored along with all remaining input to the end
+        of the line.
+        </para>
+        <para>
+        Expressions on <command>\if</command> and <command>\elseif</command>
+        commands within a false branch of a conditional block will not be
+        evaluated.
+        </para>
+        <para>
+        A conditional block can at most one <command>\else</command> command.
+        </para>
+        <para>
+        The <command>\elseif</command> command cannot follow the
+        <command>\else</command> command.
+        </para>
+        </listitem>
+      </varlistentry>
 
       <varlistentry>
         <term><literal>\ir</literal> or <literal>\include_relative</literal> <replaceable class="parameter">filename</replaceable></term>
diff --git a/src/bin/psql/command.c b/src/bin/psql/command.c
index 4139b77..d4e0bb8 100644
--- a/src/bin/psql/command.c
+++ b/src/bin/psql/command.c
@@ -49,6 +49,7 @@
 #include "psqlscanslash.h"
 #include "settings.h"
 #include "variables.h"
+#include "fe_utils/psqlscan_int.h"
 
 /*
  * Editable database object types.
@@ -132,7 +133,7 @@ HandleSlashCmds(PsqlScanState scan_state,
 		status = PSQL_CMD_ERROR;
 	}
 
-	if (status != PSQL_CMD_ERROR)
+	if ((status != PSQL_CMD_ERROR) && psqlscan_branch_active(scan_state))
 	{
 		/* eat any remaining arguments after a valid command */
 		/* note we suppress evaluation of backticks here */
@@ -194,6 +195,32 @@ read_connect_arg(PsqlScanState scan_state)
 	return result;
 }
 
+/*
+ * Read and interpret argument as a boolean expression.
+ */
+static bool
+read_boolean_expression(PsqlScanState scan_state, const char *action)
+{
+	bool	result = false;
+	char	*expr = psql_scan_slash_option(scan_state,
+											OT_NORMAL, NULL, false);
+	if (expr)
+	{
+		if (ParseVariableBool(expr, action))
+			result = true;
+		free(expr);
+	}
+	return result;
+}
+
+static bool
+is_branching_command(const char *cmd)
+{
+	return ((strcmp(cmd, "if") == 0 || \
+			strcmp(cmd, "elseif") == 0 || \
+			strcmp(cmd, "else") == 0 || \
+			strcmp(cmd, "endif") == 0));
+}
 
 /*
  * Subroutine to actually try to execute a backslash command.
@@ -207,6 +234,14 @@ exec_command(const char *cmd,
 								 * failed */
 	backslashResult status = PSQL_CMD_SKIP_LINE;
 
+	if (!psqlscan_branch_active(scan_state) && !is_branching_command(cmd) )
+	{
+		/* Continue with an empty buffer as if the command were never read */
+		resetPQExpBuffer(query_buf); /* TODO: is this needed? */
+		psql_scan_reset(scan_state); /* TODO: is this needed or just for interactive? */
+		return status;
+	}
+
 	/*
 	 * \a -- toggle field alignment This makes little sense but we keep it
 	 * around.
@@ -984,6 +1019,84 @@ exec_command(const char *cmd,
 		}
 	}
 
+	else if (strcmp(cmd, "if") == 0)
+	{
+		ifState new_if_state = IFSTATE_IGNORED;
+		if (psqlscan_branch_active(scan_state))
+		{
+			if (read_boolean_expression(scan_state, "\\if"))
+				new_if_state = IFSTATE_TRUE;
+			else
+				new_if_state = IFSTATE_FALSE;
+		}
+		psqlscan_branch_push(scan_state,new_if_state);
+		psql_scan_reset(scan_state);
+	}
+
+	else if (strcmp(cmd, "elseif") == 0)
+	{
+		if (psqlscan_branch_empty(scan_state))
+			psql_error("encountered un-matched \\elseif\n");
+
+		switch (psqlscan_branch_get_state(scan_state))
+		{
+			case IFSTATE_IGNORED:
+				/* inactive branch, do nothing */
+				break;
+			case IFSTATE_TRUE:
+				/* just finished true section of active branch */
+				psqlscan_branch_set_state(scan_state, IFSTATE_IGNORED);
+				break;
+			case IFSTATE_FALSE:
+				/* determine if this section is true or not */
+				if (read_boolean_expression(scan_state, "\\elseif"))
+					psqlscan_branch_set_state(scan_state, IFSTATE_TRUE);
+				break;
+			case IFSTATE_ELSE_TRUE:
+			case IFSTATE_ELSE_FALSE:
+				psql_error("encountered \\elseif after \\else\n");
+				break;
+			default:
+				break;
+		}
+		psql_scan_reset(scan_state);
+	}
+
+	else if (strcmp(cmd, "else") == 0)
+	{
+		if (psqlscan_branch_empty(scan_state))
+			psql_error("encountered un-matched \\else\n");
+
+		switch (psqlscan_branch_get_state(scan_state))
+		{
+			case IFSTATE_TRUE:
+				/* just finished true section of active branch */
+			case IFSTATE_IGNORED:
+				/* whole branch was inactive */
+				psqlscan_branch_set_state(scan_state, IFSTATE_ELSE_FALSE);
+				break;
+			case IFSTATE_FALSE:
+				/* just finished true section of active branch */
+				psqlscan_branch_set_state(scan_state, IFSTATE_ELSE_TRUE);
+				break;
+			case IFSTATE_ELSE_TRUE:
+			case IFSTATE_ELSE_FALSE:
+				psql_error("encountered \\else after \\else\n");
+				break;
+			default:
+				break;
+		}
+		psql_scan_reset(scan_state);
+	}
+
+	else if (strcmp(cmd, "endif") == 0)
+	{
+		if (psqlscan_branch_empty(scan_state))
+			psql_error("encountered un-matched \\endif\n");
+		psqlscan_branch_end_state(scan_state);
+		psql_scan_reset(scan_state);
+	}
+
 	/* \l is list databases */
 	else if (strcmp(cmd, "l") == 0 || strcmp(cmd, "list") == 0 ||
 			 strcmp(cmd, "l+") == 0 || strcmp(cmd, "list+") == 0)
diff --git a/src/bin/psql/mainloop.c b/src/bin/psql/mainloop.c
index bb306a4..8f12e55 100644
--- a/src/bin/psql/mainloop.c
+++ b/src/bin/psql/mainloop.c
@@ -15,7 +15,7 @@
 #include "settings.h"
 
 #include "mb/pg_wchar.h"
-
+#include "fe_utils/psqlscan_int.h"
 
 /* callback functions for our flex lexer */
 const PsqlScanCallbacks psqlscan_callbacks = {
@@ -23,7 +23,6 @@ const PsqlScanCallbacks psqlscan_callbacks = {
 	psql_error
 };
 
-
 /*
  * Main processing loop for reading lines of input
  *	and sending them to the backend.
@@ -51,6 +50,9 @@ MainLoop(FILE *source)
 	volatile int count_eof = 0;
 	volatile bool die_on_error = false;
 
+	/* only needed at the end to detect unbalanced ifs in scan_state */
+	bool if_endifs_balanced = true;
+
 	/* Save the prior command source */
 	FILE	   *prev_cmd_source;
 	bool		prev_cmd_interactive;
@@ -285,21 +287,28 @@ MainLoop(FILE *source)
 			if (scan_result == PSCAN_SEMICOLON ||
 				(scan_result == PSCAN_EOL && pset.singleline))
 			{
-				/*
-				 * Save query in history.  We use history_buf to accumulate
-				 * multi-line queries into a single history entry.
-				 */
-				if (pset.cur_cmd_interactive && !line_saved_in_history)
+				if (psqlscan_branch_active(scan_state))
 				{
-					pg_append_history(line, history_buf);
-					pg_send_history(history_buf);
-					line_saved_in_history = true;
+					/*
+					 * Save query in history.  We use history_buf to accumulate
+					 * multi-line queries into a single history entry.
+					 */
+					if (pset.cur_cmd_interactive && !line_saved_in_history)
+					{
+						pg_append_history(line, history_buf);
+						pg_send_history(history_buf);
+						line_saved_in_history = true;
+					}
+
+					/* execute query */
+					success = SendQuery(query_buf->data);
 				}
+				else
+					success = true;
 
-				/* execute query */
-				success = SendQuery(query_buf->data);
 				slashCmdStatus = success ? PSQL_CMD_SEND : PSQL_CMD_ERROR;
 				pset.stmt_lineno = 1;
+				slashCmdStatus = success ? PSQL_CMD_SEND : PSQL_CMD_ERROR;
 
 				/* transfer query to previous_buf by pointer-swapping */
 				{
@@ -352,21 +361,28 @@ MainLoop(FILE *source)
 				if ((slashCmdStatus == PSQL_CMD_SEND || slashCmdStatus == PSQL_CMD_NEWEDIT) &&
 					query_buf->len == 0)
 				{
+					/* TODO check if-then-skip-state */
 					/* copy previous buffer to current for handling */
 					appendPQExpBufferStr(query_buf, previous_buf->data);
 				}
 
 				if (slashCmdStatus == PSQL_CMD_SEND)
 				{
-					success = SendQuery(query_buf->data);
-
-					/* transfer query to previous_buf by pointer-swapping */
+					if (psqlscan_branch_active(scan_state))
 					{
-						PQExpBuffer swap_buf = previous_buf;
+						success = SendQuery(query_buf->data);
 
-						previous_buf = query_buf;
-						query_buf = swap_buf;
+						/* transfer query to previous_buf by pointer-swapping */
+						{
+							PQExpBuffer swap_buf = previous_buf;
+
+							previous_buf = query_buf;
+							query_buf = swap_buf;
+						}
 					}
+					else
+						success = true;
+
 					resetPQExpBuffer(query_buf);
 
 					/* flush any paren nesting info after forced send */
@@ -425,12 +441,17 @@ MainLoop(FILE *source)
 	if (query_buf->len > 0 && !pset.cur_cmd_interactive &&
 		successResult == EXIT_SUCCESS)
 	{
-		/* save query in history */
-		if (pset.cur_cmd_interactive)
-			pg_send_history(history_buf);
+		if (psqlscan_branch_active(scan_state))
+		{
+			/* save query in history */
+			if (pset.cur_cmd_interactive)
+				pg_send_history(history_buf);
 
-		/* execute query */
-		success = SendQuery(query_buf->data);
+			/* execute query */
+			success = SendQuery(query_buf->data);
+		}
+		else
+			success = true;
 
 		if (!success && die_on_error)
 			successResult = EXIT_USER;
@@ -451,11 +472,17 @@ MainLoop(FILE *source)
 	destroyPQExpBuffer(previous_buf);
 	destroyPQExpBuffer(history_buf);
 
+	if (slashCmdStatus != PSQL_CMD_TERMINATE)
+		if_endifs_balanced = psqlscan_branch_empty(scan_state);
+
 	psql_scan_destroy(scan_state);
 
 	pset.cur_cmd_source = prev_cmd_source;
 	pset.cur_cmd_interactive = prev_cmd_interactive;
 	pset.lineno = prev_lineno;
 
+	if (! if_endifs_balanced )
+		psql_error("found EOF before closing \\endif(s)\n");
+
 	return successResult;
 }	/* MainLoop() */
diff --git a/src/bin/psql/mainloop.h b/src/bin/psql/mainloop.h
index 228a5e0..47f4c32 100644
--- a/src/bin/psql/mainloop.h
+++ b/src/bin/psql/mainloop.h
@@ -14,4 +14,5 @@ extern const PsqlScanCallbacks psqlscan_callbacks;
 
 extern int	MainLoop(FILE *source);
 
+
 #endif   /* MAINLOOP_H */
diff --git a/src/fe_utils/psqlscan.l b/src/fe_utils/psqlscan.l
index 1b29341..881c4f8 100644
--- a/src/fe_utils/psqlscan.l
+++ b/src/fe_utils/psqlscan.l
@@ -904,6 +904,9 @@ psql_scan_create(const PsqlScanCallbacks *callbacks)
 
 	psql_scan_reset(state);
 
+	state->branch_stack = NULL;
+	state->branch_block_active = true;
+
 	return state;
 }
 
@@ -919,6 +922,13 @@ psql_scan_destroy(PsqlScanState state)
 
 	yylex_destroy(state->scanner);
 
+	while (state->branch_stack != NULL)
+	{
+		IfStackElem *p = state->branch_stack;
+		state->branch_stack = state->branch_stack->next;
+		free(p);
+	}
+
 	free(state);
 }
 
@@ -1426,3 +1436,103 @@ psqlscan_escape_variable(PsqlScanState state, const char *txt, int len,
 		psqlscan_emit(state, txt, len);
 	}
 }
+
+/*
+ * psqlscan_branch_empty
+ *
+ * True if there are no active \if-structures
+ */
+bool
+psqlscan_branch_empty(PsqlScanState state)
+{
+	return (state->branch_stack == NULL);
+}
+
+/*
+ * psqlscan_branch_active
+ *
+ * True if the current \if-block (if any) is true and queries/commands
+ * should be executed.
+ */
+bool
+psqlscan_branch_active(PsqlScanState state)
+{
+	return state->branch_block_active;
+}
+
+/*
+ * Fetch the current state of the top of the stack
+ */
+ifState
+psqlscan_branch_get_state(PsqlScanState state)
+{
+	if (psqlscan_branch_empty(state))
+		return IFSTATE_NONE;
+	return state->branch_stack->if_state;
+}
+
+/*
+ * psqlscan_branch_update_active
+ *
+ * Scan the branch_stack to determine whether the next statements
+ * can execute or should be skipped. Cache this result in
+ * branch_block_active.
+ */
+static void
+psqlscan_branch_update_active(PsqlScanState state)
+{
+	ifState s = psqlscan_branch_get_state(state);
+	state->branch_block_active  = ( (s == IFSTATE_NONE) ||
+									(s == IFSTATE_TRUE) ||
+									(s == IFSTATE_ELSE_TRUE));
+}
+
+/*
+ * psqlscan_branch_push
+ *
+ * Create a new \if branch.
+ */
+bool
+psqlscan_branch_push(PsqlScanState state, ifState new_state)
+{
+	IfStackElem *p = pg_malloc0(sizeof(IfStackElem));
+	p->if_state = new_state;
+	p->next = state->branch_stack;
+	state->branch_stack = p;
+	psqlscan_branch_update_active(state);
+	return true;
+}
+
+/*
+ * psqlscan_branch_set_state
+ *
+ * Change the state of the topmost branch.
+ * Returns false if there was branch state to set.
+ */
+bool
+psqlscan_branch_set_state(PsqlScanState state, ifState new_state)
+{
+	if (psqlscan_branch_empty(state))
+		return false;
+	state->branch_stack->if_state = new_state;
+	psqlscan_branch_update_active(state);
+	return true;
+}
+
+/*
+ * psqlscan_branch_end_state
+ * 
+ * Destroy the topmost branch because and \endif was encountered.
+ * Returns false if there was no branch to end.
+ */
+bool
+psqlscan_branch_end_state(PsqlScanState state)
+{
+	IfStackElem *p = state->branch_stack;
+	if (!p)
+		return false;
+	state->branch_stack = state->branch_stack->next;
+	free(p);
+	psqlscan_branch_update_active(state);
+	return true;
+}
diff --git a/src/include/fe_utils/psqlscan_int.h b/src/include/fe_utils/psqlscan_int.h
index 0fddc7a..e9773ca 100644
--- a/src/include/fe_utils/psqlscan_int.h
+++ b/src/include/fe_utils/psqlscan_int.h
@@ -75,6 +75,30 @@ typedef struct StackElem
 	struct StackElem *next;
 } StackElem;
 
+typedef enum _ifState
+{
+	IFSTATE_NONE = 0,	/* Not currently in an \if block */
+	IFSTATE_TRUE,		/* currently in an \if or \elseif which is true
+						 * and all parent branches (if any) are true */
+	IFSTATE_FALSE,		/* currently in an \if or \elseif which is false
+						 * but no true branch has yet been seen,
+						 * and all parent branches (if any) are true */
+	IFSTATE_IGNORED,	/* currently in an \elseif which follows a true \if
+						 * or the whole \if is a child of a false parent */
+	IFSTATE_ELSE_TRUE,	/* currently in an \else which is true
+						 * and all parent branches (if any) are true */
+	IFSTATE_ELSE_FALSE	/* currently in an \else which is false or ignored */
+} ifState;
+
+/*
+ * The state of nested ifs is stored in a stack.
+ */
+typedef struct IfStackElem
+{
+	ifState		if_state;
+	struct IfStackElem *next;
+} IfStackElem;
+
 /*
  * All working state of the lexer must be stored in PsqlScanStateData
  * between calls.  This allows us to have multiple open lexer operations,
@@ -118,6 +142,12 @@ typedef struct PsqlScanStateData
 	 * Callback functions provided by the program making use of the lexer.
 	 */
 	const PsqlScanCallbacks *callbacks;
+
+	/*
+	 * \if branch state variables
+	 */
+	IfStackElem *branch_stack;
+	bool branch_block_active;
 } PsqlScanStateData;
 
 
@@ -141,4 +171,21 @@ extern void psqlscan_escape_variable(PsqlScanState state,
 						 const char *txt, int len,
 						 bool as_ident);
 
+/*
+ * branching commands
+ */
+extern bool psqlscan_branch_empty(PsqlScanState state);
+
+extern bool psqlscan_branch_active(PsqlScanState state);
+
+extern ifState psqlscan_branch_get_state(PsqlScanState state);
+
+extern bool psqlscan_branch_push(PsqlScanState state,
+									ifState new_state);
+
+extern bool psqlscan_branch_set_state(PsqlScanState state,
+									ifState new_state);
+
+extern bool psqlscan_branch_end_state(PsqlScanState state);
+
 #endif   /* PSQLSCAN_INT_H */
diff --git a/src/test/regress/expected/psql.out b/src/test/regress/expected/psql.out
index 464436a..7492a92 100644
--- a/src/test/regress/expected/psql.out
+++ b/src/test/regress/expected/psql.out
@@ -2686,6 +2686,33 @@ deallocate q;
 \pset format aligned
 \pset expanded off
 \pset border 1
+\if true
+	\if 1
+		\if yes
+			\if on
+				\echo 'all true'
+all true
+			\endif
+		\endif
+	\endif
+\endif
+\if false
+\elseif 0
+\elseif no
+\elseif off
+\else
+	\echo 'all false'
+all false
+\endif
+\if true
+\else
+	\echo 'should not print #1'
+\endif
+\if false
+\elseif true
+\else
+	\echo 'should not print #2'
+\endif
 -- SHOW_CONTEXT
 \set SHOW_CONTEXT never
 do $$
diff --git a/src/test/regress/sql/psql.sql b/src/test/regress/sql/psql.sql
index 900aa7e..ef1be30 100644
--- a/src/test/regress/sql/psql.sql
+++ b/src/test/regress/sql/psql.sql
@@ -357,6 +357,36 @@ deallocate q;
 \pset expanded off
 \pset border 1
 
+\if true
+	\if 1
+		\if yes
+			\if on
+				\echo 'all true'
+			\endif
+		\endif
+	\endif
+\endif
+
+\if false
+\elseif 0
+\elseif no
+\elseif off
+\else
+	\echo 'all false'
+\endif
+
+\if true
+\else
+	\echo 'should not print #1'
+\endif
+
+\if false
+\elseif true
+\else
+	\echo 'should not print #2'
+\endif
+
+
 -- SHOW_CONTEXT
 
 \set SHOW_CONTEXT never


^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-01-23 20:37  Fabien COELHO <coelho@cri.ensmp.fr>
  parent: Corey Huinker <corey.huinker@gmail.com>
  0 siblings, 2 replies; 232+ messages in thread

From: Fabien COELHO @ 2017-01-23 20:37 UTC (permalink / raw)
  To: Corey Huinker <corey.huinker@gmail.com>; +Cc: pgsql-hackers


> And here's the patch. I've changed the subject line and will be submitting
> a new entry to the commitfest.

A few comments:

Patch applies, make check is ok, but currently really too partial.

I do not like the choice of "elseif", which exists in PHP & VB. PL/pgSQL 
has "ELSIF" like perl, that I do not like much, though. Given the syntax 
and behavioral proximity with cpp, I suggest that "elif" would be a better 
choice.

Documentation: I do not think that the systematic test-like example in the 
documentation is relevant, a better example should be shown. The list of 
what is considered true or false should be told explicitely, not end with 
"etc" that is everyone to guess.

Tests: On principle they should include echos in all non executed branches 
to reassure that they are indeed not executed.

Also, no error cases are tested. They should be. Maybe it is not very easy 
to test some cases which expect to make psql generate errors, but I feel 
they are absolutely necessary for such a feature.

1: unrecognized value "whatever" for "\if"; assuming "on"

I do not think that the script should continue with such an assumption.

2: encountered \else after \else ... "# ERROR BEFORE"

Even with ON_ERROR_STOP activated the execution continues.

3: no \endif

Error reported, but it does not stop even with ON_ERROR_STOP.

4: include with bad nesting...

Again, even with ON_ERROR_STOP, the execution continues...


Code:

   -       if (status != PSQL_CMD_ERROR)
   +       if ((status != PSQL_CMD_ERROR) && psqlscan_branch_active(scan_state))

Why the added parenthesis?

   case ...: case ...:

The project rules are to add explicit /* PASSTHROUGH */ comment.

There are spaces at the end of one line in a comment about 
psqlscan_branch_end_state.

There are multiple "TODO" comments in the file... Is it done or work in 
progress?

Usually in pg comments about a function do not repeat the function name. 
For very short comment, they are /* inlined */ on one line. Use pg comment 
style.

-- 
Fabien.


-- 
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers



^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-01-23 20:39  Fabien COELHO <coelho@cri.ensmp.fr>
  parent: Fabien COELHO <coelho@cri.ensmp.fr>
  1 sibling, 0 replies; 232+ messages in thread

From: Fabien COELHO @ 2017-01-23 20:39 UTC (permalink / raw)
  To: Corey Huinker <corey.huinker@gmail.com>; +Cc: pgsql-hackers


> A few comments:

Argh, better with the attachements:-(

-- 
Fabien.

-- 
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers

Attachments:

  [application/x-sql] if-error-1.sql (77B, ../../alpine.DEB.2.20.1701232138530.31421@lancre/2-if-error-1.sql)
  download

  [application/x-sql] if-error-2.sql (109B, ../../alpine.DEB.2.20.1701232138530.31421@lancre/3-if-error-2.sql)
  download

  [application/x-sql] if-error-3.sql (59B, ../../alpine.DEB.2.20.1701232138530.31421@lancre/4-if-error-3.sql)
  download

  [application/x-sql] if-error-4.sql (160B, ../../alpine.DEB.2.20.1701232138530.31421@lancre/5-if-error-4.sql)
  download

^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-01-23 21:12  Corey Huinker <corey.huinker@gmail.com>
  parent: Fabien COELHO <coelho@cri.ensmp.fr>
  1 sibling, 3 replies; 232+ messages in thread

From: Corey Huinker @ 2017-01-23 21:12 UTC (permalink / raw)
  To: Fabien COELHO <coelho@cri.ensmp.fr>; +Cc: pgsql-hackers

>
> I do not like the choice of "elseif", which exists in PHP & VB. PL/pgSQL
> has "ELSIF" like perl, that I do not like much, though. Given the syntax
> and behavioral proximity with cpp, I suggest that "elif" would be a better
> choice.
>

I'm personally indifferent to elif vs elsif vs elseif, but I think elseif
was the consensus. It's easy enough to change.


>
> Documentation: I do not think that the systematic test-like example in the
> documentation is relevant, a better example should be shown. The list of
> what is considered true or false should be told explicitely, not end with
> "etc" that is everyone to guess.
>

It was copied from the regression test. I knew there would be follow-up
suggestions for what should be shown.


>
> Tests: On principle they should include echos in all non executed branches
> to reassure that they are indeed not executed.
>

Will do.


>
> Also, no error cases are tested. They should be. Maybe it is not very easy
> to test some cases which expect to make psql generate errors, but I feel
> they are absolutely necessary for such a feature.
>

Will do.


>
> 1: unrecognized value "whatever" for "\if"; assuming "on"
>
> I do not think that the script should continue with such an assumption.
>

I agree, and this means we can't use ParseVariableBool() as-is. I already
broke out argument reading to it's own function, knowing that it'd be the
stub for expressions. So I guess we start that now. What subset of true-ish
values do you think we should support? If we think that real expressions
are possible soon, we could only allow 'true' and 'false' for now, but if
we expect that expressions might not make it into v10, then perhaps we
should support the same text values that coerce to booleans on the server
side.


>
> 2: encountered \else after \else ... "# ERROR BEFORE"
>
> Even with ON_ERROR_STOP activated the execution continues.


> 3: no \endif
>
> Error reported, but it does not stop even with ON_ERROR_STOP.
>
> 4: include with bad nesting...
>
> Again, even with ON_ERROR_STOP, the execution continues...
>

All valid issues. Will add those to the regression as well (with
ON_ERROR_STOP disabled, obviously).


>
>
> Code:
>
>   -       if (status != PSQL_CMD_ERROR)
>   +       if ((status != PSQL_CMD_ERROR) && psqlscan_branch_active(scan_st
> ate))
>
> Why the added parenthesis?
>

Will fix.


>
>   case ...: case ...:
>
> The project rules are to add explicit /* PASSTHROUGH */ comment.
>

Will do.


>
> There are spaces at the end of one line in a comment about
> psqlscan_branch_end_state.
>
> There are multiple "TODO" comments in the file... Is it done or work in
> progress?
>

I forgot to remove them. But it would be wildly optimistic of me to think
there would be no more work for me after the first patch submission.


>
> Usually in pg comments about a function do not repeat the function name.
> For very short comment, they are /* inlined */ on one line. Use pg comment
> style.


In that case, I was copying the style found in other functions psqlscan.l -
I'm happy to remove it.

^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-01-23 23:03  Corey Huinker <corey.huinker@gmail.com>
  parent: Corey Huinker <corey.huinker@gmail.com>
  2 siblings, 1 reply; 232+ messages in thread

From: Corey Huinker @ 2017-01-23 23:03 UTC (permalink / raw)
  To: Fabien COELHO <coelho@cri.ensmp.fr>; +Cc: pgsql-hackers

On Mon, Jan 23, 2017 at 4:12 PM, Corey Huinker <corey.huinker@gmail.com>
wrote:

> I do not like the choice of "elseif", which exists in PHP & VB. PL/pgSQL
>> has "ELSIF" like perl, that I do not like much, though. Given the syntax
>> and behavioral proximity with cpp, I suggest that "elif" would be a better
>> choice.
>>
>
> I'm personally indifferent to elif vs elsif vs elseif, but I think elseif
> was the consensus. It's easy enough to change.
>

Went with elsif to follow pl/pgsql. In reviewing the original thread it
seemed that "elif" was linked to "fi" and that got some negative feedback.


>
>
>>
>> Documentation: I do not think that the systematic test-like example in
>> the documentation is relevant, a better example should be shown. The list
>> of what is considered true or false should be told explicitely, not end
>> with "etc" that is everyone to guess.
>>
>
> It was copied from the regression test. I knew there would be follow-up
> suggestions for what should be shown.
>

Work on this is pending discussion of what true/false values we should
allow, and if values outside of those is an error.


>>
>>   case ...: case ...:
>>
>> The project rules are to add explicit /* PASSTHROUGH */ comment.
>>
>
> Will do.
>

I went looking for other examples of explicit /* PASSTHROUGH */ comments
and could find none. Could you explain what it is you want me to fix with
the switch statements?

^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-01-24 06:06  Fabien COELHO <coelho@cri.ensmp.fr>
  parent: Corey Huinker <corey.huinker@gmail.com>
  0 siblings, 1 reply; 232+ messages in thread

From: Fabien COELHO @ 2017-01-24 06:06 UTC (permalink / raw)
  To: Corey Huinker <corey.huinker@gmail.com>; +Cc: pgsql-hackers


Hello,

>> I'm personally indifferent to elif vs elsif vs elseif, but I think elseif
>> was the consensus. It's easy enough to change.
>
> Went with elsif to follow pl/pgsql. In reviewing the original thread it
> seemed that "elif" was linked to "fi" and that got some negative feedback.

As I understood it, the negative feeback was really about sh inspiration 
"if/fi", not about elif/elsif/elseif. I do not think that there was an
expressed consensus about the later.

Else-if variants from different languages include:

  VB: If ElseIf Else End If (with optional Then)
  PHP: if {} elseif {} else {}
  Tcl: if {} elseif {} else {}

  PL/pgSQL: IF ... THEN ... ELSIF ... ELSE ... END IF;
  Perl: if {} elsif {} else {}
  Ruby: if elsif else end

  CPP: #if #elif #else #endif
  Python: if : elif: else:
  bash: if [] then ... elif ... else ... fi

The closest case is CPP with its line-oriented #-prefix syntax, and I 
still think that we should do it like that.

> I went looking for other examples of explicit /* PASSTHROUGH */ comments
> and could find none. Could you explain what it is you want me to fix with
> the switch statements?

Sorry, I got it wrong. The comment (which is FALLTHROUGH or FALL THROUGH, 
not PASSTHROUGH) is required if there is specific code in a case and the 
case is expected to continue with executing the next case code as well. 
This is quite rare, and it is not the case for your code, which just has 
some comments in one case.

-- 
Fabien


-- 
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers



^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-01-24 06:15  Fabien COELHO <coelho@cri.ensmp.fr>
  parent: Corey Huinker <corey.huinker@gmail.com>
  2 siblings, 1 reply; 232+ messages in thread

From: Fabien COELHO @ 2017-01-24 06:15 UTC (permalink / raw)
  To: Corey Huinker <corey.huinker@gmail.com>; +Cc: pgsql-hackers


>> 1: unrecognized value "whatever" for "\if"; assuming "on"
>>
>> I do not think that the script should continue with such an assumption.
>
> I agree, and this means we can't use ParseVariableBool() as-is. I 
> already broke out argument reading to it's own function, knowing that 
> it'd be the stub for expressions. So I guess we start that now. What 
> subset of true-ish values do you think we should support? If we think 
> that real expressions are possible soon, we could only allow 'true' and 
> 'false' for now, but if we expect that expressions might not make it 
> into v10, then perhaps we should support the same text values that 
> coerce to booleans on the server side.

Hmmm. I would text value that coerce to true? I would also accept non-zero 
integers (eg SELECT 1::BOOL; -- t).

I would suggest to assume false on everything else, and/or maybe to ignore 
the whole if/endif section in such cases.

> All valid issues. Will add those to the regression as well (with
> ON_ERROR_STOP disabled, obviously).

ISTM that with TAP test you can check for error returns, so maybe this can 
be done.

-- 
Fabien.


-- 
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers



^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-01-24 06:22  Corey Huinker <corey.huinker@gmail.com>
  parent: Fabien COELHO <coelho@cri.ensmp.fr>
  0 siblings, 0 replies; 232+ messages in thread

From: Corey Huinker @ 2017-01-24 06:22 UTC (permalink / raw)
  To: Fabien COELHO <coelho@cri.ensmp.fr>; +Cc: pgsql-hackers

>
>
> As I understood it, the negative feeback was really about sh inspiration
> "if/fi", not about elif/elsif/elseif. I do not think that there was an
> expressed consensus about the later.
>

True


> The closest case is CPP with its line-oriented #-prefix syntax, and I
> still think that we should do it like that.


Given that the pl/pgsql syntax has a space between "end" and "if", I have
to agree. It's easy enough to change back if others can make a convincing
argument for something else.

^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-01-24 07:54  Corey Huinker <corey.huinker@gmail.com>
  parent: Fabien COELHO <coelho@cri.ensmp.fr>
  0 siblings, 1 reply; 232+ messages in thread

From: Corey Huinker @ 2017-01-24 07:54 UTC (permalink / raw)
  To: Fabien COELHO <coelho@cri.ensmp.fr>; +Cc: pgsql-hackers

On Tue, Jan 24, 2017 at 1:15 AM, Fabien COELHO <coelho@cri.ensmp.fr> wrote:

>
> 1: unrecognized value "whatever" for "\if"; assuming "on"
>>>
>>> I do not think that the script should continue with such an assumption.
>>>
>>
>> I agree, and this means we can't use ParseVariableBool() as-is. I already
>> broke out argument reading to it's own function, knowing that it'd be the
>> stub for expressions. So I guess we start that now. What subset of true-ish
>> values do you think we should support? If we think that real expressions
>> are possible soon, we could only allow 'true' and 'false' for now, but if
>> we expect that expressions might not make it into v10, then perhaps we
>> should support the same text values that coerce to booleans on the server
>> side.
>>
>
> Hmmm. I would text value that coerce to true? I would also accept non-zero
> integers (eg SELECT 1::BOOL; -- t).
>


The docs (doc/src/sgml/datatype.sgml) list TRUE 't' 'true' 'y' 'yes' 'on'
'1'    vs FALSE 'f' 'false' 'n' 'no' 'off' '0'

However, src/test/regress/expected/boolean.out shows that there's some
flexiblity there with spaces, even before you inspect parse_bool_with_len()
in src/backend/utils/adt/bool.c.

If we could bring src/backend/utils/adt/bool.c across the server/client
wall, I would just use parse_bool_with_len as-is.

As it is, given that whatever I do is temporary until real expressions come
into place, that wouldn't be a terrible amount of code copying, and we'd
still have a proto-expression that probably isn't going to conflict with
whatever expression syntax we do chose. Having said that, if anyone can see
ANY reason that some subset of the existing bool-friendly strings would
cause a problem with the expression syntax we do hope to use, speak now and
we can restrict the accepted values.


> I would suggest to assume false on everything else, and/or maybe to ignore
> the whole if/endif section in such cases.


+1, it also halves the number of values we have to support later.


> ISTM that with TAP test you can check for error returns, so maybe this can
> be done.


I'll have to educate myself on TAP tests.

^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-01-24 08:58  Fabien COELHO <coelho@cri.ensmp.fr>
  parent: Corey Huinker <corey.huinker@gmail.com>
  0 siblings, 1 reply; 232+ messages in thread

From: Fabien COELHO @ 2017-01-24 08:58 UTC (permalink / raw)
  To: Corey Huinker <corey.huinker@gmail.com>; +Cc: pgsql-hackers


>> I would suggest to assume false on everything else, and/or maybe to ignore
>> the whole if/endif section in such cases.
>
> +1, it also halves the number of values we have to support later.

After giving it some thought, I revise a little bit my opinion:

I think that if the value is evaluated to TRUE or FALSE, then fine. If it 
is anything else, then an error is raised (error message shown), which 
should also stop the script on "ON_ERROR_STOP", and if not the script 
continues with assuming the value was FALSE.

-- 
Fabien.


-- 
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers



^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-01-24 18:08  Daniel Verite <daniel@manitou-mail.org>
  parent: Corey Huinker <corey.huinker@gmail.com>
  2 siblings, 2 replies; 232+ messages in thread

From: Daniel Verite @ 2017-01-24 18:08 UTC (permalink / raw)
  To: Corey Huinker <corey.huinker@gmail.com>; +Cc: Fabien COELHO <coelho@cri.ensmp.fr>; pgsql-hackers

	Corey Huinker wrote:

> >
> > 1: unrecognized value "whatever" for "\if"; assuming "on"
> >
> > I do not think that the script should continue with such an assumption.
> >
> 
> I agree, and this means we can't use ParseVariableBool() as-is

The patch at https://commitfest.postgresql.org/12/799/
in the ongoing CF already changes ParseVariableBool()
to not assume that unrecognizable values should be set to
"on".

There's also the fact that ParseVariableBool() in HEAD assumes
that an empty value is valid and true, which I think leads to this
inconsistency in the current patch:

\set empty
\if :empty
select 1 as result \gset
\else
select 2 as result \gset
\endif
\echo 'result is' :result

produces: result is 1 (so an empty string evaluates to true)

Yet this sequence:

\if
select 1 as result \gset
\else
select 2 as result \gset
\endif
\echo 'result is' :result

produces: result is 2 (so an empty \if evaluates to false)

The equivalence between empty value and true in
ParseVariableBool() is also suppressed in the above-mentioned
patch.

ISTM that it's important that eventually ParseVariableBool()
and \if agree on what evaluates to true and false (and the
more straightforward way to achieve that is by \if calling
directly ParseVariableBool), but that it's not productive that we
discuss /if issues relatively to the behavior of ParseVariableBool()
in HEAD at the moment, as it's likely to change.


Best regards,
-- 
Daniel Vérité
PostgreSQL-powered mailer: http://www.manitou-mail.org
Twitter: @DanielVerite


-- 
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers



^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-01-24 18:25  Corey Huinker <corey.huinker@gmail.com>
  parent: Daniel Verite <daniel@manitou-mail.org>
  1 sibling, 1 reply; 232+ messages in thread

From: Corey Huinker @ 2017-01-24 18:25 UTC (permalink / raw)
  To: Daniel Verite <daniel@manitou-mail.org>; +Cc: Fabien COELHO <coelho@cri.ensmp.fr>; pgsql-hackers

>
> ISTM that it's important that eventually ParseVariableBool()
> and \if agree on what evaluates to true and false (and the
> more straightforward way to achieve that is by \if calling
> directly ParseVariableBool), but that it's not productive that we
> discuss /if issues relatively to the behavior of ParseVariableBool()
> in HEAD at the moment, as it's likely to change.
>

I'd like to keep in sync with ParseVariableBoolean(), but

Also, Fabien has made a good case for invalid parsed values being an
ON_ERROR_STOP-able error, and not defaulted to either true or false.

This might be asking a lot, but could we make a "strict" mode for
ParseVariableBool() that returns a success boolean, and have the existing
ParseVariableBool() signature call that new function, and issue the
"assuming " warning if the strict function failed?

^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-01-24 18:40  Corey Huinker <corey.huinker@gmail.com>
  parent: Corey Huinker <corey.huinker@gmail.com>
  0 siblings, 0 replies; 232+ messages in thread

From: Corey Huinker @ 2017-01-24 18:40 UTC (permalink / raw)
  To: Daniel Verite <daniel@manitou-mail.org>; +Cc: Fabien COELHO <coelho@cri.ensmp.fr>; pgsql-hackers

On Tue, Jan 24, 2017 at 1:25 PM, Corey Huinker <corey.huinker@gmail.com>
wrote:

> This might be asking a lot, but could we make a "strict" mode for
> ParseVariableBool() that returns a success boolean, and have the existing
> ParseVariableBool() signature call that new function, and issue the
> "assuming " warning if the strict function failed?


Nevermind. Looking at the v7 patch I see that it does everything I need and
more. I should have looked first.

^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-01-24 19:38  Tom Lane <tgl@sss.pgh.pa.us>
  parent: Daniel Verite <daniel@manitou-mail.org>
  1 sibling, 0 replies; 232+ messages in thread

From: Tom Lane @ 2017-01-24 19:38 UTC (permalink / raw)
  To: Daniel Verite <daniel@manitou-mail.org>; +Cc: Corey Huinker <corey.huinker@gmail.com>; Fabien COELHO <coelho@cri.ensmp.fr>; pgsql-hackers

"Daniel Verite" <daniel@manitou-mail.org> writes:
> ISTM that it's important that eventually ParseVariableBool()
> and \if agree on what evaluates to true and false (and the
> more straightforward way to achieve that is by \if calling
> directly ParseVariableBool), but that it's not productive that we
> discuss /if issues relatively to the behavior of ParseVariableBool()
> in HEAD at the moment, as it's likely to change.

AFAIK we do have consensus on changing its behavior to disallow
assignment of invalid values.  It's just a matter of getting the
patch to be stylistically nice.

			regards, tom lane


-- 
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers



^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-01-24 19:52  Corey Huinker <corey.huinker@gmail.com>
  parent: Fabien COELHO <coelho@cri.ensmp.fr>
  0 siblings, 1 reply; 232+ messages in thread

From: Corey Huinker @ 2017-01-24 19:52 UTC (permalink / raw)
  To: Fabien COELHO <coelho@cri.ensmp.fr>; +Cc: pgsql-hackers

Revised patch, with one caveat: It contains copy/pasted code from
variable.c intended to bridge the gap until https://commitfest.postgresql.
org/12/799/  (changing ParseVariableBool to detect invalid boolean-ish
strings) is merged. We may want to pause full-review of this patch pending
resolution of that one. I'm happy to continue with the stop-gap in place.

Changes made:
- \elseif is now \elif
- Invalid boolean values now return an error
- ON_ERROR_STOP is respected in all errors raided by \if, \elsif, \else,
\endif commands.
- Documentation gives a more real-world example of usage.
- Documentation gives a more explicit list of valid boolean values
- Regression tests for out-of-place \endif, \else, and \endif
- Regression test for invalid boolean values
- Removal of debug detritus.

Changes not(yet) made:
- No TAP test for errors respecting ON_ERROR_STOP
- function comments in psqlscan.l follow the style found in other comments
there, which goes counter to global style.


On Tue, Jan 24, 2017 at 3:58 AM, Fabien COELHO <coelho@cri.ensmp.fr> wrote:

>
> I would suggest to assume false on everything else, and/or maybe to ignore
>>> the whole if/endif section in such cases.
>>>
>>
>> +1, it also halves the number of values we have to support later.
>>
>
> After giving it some thought, I revise a little bit my opinion:
>
>
> I think that if the value is evaluated to TRUE or FALSE, then fine. If it
> is anything else, then an error is raised (error message shown), which
> should also stop the script on "ON_ERROR_STOP", and if not the script
> continues with assuming the value was FALSE.
>
> --
> Fabien.
>
diff --git a/doc/src/sgml/ref/psql-ref.sgml b/doc/src/sgml/ref/psql-ref.sgml
index 9915731..20091e5 100644
--- a/doc/src/sgml/ref/psql-ref.sgml
+++ b/doc/src/sgml/ref/psql-ref.sgml
@@ -2007,6 +2007,78 @@ hello 10
         </listitem>
       </varlistentry>
 
+      <varlistentry>
+        <term><literal>\if</literal> <replaceable class="parameter">expr</replaceable></term>
+        <term><literal>\elif</literal> <replaceable class="parameter">expr</replaceable></term>
+        <term><literal>\else</literal></term>
+        <term><literal>\endif</literal></term>
+        <listitem>
+        <para>
+        This group of commands implements nestable conditional blocks, like
+        this:
+        </para>
+<programlisting>
+SELECT
+    EXISTS(SELECT 1 FROM customer) as has_customers,
+    EXISTS(SELECT 1 FROM employee) as has_employees
+\gset
+\if :has_users
+    SELECT * FROM customer ORDER BY creation_date LIMIT 5;
+\elif :has_employees
+    \echo 'no customers found'
+    SELECT * FROM employee ORDER BY creation_date LIMIT 5;
+\else
+    \if yes
+        \echo 'No customers or employees'
+    \else
+        \echo 'this should never print'
+    \endif
+\endif
+</programlisting>
+        <para>
+        Conditional blocks must begin with a <command>\if</command> and end
+        with an <command>\endif</command>, and the pairs must be found in
+        the same source file. If an EOF is reached on the main file or an
+        <command>\include</command>-ed file before all 
+        <command>\if</command>-<command>\endif</command> are matched, then
+        psql will raise an error.
+        </para>
+        <para>
+        The <command>\if</command> and <command>\elif</command> commands
+        read the rest of the line and evaluate it as a boolean expression.
+        Currently, expressions are limited to a single unquoted string
+        which is evaluated like other options booleans, so the valid values
+        are any unabiguous case insensitive matches for one of:
+        <literal>true</literal>, <literal>false</literal>, <literal>1</literal>,
+        <literal>0</literal>, <literal>on</literal>, <literal>off</literal>,
+        <literal>yes</literal>, <literal>no</literal>.  So 
+        <literal>t</literal>, <literal>T</literal>, and <literal>tR</literal>
+        will all match <literal>true</literal>.
+        </para>
+        <para>
+        Queries within a false branch of a conditional block will not be
+        sent to the server.
+        </para>
+        <para>
+        Non-conditional <command>\</command>-commands within a false branch
+        of a conditional block will not be evaluated for correctness. The
+        command will be ignored along with all remaining input to the end
+        of the line.
+        </para>
+        <para>
+        Expressions on <command>\if</command> and <command>\elif</command>
+        commands within a false branch of a conditional block will not be
+        evaluated.
+        </para>
+        <para>
+        A conditional block can at most one <command>\else</command> command.
+        </para>
+        <para>
+        The <command>\elif</command> command cannot follow the
+        <command>\else</command> command.
+        </para>
+        </listitem>
+      </varlistentry>
 
       <varlistentry>
         <term><literal>\ir</literal> or <literal>\include_relative</literal> <replaceable class="parameter">filename</replaceable></term>
diff --git a/src/bin/psql/command.c b/src/bin/psql/command.c
index 4139b77..feb9ddc 100644
--- a/src/bin/psql/command.c
+++ b/src/bin/psql/command.c
@@ -49,6 +49,7 @@
 #include "psqlscanslash.h"
 #include "settings.h"
 #include "variables.h"
+#include "fe_utils/psqlscan_int.h"
 
 /*
  * Editable database object types.
@@ -132,7 +133,7 @@ HandleSlashCmds(PsqlScanState scan_state,
 		status = PSQL_CMD_ERROR;
 	}
 
-	if (status != PSQL_CMD_ERROR)
+	if (status != PSQL_CMD_ERROR && psqlscan_branch_active(scan_state))
 	{
 		/* eat any remaining arguments after a valid command */
 		/* note we suppress evaluation of backticks here */
@@ -194,6 +195,68 @@ read_connect_arg(PsqlScanState scan_state)
 	return result;
 }
 
+/*
+ * Read and interpret argument as a boolean expression.
+ * Return true if a boolean value was successfully parsed.
+ */
+static bool
+read_boolean_expression(PsqlScanState scan_state, char *action,
+						bool *result)
+{
+	bool	success = false;
+	char	*value = psql_scan_slash_option(scan_state,
+											OT_NORMAL, NULL, false);
+	/*
+	 * placeholder code until ParseVariableBool() ads error detection
+	 * once that patch is in place, use that instead
+	 */
+	if (value)
+	{
+		size_t		len;
+
+		if (value == NULL)
+			return false;			/* not set -> assume "off" */
+
+		len = strlen(value);
+
+		if ((pg_strncasecmp(value, "true", len) == 0) ||
+			(pg_strncasecmp(value, "yes", len) == 0) ||
+			(pg_strncasecmp(value, "on", (len > 2 ? len : 2)) == 0) ||
+			(pg_strcasecmp(value, "1") == 0))
+		{
+			success = true;
+			*result = true;
+		}
+		else if ((pg_strncasecmp(value, "false", len) == 0) ||
+				 (pg_strncasecmp(value, "no", len) == 0) ||
+				 (pg_strncasecmp(value, "off", (len > 2 ? len : 2)) == 0) ||
+				 (pg_strcasecmp(value, "0") == 0))
+		{
+			success = true;
+			*result = false;
+		}
+		else
+		{
+			psql_error("\\%s: invalid boolean expression: %s\n",
+						action, value);
+		}
+		free(value);
+	}
+	else
+	{
+		psql_error("\\%s: no expression given\n",action);
+	}
+	return success;
+}
+
+static bool
+is_branching_command(const char *cmd)
+{
+	return ((strcmp(cmd, "if") == 0 || \
+			strcmp(cmd, "elif") == 0 || \
+			strcmp(cmd, "else") == 0 || \
+			strcmp(cmd, "endif") == 0));
+}
 
 /*
  * Subroutine to actually try to execute a backslash command.
@@ -207,6 +270,14 @@ exec_command(const char *cmd,
 								 * failed */
 	backslashResult status = PSQL_CMD_SKIP_LINE;
 
+	if (!psqlscan_branch_active(scan_state) && !is_branching_command(cmd) )
+	{
+		/* Continue with an empty buffer as if the command were never read */
+		resetPQExpBuffer(query_buf);
+		psql_scan_reset(scan_state);
+		return status;
+	}
+
 	/*
 	 * \a -- toggle field alignment This makes little sense but we keep it
 	 * around.
@@ -984,6 +1055,114 @@ exec_command(const char *cmd,
 		}
 	}
 
+	else if (strcmp(cmd, "if") == 0)
+	{
+		ifState new_if_state = IFSTATE_IGNORED;
+		if (psqlscan_branch_active(scan_state))
+		{
+			bool if_true = false;
+			success = read_boolean_expression(scan_state, "if", &if_true);
+			if (success)
+			{
+				if (if_true)
+					new_if_state = IFSTATE_TRUE;
+				else
+					new_if_state = IFSTATE_FALSE;
+			}
+		}
+		if (success)
+			psqlscan_branch_push(scan_state,new_if_state);
+		psql_scan_reset(scan_state);
+	}
+
+	else if (strcmp(cmd, "elif") == 0)
+	{
+		if (psqlscan_branch_empty(scan_state))
+		{
+			psql_error("encountered un-matched \\elif\n");
+			success = false;
+		}
+		else
+		{
+			bool elif_true = false;
+			switch (psqlscan_branch_get_state(scan_state))
+			{
+				case IFSTATE_IGNORED:
+					/* inactive branch, do nothing */
+					break;
+				case IFSTATE_TRUE:
+					/* just finished true section of active branch */
+					psqlscan_branch_set_state(scan_state, IFSTATE_IGNORED);
+					break;
+				case IFSTATE_FALSE:
+					/* determine if this section is true or not */
+					success = read_boolean_expression(scan_state, "elif",
+														&elif_true);
+					if (success)
+					{
+						if (elif_true)
+							psqlscan_branch_set_state(scan_state, IFSTATE_TRUE);
+					}
+					break;
+				case IFSTATE_ELSE_TRUE:
+				case IFSTATE_ELSE_FALSE:
+					psql_error("encountered \\elif after \\else\n");
+					success = false;
+					break;
+				default:
+					break;
+			}
+		}
+		psql_scan_reset(scan_state);
+	}
+
+	else if (strcmp(cmd, "else") == 0)
+	{
+		if (psqlscan_branch_empty(scan_state))
+		{
+			psql_error("encountered un-matched \\else\n");
+			success = false;
+		}
+		else
+		{
+			switch (psqlscan_branch_get_state(scan_state))
+			{
+				case IFSTATE_TRUE:
+					/* just finished true section of active branch */
+				case IFSTATE_IGNORED:
+					/* whole branch was inactive */
+					psqlscan_branch_set_state(scan_state, IFSTATE_ELSE_FALSE);
+					break;
+				case IFSTATE_FALSE:
+					/* just finished true section of active branch */
+					psqlscan_branch_set_state(scan_state, IFSTATE_ELSE_TRUE);
+					break;
+				case IFSTATE_ELSE_TRUE:
+				case IFSTATE_ELSE_FALSE:
+					psql_error("encountered \\else after \\else\n");
+					success = false;
+					break;
+				default:
+					break;
+			}
+		}
+		psql_scan_reset(scan_state);
+	}
+
+	else if (strcmp(cmd, "endif") == 0)
+	{
+		if (psqlscan_branch_empty(scan_state))
+		{
+			psql_error("encountered un-matched \\endif\n");
+			success = false;
+		}
+		else
+		{
+			psqlscan_branch_end_state(scan_state);
+		}
+		psql_scan_reset(scan_state);
+	}
+
 	/* \l is list databases */
 	else if (strcmp(cmd, "l") == 0 || strcmp(cmd, "list") == 0 ||
 			 strcmp(cmd, "l+") == 0 || strcmp(cmd, "list+") == 0)
diff --git a/src/bin/psql/mainloop.c b/src/bin/psql/mainloop.c
index bb306a4..7252824 100644
--- a/src/bin/psql/mainloop.c
+++ b/src/bin/psql/mainloop.c
@@ -15,7 +15,7 @@
 #include "settings.h"
 
 #include "mb/pg_wchar.h"
-
+#include "fe_utils/psqlscan_int.h"
 
 /* callback functions for our flex lexer */
 const PsqlScanCallbacks psqlscan_callbacks = {
@@ -23,7 +23,6 @@ const PsqlScanCallbacks psqlscan_callbacks = {
 	psql_error
 };
 
-
 /*
  * Main processing loop for reading lines of input
  *	and sending them to the backend.
@@ -51,6 +50,9 @@ MainLoop(FILE *source)
 	volatile int count_eof = 0;
 	volatile bool die_on_error = false;
 
+	/* only needed at the end to detect unbalanced ifs in scan_state */
+	bool if_endifs_balanced = true;
+
 	/* Save the prior command source */
 	FILE	   *prev_cmd_source;
 	bool		prev_cmd_interactive;
@@ -285,21 +287,28 @@ MainLoop(FILE *source)
 			if (scan_result == PSCAN_SEMICOLON ||
 				(scan_result == PSCAN_EOL && pset.singleline))
 			{
-				/*
-				 * Save query in history.  We use history_buf to accumulate
-				 * multi-line queries into a single history entry.
-				 */
-				if (pset.cur_cmd_interactive && !line_saved_in_history)
+				if (psqlscan_branch_active(scan_state))
 				{
-					pg_append_history(line, history_buf);
-					pg_send_history(history_buf);
-					line_saved_in_history = true;
+					/*
+					 * Save query in history.  We use history_buf to accumulate
+					 * multi-line queries into a single history entry.
+					 */
+					if (pset.cur_cmd_interactive && !line_saved_in_history)
+					{
+						pg_append_history(line, history_buf);
+						pg_send_history(history_buf);
+						line_saved_in_history = true;
+					}
+
+					/* execute query */
+					success = SendQuery(query_buf->data);
 				}
+				else
+					success = true;
 
-				/* execute query */
-				success = SendQuery(query_buf->data);
 				slashCmdStatus = success ? PSQL_CMD_SEND : PSQL_CMD_ERROR;
 				pset.stmt_lineno = 1;
+				slashCmdStatus = success ? PSQL_CMD_SEND : PSQL_CMD_ERROR;
 
 				/* transfer query to previous_buf by pointer-swapping */
 				{
@@ -358,15 +367,21 @@ MainLoop(FILE *source)
 
 				if (slashCmdStatus == PSQL_CMD_SEND)
 				{
-					success = SendQuery(query_buf->data);
-
-					/* transfer query to previous_buf by pointer-swapping */
+					if (psqlscan_branch_active(scan_state))
 					{
-						PQExpBuffer swap_buf = previous_buf;
+						success = SendQuery(query_buf->data);
 
-						previous_buf = query_buf;
-						query_buf = swap_buf;
+						/* transfer query to previous_buf by pointer-swapping */
+						{
+							PQExpBuffer swap_buf = previous_buf;
+
+							previous_buf = query_buf;
+							query_buf = swap_buf;
+						}
 					}
+					else
+						success = true;
+
 					resetPQExpBuffer(query_buf);
 
 					/* flush any paren nesting info after forced send */
@@ -425,12 +440,17 @@ MainLoop(FILE *source)
 	if (query_buf->len > 0 && !pset.cur_cmd_interactive &&
 		successResult == EXIT_SUCCESS)
 	{
-		/* save query in history */
-		if (pset.cur_cmd_interactive)
-			pg_send_history(history_buf);
+		if (psqlscan_branch_active(scan_state))
+		{
+			/* save query in history */
+			if (pset.cur_cmd_interactive)
+				pg_send_history(history_buf);
 
-		/* execute query */
-		success = SendQuery(query_buf->data);
+			/* execute query */
+			success = SendQuery(query_buf->data);
+		}
+		else
+			success = true;
 
 		if (!success && die_on_error)
 			successResult = EXIT_USER;
@@ -451,11 +471,17 @@ MainLoop(FILE *source)
 	destroyPQExpBuffer(previous_buf);
 	destroyPQExpBuffer(history_buf);
 
+	if (slashCmdStatus != PSQL_CMD_TERMINATE)
+		if_endifs_balanced = psqlscan_branch_empty(scan_state);
+
 	psql_scan_destroy(scan_state);
 
 	pset.cur_cmd_source = prev_cmd_source;
 	pset.cur_cmd_interactive = prev_cmd_interactive;
 	pset.lineno = prev_lineno;
 
+	if (! if_endifs_balanced )
+		psql_error("found EOF before closing \\endif(s)\n");
+
 	return successResult;
 }	/* MainLoop() */
diff --git a/src/bin/psql/mainloop.h b/src/bin/psql/mainloop.h
index 228a5e0..47f4c32 100644
--- a/src/bin/psql/mainloop.h
+++ b/src/bin/psql/mainloop.h
@@ -14,4 +14,5 @@ extern const PsqlScanCallbacks psqlscan_callbacks;
 
 extern int	MainLoop(FILE *source);
 
+
 #endif   /* MAINLOOP_H */
diff --git a/src/fe_utils/psqlscan.l b/src/fe_utils/psqlscan.l
index 1b29341..f70841c 100644
--- a/src/fe_utils/psqlscan.l
+++ b/src/fe_utils/psqlscan.l
@@ -904,6 +904,9 @@ psql_scan_create(const PsqlScanCallbacks *callbacks)
 
 	psql_scan_reset(state);
 
+	state->branch_stack = NULL;
+	state->branch_block_active = true;
+
 	return state;
 }
 
@@ -919,6 +922,13 @@ psql_scan_destroy(PsqlScanState state)
 
 	yylex_destroy(state->scanner);
 
+	while (state->branch_stack != NULL)
+	{
+		IfStackElem *p = state->branch_stack;
+		state->branch_stack = state->branch_stack->next;
+		free(p);
+	}
+
 	free(state);
 }
 
@@ -1426,3 +1436,103 @@ psqlscan_escape_variable(PsqlScanState state, const char *txt, int len,
 		psqlscan_emit(state, txt, len);
 	}
 }
+
+/*
+ * psqlscan_branch_empty
+ *
+ * True if there are no active \if-structures
+ */
+bool
+psqlscan_branch_empty(PsqlScanState state)
+{
+	return (state->branch_stack == NULL);
+}
+
+/*
+ * psqlscan_branch_active
+ *
+ * True if the current \if-block (if any) is true and queries/commands
+ * should be executed.
+ */
+bool
+psqlscan_branch_active(PsqlScanState state)
+{
+	return state->branch_block_active;
+}
+
+/*
+ * Fetch the current state of the top of the stack
+ */
+ifState
+psqlscan_branch_get_state(PsqlScanState state)
+{
+	if (psqlscan_branch_empty(state))
+		return IFSTATE_NONE;
+	return state->branch_stack->if_state;
+}
+
+/*
+ * psqlscan_branch_update_active
+ *
+ * Scan the branch_stack to determine whether the next statements
+ * can execute or should be skipped. Cache this result in
+ * branch_block_active.
+ */
+static void
+psqlscan_branch_update_active(PsqlScanState state)
+{
+	ifState s = psqlscan_branch_get_state(state);
+	state->branch_block_active  = ( (s == IFSTATE_NONE) ||
+									(s == IFSTATE_TRUE) ||
+									(s == IFSTATE_ELSE_TRUE));
+}
+
+/*
+ * psqlscan_branch_push
+ *
+ * Create a new \if branch.
+ */
+bool
+psqlscan_branch_push(PsqlScanState state, ifState new_state)
+{
+	IfStackElem *p = pg_malloc0(sizeof(IfStackElem));
+	p->if_state = new_state;
+	p->next = state->branch_stack;
+	state->branch_stack = p;
+	psqlscan_branch_update_active(state);
+	return true;
+}
+
+/*
+ * psqlscan_branch_set_state
+ *
+ * Change the state of the topmost branch.
+ * Returns false if there was branch state to set.
+ */
+bool
+psqlscan_branch_set_state(PsqlScanState state, ifState new_state)
+{
+	if (psqlscan_branch_empty(state))
+		return false;
+	state->branch_stack->if_state = new_state;
+	psqlscan_branch_update_active(state);
+	return true;
+}
+
+/*
+ * psqlscan_branch_end_state
+ *
+ * Destroy the topmost branch because and \endif was encountered.
+ * Returns false if there was no branch to end.
+ */
+bool
+psqlscan_branch_end_state(PsqlScanState state)
+{
+	IfStackElem *p = state->branch_stack;
+	if (!p)
+		return false;
+	state->branch_stack = state->branch_stack->next;
+	free(p);
+	psqlscan_branch_update_active(state);
+	return true;
+}
diff --git a/src/include/fe_utils/psqlscan_int.h b/src/include/fe_utils/psqlscan_int.h
index 0fddc7a..734e719 100644
--- a/src/include/fe_utils/psqlscan_int.h
+++ b/src/include/fe_utils/psqlscan_int.h
@@ -75,6 +75,30 @@ typedef struct StackElem
 	struct StackElem *next;
 } StackElem;
 
+typedef enum _ifState
+{
+	IFSTATE_NONE = 0,	/* Not currently in an \if block */
+	IFSTATE_TRUE,		/* currently in an \if or \elif which is true
+						 * and all parent branches (if any) are true */
+	IFSTATE_FALSE,		/* currently in an \if or \elif which is false
+						 * but no true branch has yet been seen,
+						 * and all parent branches (if any) are true */
+	IFSTATE_IGNORED,	/* currently in an \elif which follows a true \if
+						 * or the whole \if is a child of a false parent */
+	IFSTATE_ELSE_TRUE,	/* currently in an \else which is true
+						 * and all parent branches (if any) are true */
+	IFSTATE_ELSE_FALSE	/* currently in an \else which is false or ignored */
+} ifState;
+
+/*
+ * The state of nested ifs is stored in a stack.
+ */
+typedef struct IfStackElem
+{
+	ifState		if_state;
+	struct IfStackElem *next;
+} IfStackElem;
+
 /*
  * All working state of the lexer must be stored in PsqlScanStateData
  * between calls.  This allows us to have multiple open lexer operations,
@@ -118,6 +142,12 @@ typedef struct PsqlScanStateData
 	 * Callback functions provided by the program making use of the lexer.
 	 */
 	const PsqlScanCallbacks *callbacks;
+
+	/*
+	 * \if branch state variables
+	 */
+	IfStackElem *branch_stack;
+	bool branch_block_active;
 } PsqlScanStateData;
 
 
@@ -141,4 +171,21 @@ extern void psqlscan_escape_variable(PsqlScanState state,
 						 const char *txt, int len,
 						 bool as_ident);
 
+/*
+ * branching commands
+ */
+extern bool psqlscan_branch_empty(PsqlScanState state);
+
+extern bool psqlscan_branch_active(PsqlScanState state);
+
+extern ifState psqlscan_branch_get_state(PsqlScanState state);
+
+extern bool psqlscan_branch_push(PsqlScanState state,
+									ifState new_state);
+
+extern bool psqlscan_branch_set_state(PsqlScanState state,
+									ifState new_state);
+
+extern bool psqlscan_branch_end_state(PsqlScanState state);
+
 #endif   /* PSQLSCAN_INT_H */
diff --git a/src/test/regress/expected/psql.out b/src/test/regress/expected/psql.out
index 464436a..1dcaa46 100644
--- a/src/test/regress/expected/psql.out
+++ b/src/test/regress/expected/psql.out
@@ -2686,6 +2686,66 @@ deallocate q;
 \pset format aligned
 \pset expanded off
 \pset border 1
+\if true
+	\if 1
+		\if yes
+			\if on
+				\echo 'all true'
+all true
+			\else
+				\echo 'should not print #1-1'
+			\endif
+		\else
+			\echo 'should not print #1-2'
+		\endif
+	\else
+		\echo 'should not print #1-3'
+	\endif
+\else 
+	\echo 'should not print #1-4'
+\endif
+\if false
+	\echo 'should not print #2-1'
+\elif 0
+	\echo 'should not print #2-2'
+\elif no
+	\echo 'should not print #2-3'
+\elif off
+	\echo 'should not print #2-4'
+\else
+	\echo 'all false'
+all false
+\endif
+\if true
+	\echo 'first thing true'
+first thing true
+\else
+	\echo 'should not print #3-1'
+\endif
+\if false
+	\echo 'should not print #4-1'
+\elif true
+	\echo 'second thing true'
+second thing true
+\else
+	\echo 'should not print #5-1'
+\endif
+\endif
+encountered un-matched \endif
+\else
+encountered un-matched \else
+\elif
+encountered un-matched \elif
+\if true
+\else
+\else
+encountered \else after \else
+\endif
+\if false
+\else
+\elif
+encountered \elif after \else
+\endif
 -- SHOW_CONTEXT
 \set SHOW_CONTEXT never
 do $$
diff --git a/src/test/regress/sql/psql.sql b/src/test/regress/sql/psql.sql
index 900aa7e..4f41894 100644
--- a/src/test/regress/sql/psql.sql
+++ b/src/test/regress/sql/psql.sql
@@ -357,6 +357,66 @@ deallocate q;
 \pset expanded off
 \pset border 1
 
+\if true
+	\if 1
+		\if yes
+			\if on
+				\echo 'all true'
+			\else
+				\echo 'should not print #1-1'
+			\endif
+		\else
+			\echo 'should not print #1-2'
+		\endif
+	\else
+		\echo 'should not print #1-3'
+	\endif
+\else
+	\echo 'should not print #1-4'
+\endif
+
+\if false
+	\echo 'should not print #2-1'
+\elif 0
+	\echo 'should not print #2-2'
+\elif no
+	\echo 'should not print #2-3'
+\elif off
+	\echo 'should not print #2-4'
+\else
+	\echo 'all false'
+\endif
+
+\if true
+	\echo 'first thing true'
+\else
+	\echo 'should not print #3-1'
+\endif
+
+\if false
+	\echo 'should not print #4-1'
+\elif true
+	\echo 'second thing true'
+\else
+	\echo 'should not print #5-1'
+\endif
+
+\endif
+
+\else
+
+\elif
+
+\if true
+\else
+\else
+\endif
+
+\if false
+\else
+\elif
+\endif
+
 -- SHOW_CONTEXT
 
 \set SHOW_CONTEXT never


-- 
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers

Attachments:

  [text/plain] 0001.if_endif.v2.diff (20.4K, ../../CADkLM=eLeC+xpKsqE92etfhnQRw83YM42QFAm+PtQTDso-bPow@mail.gmail.com/3-0001.if_endif.v2.diff)
  download | inline diff:
diff --git a/doc/src/sgml/ref/psql-ref.sgml b/doc/src/sgml/ref/psql-ref.sgml
index 9915731..20091e5 100644
--- a/doc/src/sgml/ref/psql-ref.sgml
+++ b/doc/src/sgml/ref/psql-ref.sgml
@@ -2007,6 +2007,78 @@ hello 10
         </listitem>
       </varlistentry>
 
+      <varlistentry>
+        <term><literal>\if</literal> <replaceable class="parameter">expr</replaceable></term>
+        <term><literal>\elif</literal> <replaceable class="parameter">expr</replaceable></term>
+        <term><literal>\else</literal></term>
+        <term><literal>\endif</literal></term>
+        <listitem>
+        <para>
+        This group of commands implements nestable conditional blocks, like
+        this:
+        </para>
+<programlisting>
+SELECT
+    EXISTS(SELECT 1 FROM customer) as has_customers,
+    EXISTS(SELECT 1 FROM employee) as has_employees
+\gset
+\if :has_users
+    SELECT * FROM customer ORDER BY creation_date LIMIT 5;
+\elif :has_employees
+    \echo 'no customers found'
+    SELECT * FROM employee ORDER BY creation_date LIMIT 5;
+\else
+    \if yes
+        \echo 'No customers or employees'
+    \else
+        \echo 'this should never print'
+    \endif
+\endif
+</programlisting>
+        <para>
+        Conditional blocks must begin with a <command>\if</command> and end
+        with an <command>\endif</command>, and the pairs must be found in
+        the same source file. If an EOF is reached on the main file or an
+        <command>\include</command>-ed file before all 
+        <command>\if</command>-<command>\endif</command> are matched, then
+        psql will raise an error.
+        </para>
+        <para>
+        The <command>\if</command> and <command>\elif</command> commands
+        read the rest of the line and evaluate it as a boolean expression.
+        Currently, expressions are limited to a single unquoted string
+        which is evaluated like other options booleans, so the valid values
+        are any unabiguous case insensitive matches for one of:
+        <literal>true</literal>, <literal>false</literal>, <literal>1</literal>,
+        <literal>0</literal>, <literal>on</literal>, <literal>off</literal>,
+        <literal>yes</literal>, <literal>no</literal>.  So 
+        <literal>t</literal>, <literal>T</literal>, and <literal>tR</literal>
+        will all match <literal>true</literal>.
+        </para>
+        <para>
+        Queries within a false branch of a conditional block will not be
+        sent to the server.
+        </para>
+        <para>
+        Non-conditional <command>\</command>-commands within a false branch
+        of a conditional block will not be evaluated for correctness. The
+        command will be ignored along with all remaining input to the end
+        of the line.
+        </para>
+        <para>
+        Expressions on <command>\if</command> and <command>\elif</command>
+        commands within a false branch of a conditional block will not be
+        evaluated.
+        </para>
+        <para>
+        A conditional block can at most one <command>\else</command> command.
+        </para>
+        <para>
+        The <command>\elif</command> command cannot follow the
+        <command>\else</command> command.
+        </para>
+        </listitem>
+      </varlistentry>
 
       <varlistentry>
         <term><literal>\ir</literal> or <literal>\include_relative</literal> <replaceable class="parameter">filename</replaceable></term>
diff --git a/src/bin/psql/command.c b/src/bin/psql/command.c
index 4139b77..feb9ddc 100644
--- a/src/bin/psql/command.c
+++ b/src/bin/psql/command.c
@@ -49,6 +49,7 @@
 #include "psqlscanslash.h"
 #include "settings.h"
 #include "variables.h"
+#include "fe_utils/psqlscan_int.h"
 
 /*
  * Editable database object types.
@@ -132,7 +133,7 @@ HandleSlashCmds(PsqlScanState scan_state,
 		status = PSQL_CMD_ERROR;
 	}
 
-	if (status != PSQL_CMD_ERROR)
+	if (status != PSQL_CMD_ERROR && psqlscan_branch_active(scan_state))
 	{
 		/* eat any remaining arguments after a valid command */
 		/* note we suppress evaluation of backticks here */
@@ -194,6 +195,68 @@ read_connect_arg(PsqlScanState scan_state)
 	return result;
 }
 
+/*
+ * Read and interpret argument as a boolean expression.
+ * Return true if a boolean value was successfully parsed.
+ */
+static bool
+read_boolean_expression(PsqlScanState scan_state, char *action,
+						bool *result)
+{
+	bool	success = false;
+	char	*value = psql_scan_slash_option(scan_state,
+											OT_NORMAL, NULL, false);
+	/*
+	 * placeholder code until ParseVariableBool() ads error detection
+	 * once that patch is in place, use that instead
+	 */
+	if (value)
+	{
+		size_t		len;
+
+		if (value == NULL)
+			return false;			/* not set -> assume "off" */
+
+		len = strlen(value);
+
+		if ((pg_strncasecmp(value, "true", len) == 0) ||
+			(pg_strncasecmp(value, "yes", len) == 0) ||
+			(pg_strncasecmp(value, "on", (len > 2 ? len : 2)) == 0) ||
+			(pg_strcasecmp(value, "1") == 0))
+		{
+			success = true;
+			*result = true;
+		}
+		else if ((pg_strncasecmp(value, "false", len) == 0) ||
+				 (pg_strncasecmp(value, "no", len) == 0) ||
+				 (pg_strncasecmp(value, "off", (len > 2 ? len : 2)) == 0) ||
+				 (pg_strcasecmp(value, "0") == 0))
+		{
+			success = true;
+			*result = false;
+		}
+		else
+		{
+			psql_error("\\%s: invalid boolean expression: %s\n",
+						action, value);
+		}
+		free(value);
+	}
+	else
+	{
+		psql_error("\\%s: no expression given\n",action);
+	}
+	return success;
+}
+
+static bool
+is_branching_command(const char *cmd)
+{
+	return ((strcmp(cmd, "if") == 0 || \
+			strcmp(cmd, "elif") == 0 || \
+			strcmp(cmd, "else") == 0 || \
+			strcmp(cmd, "endif") == 0));
+}
 
 /*
  * Subroutine to actually try to execute a backslash command.
@@ -207,6 +270,14 @@ exec_command(const char *cmd,
 								 * failed */
 	backslashResult status = PSQL_CMD_SKIP_LINE;
 
+	if (!psqlscan_branch_active(scan_state) && !is_branching_command(cmd) )
+	{
+		/* Continue with an empty buffer as if the command were never read */
+		resetPQExpBuffer(query_buf);
+		psql_scan_reset(scan_state);
+		return status;
+	}
+
 	/*
 	 * \a -- toggle field alignment This makes little sense but we keep it
 	 * around.
@@ -984,6 +1055,114 @@ exec_command(const char *cmd,
 		}
 	}
 
+	else if (strcmp(cmd, "if") == 0)
+	{
+		ifState new_if_state = IFSTATE_IGNORED;
+		if (psqlscan_branch_active(scan_state))
+		{
+			bool if_true = false;
+			success = read_boolean_expression(scan_state, "if", &if_true);
+			if (success)
+			{
+				if (if_true)
+					new_if_state = IFSTATE_TRUE;
+				else
+					new_if_state = IFSTATE_FALSE;
+			}
+		}
+		if (success)
+			psqlscan_branch_push(scan_state,new_if_state);
+		psql_scan_reset(scan_state);
+	}
+
+	else if (strcmp(cmd, "elif") == 0)
+	{
+		if (psqlscan_branch_empty(scan_state))
+		{
+			psql_error("encountered un-matched \\elif\n");
+			success = false;
+		}
+		else
+		{
+			bool elif_true = false;
+			switch (psqlscan_branch_get_state(scan_state))
+			{
+				case IFSTATE_IGNORED:
+					/* inactive branch, do nothing */
+					break;
+				case IFSTATE_TRUE:
+					/* just finished true section of active branch */
+					psqlscan_branch_set_state(scan_state, IFSTATE_IGNORED);
+					break;
+				case IFSTATE_FALSE:
+					/* determine if this section is true or not */
+					success = read_boolean_expression(scan_state, "elif",
+														&elif_true);
+					if (success)
+					{
+						if (elif_true)
+							psqlscan_branch_set_state(scan_state, IFSTATE_TRUE);
+					}
+					break;
+				case IFSTATE_ELSE_TRUE:
+				case IFSTATE_ELSE_FALSE:
+					psql_error("encountered \\elif after \\else\n");
+					success = false;
+					break;
+				default:
+					break;
+			}
+		}
+		psql_scan_reset(scan_state);
+	}
+
+	else if (strcmp(cmd, "else") == 0)
+	{
+		if (psqlscan_branch_empty(scan_state))
+		{
+			psql_error("encountered un-matched \\else\n");
+			success = false;
+		}
+		else
+		{
+			switch (psqlscan_branch_get_state(scan_state))
+			{
+				case IFSTATE_TRUE:
+					/* just finished true section of active branch */
+				case IFSTATE_IGNORED:
+					/* whole branch was inactive */
+					psqlscan_branch_set_state(scan_state, IFSTATE_ELSE_FALSE);
+					break;
+				case IFSTATE_FALSE:
+					/* just finished true section of active branch */
+					psqlscan_branch_set_state(scan_state, IFSTATE_ELSE_TRUE);
+					break;
+				case IFSTATE_ELSE_TRUE:
+				case IFSTATE_ELSE_FALSE:
+					psql_error("encountered \\else after \\else\n");
+					success = false;
+					break;
+				default:
+					break;
+			}
+		}
+		psql_scan_reset(scan_state);
+	}
+
+	else if (strcmp(cmd, "endif") == 0)
+	{
+		if (psqlscan_branch_empty(scan_state))
+		{
+			psql_error("encountered un-matched \\endif\n");
+			success = false;
+		}
+		else
+		{
+			psqlscan_branch_end_state(scan_state);
+		}
+		psql_scan_reset(scan_state);
+	}
+
 	/* \l is list databases */
 	else if (strcmp(cmd, "l") == 0 || strcmp(cmd, "list") == 0 ||
 			 strcmp(cmd, "l+") == 0 || strcmp(cmd, "list+") == 0)
diff --git a/src/bin/psql/mainloop.c b/src/bin/psql/mainloop.c
index bb306a4..7252824 100644
--- a/src/bin/psql/mainloop.c
+++ b/src/bin/psql/mainloop.c
@@ -15,7 +15,7 @@
 #include "settings.h"
 
 #include "mb/pg_wchar.h"
-
+#include "fe_utils/psqlscan_int.h"
 
 /* callback functions for our flex lexer */
 const PsqlScanCallbacks psqlscan_callbacks = {
@@ -23,7 +23,6 @@ const PsqlScanCallbacks psqlscan_callbacks = {
 	psql_error
 };
 
-
 /*
  * Main processing loop for reading lines of input
  *	and sending them to the backend.
@@ -51,6 +50,9 @@ MainLoop(FILE *source)
 	volatile int count_eof = 0;
 	volatile bool die_on_error = false;
 
+	/* only needed at the end to detect unbalanced ifs in scan_state */
+	bool if_endifs_balanced = true;
+
 	/* Save the prior command source */
 	FILE	   *prev_cmd_source;
 	bool		prev_cmd_interactive;
@@ -285,21 +287,28 @@ MainLoop(FILE *source)
 			if (scan_result == PSCAN_SEMICOLON ||
 				(scan_result == PSCAN_EOL && pset.singleline))
 			{
-				/*
-				 * Save query in history.  We use history_buf to accumulate
-				 * multi-line queries into a single history entry.
-				 */
-				if (pset.cur_cmd_interactive && !line_saved_in_history)
+				if (psqlscan_branch_active(scan_state))
 				{
-					pg_append_history(line, history_buf);
-					pg_send_history(history_buf);
-					line_saved_in_history = true;
+					/*
+					 * Save query in history.  We use history_buf to accumulate
+					 * multi-line queries into a single history entry.
+					 */
+					if (pset.cur_cmd_interactive && !line_saved_in_history)
+					{
+						pg_append_history(line, history_buf);
+						pg_send_history(history_buf);
+						line_saved_in_history = true;
+					}
+
+					/* execute query */
+					success = SendQuery(query_buf->data);
 				}
+				else
+					success = true;
 
-				/* execute query */
-				success = SendQuery(query_buf->data);
 				slashCmdStatus = success ? PSQL_CMD_SEND : PSQL_CMD_ERROR;
 				pset.stmt_lineno = 1;
+				slashCmdStatus = success ? PSQL_CMD_SEND : PSQL_CMD_ERROR;
 
 				/* transfer query to previous_buf by pointer-swapping */
 				{
@@ -358,15 +367,21 @@ MainLoop(FILE *source)
 
 				if (slashCmdStatus == PSQL_CMD_SEND)
 				{
-					success = SendQuery(query_buf->data);
-
-					/* transfer query to previous_buf by pointer-swapping */
+					if (psqlscan_branch_active(scan_state))
 					{
-						PQExpBuffer swap_buf = previous_buf;
+						success = SendQuery(query_buf->data);
 
-						previous_buf = query_buf;
-						query_buf = swap_buf;
+						/* transfer query to previous_buf by pointer-swapping */
+						{
+							PQExpBuffer swap_buf = previous_buf;
+
+							previous_buf = query_buf;
+							query_buf = swap_buf;
+						}
 					}
+					else
+						success = true;
+
 					resetPQExpBuffer(query_buf);
 
 					/* flush any paren nesting info after forced send */
@@ -425,12 +440,17 @@ MainLoop(FILE *source)
 	if (query_buf->len > 0 && !pset.cur_cmd_interactive &&
 		successResult == EXIT_SUCCESS)
 	{
-		/* save query in history */
-		if (pset.cur_cmd_interactive)
-			pg_send_history(history_buf);
+		if (psqlscan_branch_active(scan_state))
+		{
+			/* save query in history */
+			if (pset.cur_cmd_interactive)
+				pg_send_history(history_buf);
 
-		/* execute query */
-		success = SendQuery(query_buf->data);
+			/* execute query */
+			success = SendQuery(query_buf->data);
+		}
+		else
+			success = true;
 
 		if (!success && die_on_error)
 			successResult = EXIT_USER;
@@ -451,11 +471,17 @@ MainLoop(FILE *source)
 	destroyPQExpBuffer(previous_buf);
 	destroyPQExpBuffer(history_buf);
 
+	if (slashCmdStatus != PSQL_CMD_TERMINATE)
+		if_endifs_balanced = psqlscan_branch_empty(scan_state);
+
 	psql_scan_destroy(scan_state);
 
 	pset.cur_cmd_source = prev_cmd_source;
 	pset.cur_cmd_interactive = prev_cmd_interactive;
 	pset.lineno = prev_lineno;
 
+	if (! if_endifs_balanced )
+		psql_error("found EOF before closing \\endif(s)\n");
+
 	return successResult;
 }	/* MainLoop() */
diff --git a/src/bin/psql/mainloop.h b/src/bin/psql/mainloop.h
index 228a5e0..47f4c32 100644
--- a/src/bin/psql/mainloop.h
+++ b/src/bin/psql/mainloop.h
@@ -14,4 +14,5 @@ extern const PsqlScanCallbacks psqlscan_callbacks;
 
 extern int	MainLoop(FILE *source);
 
+
 #endif   /* MAINLOOP_H */
diff --git a/src/fe_utils/psqlscan.l b/src/fe_utils/psqlscan.l
index 1b29341..f70841c 100644
--- a/src/fe_utils/psqlscan.l
+++ b/src/fe_utils/psqlscan.l
@@ -904,6 +904,9 @@ psql_scan_create(const PsqlScanCallbacks *callbacks)
 
 	psql_scan_reset(state);
 
+	state->branch_stack = NULL;
+	state->branch_block_active = true;
+
 	return state;
 }
 
@@ -919,6 +922,13 @@ psql_scan_destroy(PsqlScanState state)
 
 	yylex_destroy(state->scanner);
 
+	while (state->branch_stack != NULL)
+	{
+		IfStackElem *p = state->branch_stack;
+		state->branch_stack = state->branch_stack->next;
+		free(p);
+	}
+
 	free(state);
 }
 
@@ -1426,3 +1436,103 @@ psqlscan_escape_variable(PsqlScanState state, const char *txt, int len,
 		psqlscan_emit(state, txt, len);
 	}
 }
+
+/*
+ * psqlscan_branch_empty
+ *
+ * True if there are no active \if-structures
+ */
+bool
+psqlscan_branch_empty(PsqlScanState state)
+{
+	return (state->branch_stack == NULL);
+}
+
+/*
+ * psqlscan_branch_active
+ *
+ * True if the current \if-block (if any) is true and queries/commands
+ * should be executed.
+ */
+bool
+psqlscan_branch_active(PsqlScanState state)
+{
+	return state->branch_block_active;
+}
+
+/*
+ * Fetch the current state of the top of the stack
+ */
+ifState
+psqlscan_branch_get_state(PsqlScanState state)
+{
+	if (psqlscan_branch_empty(state))
+		return IFSTATE_NONE;
+	return state->branch_stack->if_state;
+}
+
+/*
+ * psqlscan_branch_update_active
+ *
+ * Scan the branch_stack to determine whether the next statements
+ * can execute or should be skipped. Cache this result in
+ * branch_block_active.
+ */
+static void
+psqlscan_branch_update_active(PsqlScanState state)
+{
+	ifState s = psqlscan_branch_get_state(state);
+	state->branch_block_active  = ( (s == IFSTATE_NONE) ||
+									(s == IFSTATE_TRUE) ||
+									(s == IFSTATE_ELSE_TRUE));
+}
+
+/*
+ * psqlscan_branch_push
+ *
+ * Create a new \if branch.
+ */
+bool
+psqlscan_branch_push(PsqlScanState state, ifState new_state)
+{
+	IfStackElem *p = pg_malloc0(sizeof(IfStackElem));
+	p->if_state = new_state;
+	p->next = state->branch_stack;
+	state->branch_stack = p;
+	psqlscan_branch_update_active(state);
+	return true;
+}
+
+/*
+ * psqlscan_branch_set_state
+ *
+ * Change the state of the topmost branch.
+ * Returns false if there was branch state to set.
+ */
+bool
+psqlscan_branch_set_state(PsqlScanState state, ifState new_state)
+{
+	if (psqlscan_branch_empty(state))
+		return false;
+	state->branch_stack->if_state = new_state;
+	psqlscan_branch_update_active(state);
+	return true;
+}
+
+/*
+ * psqlscan_branch_end_state
+ *
+ * Destroy the topmost branch because and \endif was encountered.
+ * Returns false if there was no branch to end.
+ */
+bool
+psqlscan_branch_end_state(PsqlScanState state)
+{
+	IfStackElem *p = state->branch_stack;
+	if (!p)
+		return false;
+	state->branch_stack = state->branch_stack->next;
+	free(p);
+	psqlscan_branch_update_active(state);
+	return true;
+}
diff --git a/src/include/fe_utils/psqlscan_int.h b/src/include/fe_utils/psqlscan_int.h
index 0fddc7a..734e719 100644
--- a/src/include/fe_utils/psqlscan_int.h
+++ b/src/include/fe_utils/psqlscan_int.h
@@ -75,6 +75,30 @@ typedef struct StackElem
 	struct StackElem *next;
 } StackElem;
 
+typedef enum _ifState
+{
+	IFSTATE_NONE = 0,	/* Not currently in an \if block */
+	IFSTATE_TRUE,		/* currently in an \if or \elif which is true
+						 * and all parent branches (if any) are true */
+	IFSTATE_FALSE,		/* currently in an \if or \elif which is false
+						 * but no true branch has yet been seen,
+						 * and all parent branches (if any) are true */
+	IFSTATE_IGNORED,	/* currently in an \elif which follows a true \if
+						 * or the whole \if is a child of a false parent */
+	IFSTATE_ELSE_TRUE,	/* currently in an \else which is true
+						 * and all parent branches (if any) are true */
+	IFSTATE_ELSE_FALSE	/* currently in an \else which is false or ignored */
+} ifState;
+
+/*
+ * The state of nested ifs is stored in a stack.
+ */
+typedef struct IfStackElem
+{
+	ifState		if_state;
+	struct IfStackElem *next;
+} IfStackElem;
+
 /*
  * All working state of the lexer must be stored in PsqlScanStateData
  * between calls.  This allows us to have multiple open lexer operations,
@@ -118,6 +142,12 @@ typedef struct PsqlScanStateData
 	 * Callback functions provided by the program making use of the lexer.
 	 */
 	const PsqlScanCallbacks *callbacks;
+
+	/*
+	 * \if branch state variables
+	 */
+	IfStackElem *branch_stack;
+	bool branch_block_active;
 } PsqlScanStateData;
 
 
@@ -141,4 +171,21 @@ extern void psqlscan_escape_variable(PsqlScanState state,
 						 const char *txt, int len,
 						 bool as_ident);
 
+/*
+ * branching commands
+ */
+extern bool psqlscan_branch_empty(PsqlScanState state);
+
+extern bool psqlscan_branch_active(PsqlScanState state);
+
+extern ifState psqlscan_branch_get_state(PsqlScanState state);
+
+extern bool psqlscan_branch_push(PsqlScanState state,
+									ifState new_state);
+
+extern bool psqlscan_branch_set_state(PsqlScanState state,
+									ifState new_state);
+
+extern bool psqlscan_branch_end_state(PsqlScanState state);
+
 #endif   /* PSQLSCAN_INT_H */
diff --git a/src/test/regress/expected/psql.out b/src/test/regress/expected/psql.out
index 464436a..1dcaa46 100644
--- a/src/test/regress/expected/psql.out
+++ b/src/test/regress/expected/psql.out
@@ -2686,6 +2686,66 @@ deallocate q;
 \pset format aligned
 \pset expanded off
 \pset border 1
+\if true
+	\if 1
+		\if yes
+			\if on
+				\echo 'all true'
+all true
+			\else
+				\echo 'should not print #1-1'
+			\endif
+		\else
+			\echo 'should not print #1-2'
+		\endif
+	\else
+		\echo 'should not print #1-3'
+	\endif
+\else 
+	\echo 'should not print #1-4'
+\endif
+\if false
+	\echo 'should not print #2-1'
+\elif 0
+	\echo 'should not print #2-2'
+\elif no
+	\echo 'should not print #2-3'
+\elif off
+	\echo 'should not print #2-4'
+\else
+	\echo 'all false'
+all false
+\endif
+\if true
+	\echo 'first thing true'
+first thing true
+\else
+	\echo 'should not print #3-1'
+\endif
+\if false
+	\echo 'should not print #4-1'
+\elif true
+	\echo 'second thing true'
+second thing true
+\else
+	\echo 'should not print #5-1'
+\endif
+\endif
+encountered un-matched \endif
+\else
+encountered un-matched \else
+\elif
+encountered un-matched \elif
+\if true
+\else
+\else
+encountered \else after \else
+\endif
+\if false
+\else
+\elif
+encountered \elif after \else
+\endif
 -- SHOW_CONTEXT
 \set SHOW_CONTEXT never
 do $$
diff --git a/src/test/regress/sql/psql.sql b/src/test/regress/sql/psql.sql
index 900aa7e..4f41894 100644
--- a/src/test/regress/sql/psql.sql
+++ b/src/test/regress/sql/psql.sql
@@ -357,6 +357,66 @@ deallocate q;
 \pset expanded off
 \pset border 1
 
+\if true
+	\if 1
+		\if yes
+			\if on
+				\echo 'all true'
+			\else
+				\echo 'should not print #1-1'
+			\endif
+		\else
+			\echo 'should not print #1-2'
+		\endif
+	\else
+		\echo 'should not print #1-3'
+	\endif
+\else
+	\echo 'should not print #1-4'
+\endif
+
+\if false
+	\echo 'should not print #2-1'
+\elif 0
+	\echo 'should not print #2-2'
+\elif no
+	\echo 'should not print #2-3'
+\elif off
+	\echo 'should not print #2-4'
+\else
+	\echo 'all false'
+\endif
+
+\if true
+	\echo 'first thing true'
+\else
+	\echo 'should not print #3-1'
+\endif
+
+\if false
+	\echo 'should not print #4-1'
+\elif true
+	\echo 'second thing true'
+\else
+	\echo 'should not print #5-1'
+\endif
+
+\endif
+
+\else
+
+\elif
+
+\if true
+\else
+\else
+\endif
+
+\if false
+\else
+\elif
+\endif
+
 -- SHOW_CONTEXT
 
 \set SHOW_CONTEXT never


^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-01-26 20:15  Daniel Verite <daniel@manitou-mail.org>
  parent: Corey Huinker <corey.huinker@gmail.com>
  0 siblings, 1 reply; 232+ messages in thread

From: Daniel Verite @ 2017-01-26 20:15 UTC (permalink / raw)
  To: Corey Huinker <corey.huinker@gmail.com>; +Cc: Fabien COELHO <coelho@cri.ensmp.fr>; pgsql-hackers

	Corey Huinker wrote:

> Revised patch

A comment about control flow and variables:
in branches that are not taken, variables are expanded 
nonetheless, in a way that can be surprising.
Case in point:

\set var 'ab''cd'
-- select :var; 
\if false
  select :var ;
\else
  select 1;
\endif

The 2nd reference to :var has a quoting hazard, but since it's within
an "\if false" branch, at a glance it seems like this script might work.
In fact it barfs with:
  psql:script.sql:0: found EOF before closing \endif(s)

AFAICS what happens is that :var gets injected and starts a
runaway string, so that as far as the parser is concerned
the \else ..\endif block slips into the untaken branch, as a part of
that unfinished string.

This contrasts with line 2: -- select :var
where the reference to :var is inoffensive.

To avoid that kind of trouble, would it make sense not to expand
variables in untaken branches?

Best regards,
-- 
Daniel Vérité
PostgreSQL-powered mailer: http://www.manitou-mail.org
Twitter: @DanielVerite


-- 
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers



^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-01-26 20:55  Fabien COELHO <coelho@cri.ensmp.fr>
  parent: Daniel Verite <daniel@manitou-mail.org>
  0 siblings, 1 reply; 232+ messages in thread

From: Fabien COELHO @ 2017-01-26 20:55 UTC (permalink / raw)
  To: Daniel Verite <daniel@manitou-mail.org>; +Cc: Corey Huinker <corey.huinker@gmail.com>; pgsql-hackers


Hello Daniel,

> A comment about control flow and variables: in branches that are not 
> taken, variables are expanded nonetheless, in a way that can be 
> surprising. Case in point:
>
> \set var 'ab''cd'
> -- select :var;
> \if false
>  select :var ;
> \else
>  select 1;
> \endif
>
> To avoid that kind of trouble, would it make sense not to expand
> variables in untaken branches?

Hmmm. This case is somehow contrived (for a string, :'var' could be used, 
in which case escaping would avoid the hazard), but I think that what you 
suggest is a better behavior, if easy to implement.

-- 
Fabien.


-- 
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers



^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-01-26 21:06  Corey Huinker <corey.huinker@gmail.com>
  parent: Fabien COELHO <coelho@cri.ensmp.fr>
  0 siblings, 1 reply; 232+ messages in thread

From: Corey Huinker @ 2017-01-26 21:06 UTC (permalink / raw)
  To: Fabien COELHO <coelho@cri.ensmp.fr>; +Cc: Daniel Verite <daniel@manitou-mail.org>; pgsql-hackers

On Thu, Jan 26, 2017 at 3:55 PM, Fabien COELHO <coelho@cri.ensmp.fr> wrote:

>
> Hello Daniel,
>
> A comment about control flow and variables: in branches that are not
>> taken, variables are expanded nonetheless, in a way that can be surprising.
>> Case in point:
>>
>> \set var 'ab''cd'
>> -- select :var;
>> \if false
>>  select :var ;
>> \else
>>  select 1;
>> \endif
>>
>> To avoid that kind of trouble, would it make sense not to expand
>> variables in untaken branches?
>>
>
> Hmmm. This case is somehow contrived (for a string, :'var' could be used,
> in which case escaping would avoid the hazard), but I think that what you
> suggest is a better behavior, if easy to implement.
>
> --
> Fabien.
>

Good question, Daniel. Variable expansion seems to be done via
psql_get_variable which is invoked via callback, which means that I might
have to move branch_block_active into PsqlSettings. That's slightly
different because the existing boolean is scoped with MainLoop(), but
there's no way to get to a new MainLoop unless you're in an executing
branch, and no way to legally exit a MainLoop with an unbalanced if-endif
state. In short, I think it's better behavior. It does prevent someone from
setting a variable to '\endif' and expecting that to work, like this:

select case
     when random() < 0.5 then '\endif'
     else E'\else\n\echo fooled you\n\endif'
end as contrived_metaprogramming
\gset

\if false
  :contrived_metaprogramming


I'm sure someone will argue that preventing that is a good thing. Unless
someone sees a good reason not to move that PsqlSettings, I'll make that
change.

^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-01-27 22:43  Corey Huinker <corey.huinker@gmail.com>
  parent: Corey Huinker <corey.huinker@gmail.com>
  0 siblings, 1 reply; 232+ messages in thread

From: Corey Huinker @ 2017-01-27 22:43 UTC (permalink / raw)
  To: Fabien COELHO <coelho@cri.ensmp.fr>; +Cc: Daniel Verite <daniel@manitou-mail.org>; pgsql-hackers

On Thu, Jan 26, 2017 at 4:06 PM, Corey Huinker <corey.huinker@gmail.com>
wrote:

>
>
> On Thu, Jan 26, 2017 at 3:55 PM, Fabien COELHO <coelho@cri.ensmp.fr>
> wrote:
>
>>
>> Hello Daniel,
>>
>> A comment about control flow and variables: in branches that are not
>>> taken, variables are expanded nonetheless, in a way that can be surprising.
>>> Case in point:
>>>
>>> \set var 'ab''cd'
>>> -- select :var;
>>> \if false
>>>  select :var ;
>>> \else
>>>  select 1;
>>> \endif
>>>
>>> To avoid that kind of trouble, would it make sense not to expand
>>> variables in untaken branches?
>>>
>>
>> Hmmm. This case is somehow contrived (for a string, :'var' could be used,
>> in which case escaping would avoid the hazard), but I think that what you
>> suggest is a better behavior, if easy to implement.
>>
>> --
>> Fabien.
>>
>
> Good question, Daniel. Variable expansion seems to be done via
> psql_get_variable which is invoked via callback, which means that I might
> have to move branch_block_active into PsqlSettings. That's slightly
> different because the existing boolean is scoped with MainLoop(), but
> there's no way to get to a new MainLoop unless you're in an executing
> branch, and no way to legally exit a MainLoop with an unbalanced if-endif
> state. In short, I think it's better behavior. It does prevent someone from
> setting a variable to '\endif' and expecting that to work, like this:
>
> select case
>      when random() < 0.5 then '\endif'
>      else E'\else\n\echo fooled you\n\endif'
> end as contrived_metaprogramming
> \gset
>
> \if false
>   :contrived_metaprogramming
>
>
> I'm sure someone will argue that preventing that is a good thing. Unless
> someone sees a good reason not to move that PsqlSettings, I'll make that
> change.
>
>
And here it is
diff --git a/doc/src/sgml/ref/psql-ref.sgml b/doc/src/sgml/ref/psql-ref.sgml
index 640fe12..fcf265b 100644
--- a/doc/src/sgml/ref/psql-ref.sgml
+++ b/doc/src/sgml/ref/psql-ref.sgml
@@ -2035,6 +2035,78 @@ hello 10
         </listitem>
       </varlistentry>
 
+      <varlistentry>
+        <term><literal>\if</literal> <replaceable class="parameter">expr</replaceable></term>
+        <term><literal>\elif</literal> <replaceable class="parameter">expr</replaceable></term>
+        <term><literal>\else</literal></term>
+        <term><literal>\endif</literal></term>
+        <listitem>
+        <para>
+        This group of commands implements nestable conditional blocks, like
+        this:
+        </para>
+<programlisting>
+SELECT
+    EXISTS(SELECT 1 FROM customer) as has_customers,
+    EXISTS(SELECT 1 FROM employee) as has_employees
+\gset
+\if :has_users
+    SELECT * FROM customer ORDER BY creation_date LIMIT 5;
+\elif :has_employees
+    \echo 'no customers found'
+    SELECT * FROM employee ORDER BY creation_date LIMIT 5;
+\else
+    \if yes
+        \echo 'No customers or employees'
+    \else
+        \echo 'this should never print'
+    \endif
+\endif
+</programlisting>
+        <para>
+        Conditional blocks must begin with a <command>\if</command> and end
+        with an <command>\endif</command>, and the pairs must be found in
+        the same source file. If an EOF is reached on the main file or an
+        <command>\include</command>-ed file before all 
+        <command>\if</command>-<command>\endif</command> are matched, then
+        psql will raise an error.
+        </para>
+        <para>
+        The <command>\if</command> and <command>\elif</command> commands
+        read the rest of the line and evaluate it as a boolean expression.
+        Currently, expressions are limited to a single unquoted string
+        which is evaluated like other options booleans, so the valid values
+        are any unabiguous case insensitive matches for one of:
+        <literal>true</literal>, <literal>false</literal>, <literal>1</literal>,
+        <literal>0</literal>, <literal>on</literal>, <literal>off</literal>,
+        <literal>yes</literal>, <literal>no</literal>.  So 
+        <literal>t</literal>, <literal>T</literal>, and <literal>tR</literal>
+        will all match <literal>true</literal>.
+        </para>
+        <para>
+        Queries within a false branch of a conditional block will not be
+        sent to the server.
+        </para>
+        <para>
+        Non-conditional <command>\</command>-commands within a false branch
+        of a conditional block will not be evaluated for correctness. The
+        command will be ignored along with all remaining input to the end
+        of the line.
+        </para>
+        <para>
+        Expressions on <command>\if</command> and <command>\elif</command>
+        commands within a false branch of a conditional block will not be
+        evaluated.
+        </para>
+        <para>
+        A conditional block can at most one <command>\else</command> command.
+        </para>
+        <para>
+        The <command>\elif</command> command cannot follow the
+        <command>\else</command> command.
+        </para>
+        </listitem>
+      </varlistentry>
 
       <varlistentry>
         <term><literal>\ir</literal> or <literal>\include_relative</literal> <replaceable class="parameter">filename</replaceable></term>
diff --git a/src/bin/psql/command.c b/src/bin/psql/command.c
index 0c164a3..8235015 100644
--- a/src/bin/psql/command.c
+++ b/src/bin/psql/command.c
@@ -49,6 +49,7 @@
 #include "psqlscanslash.h"
 #include "settings.h"
 #include "variables.h"
+#include "fe_utils/psqlscan_int.h"
 
 /*
  * Editable database object types.
@@ -132,7 +133,7 @@ HandleSlashCmds(PsqlScanState scan_state,
 		status = PSQL_CMD_ERROR;
 	}
 
-	if (status != PSQL_CMD_ERROR)
+	if (status != PSQL_CMD_ERROR && pset.active_branch)
 	{
 		/* eat any remaining arguments after a valid command */
 		/* note we suppress evaluation of backticks here */
@@ -194,6 +195,68 @@ read_connect_arg(PsqlScanState scan_state)
 	return result;
 }
 
+/*
+ * Read and interpret argument as a boolean expression.
+ * Return true if a boolean value was successfully parsed.
+ */
+static bool
+read_boolean_expression(PsqlScanState scan_state, char *action,
+						bool *result)
+{
+	bool	success = false;
+	char	*value = psql_scan_slash_option(scan_state,
+											OT_NORMAL, NULL, false);
+	/*
+	 * placeholder code until ParseVariableBool() ads error detection
+	 * once that patch is in place, use that instead
+	 */
+	if (value)
+	{
+		size_t		len;
+
+		if (value == NULL)
+			return false;			/* not set -> assume "off" */
+
+		len = strlen(value);
+
+		if ((pg_strncasecmp(value, "true", len) == 0) ||
+			(pg_strncasecmp(value, "yes", len) == 0) ||
+			(pg_strncasecmp(value, "on", (len > 2 ? len : 2)) == 0) ||
+			(pg_strcasecmp(value, "1") == 0))
+		{
+			success = true;
+			*result = true;
+		}
+		else if ((pg_strncasecmp(value, "false", len) == 0) ||
+				 (pg_strncasecmp(value, "no", len) == 0) ||
+				 (pg_strncasecmp(value, "off", (len > 2 ? len : 2)) == 0) ||
+				 (pg_strcasecmp(value, "0") == 0))
+		{
+			success = true;
+			*result = false;
+		}
+		else
+		{
+			psql_error("\\%s: invalid boolean expression: %s\n",
+						action, value);
+		}
+		free(value);
+	}
+	else
+	{
+		psql_error("\\%s: no expression given\n",action);
+	}
+	return success;
+}
+
+static bool
+is_branching_command(const char *cmd)
+{
+	return ((strcmp(cmd, "if") == 0 || \
+			strcmp(cmd, "elif") == 0 || \
+			strcmp(cmd, "else") == 0 || \
+			strcmp(cmd, "endif") == 0));
+}
 
 /*
  * Subroutine to actually try to execute a backslash command.
@@ -207,6 +270,14 @@ exec_command(const char *cmd,
 								 * failed */
 	backslashResult status = PSQL_CMD_SKIP_LINE;
 
+	if (!pset.active_branch && !is_branching_command(cmd) )
+	{
+		/* Continue with an empty buffer as if the command were never read */
+		resetPQExpBuffer(query_buf);
+		psql_scan_reset(scan_state);
+		return status;
+	}
+
 	/*
 	 * \a -- toggle field alignment This makes little sense but we keep it
 	 * around.
@@ -1000,6 +1071,141 @@ exec_command(const char *cmd,
 		}
 	}
 
+	else if (strcmp(cmd, "if") == 0)
+	{
+		ifState new_if_state = IFSTATE_IGNORED;
+		/*
+		 * only evaluate the expression for truth if the underlying
+		 * branch is active
+		 */
+		if (pset.active_branch)
+		{
+			bool if_true = false;
+			success = read_boolean_expression(scan_state, "if", &if_true);
+			if (success)
+			{
+				if (if_true)
+					new_if_state = IFSTATE_TRUE;
+				else
+					new_if_state = IFSTATE_FALSE;
+			}
+		}
+		if (success)
+		{
+			psqlscan_branch_push(scan_state,new_if_state);
+			pset.active_branch = psqlscan_branch_active(scan_state);
+		}
+		psql_scan_reset(scan_state);
+	}
+
+	else if (strcmp(cmd, "elif") == 0)
+	{
+		if (psqlscan_branch_empty(scan_state))
+		{
+			psql_error("encountered un-matched \\elif\n");
+			success = false;
+		}
+		else
+		{
+			bool elif_true = false;
+			switch (psqlscan_branch_get_state(scan_state))
+			{
+				case IFSTATE_IGNORED:
+					/*
+					 * inactive branch, do nothing:
+					 * either if-endif already had a true block,
+					 * or whole parent block is false.
+					 */
+					break;
+				case IFSTATE_TRUE:
+					/*
+					 * just finished true section of active branch
+					 * do not evaluate expression, just skip
+					 */
+					psqlscan_branch_set_state(scan_state, IFSTATE_IGNORED);
+					pset.active_branch = false;
+					break;
+				case IFSTATE_FALSE:
+					/*
+					 * have not yet found a true block in this if-endif,
+					 * determine if this section is true or not.
+					 */
+					/* switch variable expansion back on just for this line */
+					pset.active_branch = true;
+					success = read_boolean_expression(scan_state, "elif",
+														&elif_true);
+					pset.active_branch = false;
+					if (success)
+					{
+						if (elif_true)
+						{
+							psqlscan_branch_set_state(scan_state, IFSTATE_TRUE);
+							pset.active_branch = true;
+						}
+					}
+					break;
+				case IFSTATE_ELSE_TRUE:
+				case IFSTATE_ELSE_FALSE:
+					psql_error("encountered \\elif after \\else\n");
+					success = false;
+					break;
+				default:
+					break;
+			}
+		}
+		psql_scan_reset(scan_state);
+	}
+
+	else if (strcmp(cmd, "else") == 0)
+	{
+		if (psqlscan_branch_empty(scan_state))
+		{
+			psql_error("encountered un-matched \\else\n");
+			success = false;
+		}
+		else
+		{
+			switch (psqlscan_branch_get_state(scan_state))
+			{
+				case IFSTATE_TRUE:
+					/* just finished true section of active branch */
+				case IFSTATE_IGNORED:
+					/* whole branch was inactive */
+					psqlscan_branch_set_state(scan_state, IFSTATE_ELSE_FALSE);
+					pset.active_branch = false;
+					break;
+				case IFSTATE_FALSE:
+					/* just finished true section of active branch */
+					psqlscan_branch_set_state(scan_state, IFSTATE_ELSE_TRUE);
+					pset.active_branch = true;
+					break;
+				case IFSTATE_ELSE_TRUE:
+				case IFSTATE_ELSE_FALSE:
+					psql_error("encountered \\else after \\else\n");
+					success = false;
+					break;
+				default:
+					break;
+			}
+		}
+		psql_scan_reset(scan_state);
+	}
+
+	else if (strcmp(cmd, "endif") == 0)
+	{
+		if (psqlscan_branch_empty(scan_state))
+		{
+			psql_error("encountered un-matched \\endif\n");
+			success = false;
+		}
+		else
+		{
+			psqlscan_branch_end_state(scan_state);
+			pset.active_branch = psqlscan_branch_active(scan_state);
+		}
+		psql_scan_reset(scan_state);
+	}
+
 	/* \l is list databases */
 	else if (strcmp(cmd, "l") == 0 || strcmp(cmd, "list") == 0 ||
 			 strcmp(cmd, "l+") == 0 || strcmp(cmd, "list+") == 0)
diff --git a/src/bin/psql/common.c b/src/bin/psql/common.c
index e1b04de..a526008 100644
--- a/src/bin/psql/common.c
+++ b/src/bin/psql/common.c
@@ -126,6 +126,10 @@ psql_get_variable(const char *varname, bool escape, bool as_ident)
 	char	   *result;
 	const char *value;
 
+	/* do not expand variables the branch is inactive */
+	if (!pset.active_branch)
+		return NULL;
+
 	value = GetVariable(pset.vars, varname);
 	if (!value)
 		return NULL;
diff --git a/src/bin/psql/mainloop.c b/src/bin/psql/mainloop.c
index bb306a4..b8d4887 100644
--- a/src/bin/psql/mainloop.c
+++ b/src/bin/psql/mainloop.c
@@ -15,7 +15,7 @@
 #include "settings.h"
 
 #include "mb/pg_wchar.h"
-
+#include "fe_utils/psqlscan_int.h"
 
 /* callback functions for our flex lexer */
 const PsqlScanCallbacks psqlscan_callbacks = {
@@ -23,7 +23,6 @@ const PsqlScanCallbacks psqlscan_callbacks = {
 	psql_error
 };
 
-
 /*
  * Main processing loop for reading lines of input
  *	and sending them to the backend.
@@ -51,6 +50,9 @@ MainLoop(FILE *source)
 	volatile int count_eof = 0;
 	volatile bool die_on_error = false;
 
+	/* only needed at the end to detect unbalanced ifs in scan_state */
+	bool if_endifs_balanced = true;
+
 	/* Save the prior command source */
 	FILE	   *prev_cmd_source;
 	bool		prev_cmd_interactive;
@@ -285,21 +287,28 @@ MainLoop(FILE *source)
 			if (scan_result == PSCAN_SEMICOLON ||
 				(scan_result == PSCAN_EOL && pset.singleline))
 			{
-				/*
-				 * Save query in history.  We use history_buf to accumulate
-				 * multi-line queries into a single history entry.
-				 */
-				if (pset.cur_cmd_interactive && !line_saved_in_history)
+				if (pset.active_branch)
 				{
-					pg_append_history(line, history_buf);
-					pg_send_history(history_buf);
-					line_saved_in_history = true;
+					/*
+					 * Save query in history.  We use history_buf to accumulate
+					 * multi-line queries into a single history entry.
+					 */
+					if (pset.cur_cmd_interactive && !line_saved_in_history)
+					{
+						pg_append_history(line, history_buf);
+						pg_send_history(history_buf);
+						line_saved_in_history = true;
+					}
+
+					/* execute query */
+					success = SendQuery(query_buf->data);
 				}
+				else
+					success = true;
 
-				/* execute query */
-				success = SendQuery(query_buf->data);
 				slashCmdStatus = success ? PSQL_CMD_SEND : PSQL_CMD_ERROR;
 				pset.stmt_lineno = 1;
+				slashCmdStatus = success ? PSQL_CMD_SEND : PSQL_CMD_ERROR;
 
 				/* transfer query to previous_buf by pointer-swapping */
 				{
@@ -358,15 +367,21 @@ MainLoop(FILE *source)
 
 				if (slashCmdStatus == PSQL_CMD_SEND)
 				{
-					success = SendQuery(query_buf->data);
-
-					/* transfer query to previous_buf by pointer-swapping */
+					if (pset.active_branch)
 					{
-						PQExpBuffer swap_buf = previous_buf;
+						success = SendQuery(query_buf->data);
 
-						previous_buf = query_buf;
-						query_buf = swap_buf;
+						/* transfer query to previous_buf by pointer-swapping */
+						{
+							PQExpBuffer swap_buf = previous_buf;
+
+							previous_buf = query_buf;
+							query_buf = swap_buf;
+						}
 					}
+					else
+						success = true;
+
 					resetPQExpBuffer(query_buf);
 
 					/* flush any paren nesting info after forced send */
@@ -425,12 +440,17 @@ MainLoop(FILE *source)
 	if (query_buf->len > 0 && !pset.cur_cmd_interactive &&
 		successResult == EXIT_SUCCESS)
 	{
-		/* save query in history */
-		if (pset.cur_cmd_interactive)
-			pg_send_history(history_buf);
+		if (pset.active_branch)
+		{
+			/* save query in history */
+			if (pset.cur_cmd_interactive)
+				pg_send_history(history_buf);
 
-		/* execute query */
-		success = SendQuery(query_buf->data);
+			/* execute query */
+			success = SendQuery(query_buf->data);
+		}
+		else
+			success = true;
 
 		if (!success && die_on_error)
 			successResult = EXIT_USER;
@@ -451,11 +471,17 @@ MainLoop(FILE *source)
 	destroyPQExpBuffer(previous_buf);
 	destroyPQExpBuffer(history_buf);
 
+	if (slashCmdStatus != PSQL_CMD_TERMINATE)
+		if_endifs_balanced = psqlscan_branch_empty(scan_state);
+
 	psql_scan_destroy(scan_state);
 
 	pset.cur_cmd_source = prev_cmd_source;
 	pset.cur_cmd_interactive = prev_cmd_interactive;
 	pset.lineno = prev_lineno;
 
+	if (! if_endifs_balanced )
+		psql_error("found EOF before closing \\endif(s)\n");
+
 	return successResult;
 }	/* MainLoop() */
diff --git a/src/bin/psql/mainloop.h b/src/bin/psql/mainloop.h
index 228a5e0..47f4c32 100644
--- a/src/bin/psql/mainloop.h
+++ b/src/bin/psql/mainloop.h
@@ -14,4 +14,5 @@ extern const PsqlScanCallbacks psqlscan_callbacks;
 
 extern int	MainLoop(FILE *source);
 
+
 #endif   /* MAINLOOP_H */
diff --git a/src/bin/psql/settings.h b/src/bin/psql/settings.h
index 4c7c3b1..15d5599 100644
--- a/src/bin/psql/settings.h
+++ b/src/bin/psql/settings.h
@@ -114,6 +114,9 @@ typedef struct _psqlSettings
 
 	VariableSpace vars;			/* "shell variable" repository */
 
+	bool		active_branch;	/* true if session is not in an \if branch
+								 * or the current branch is true */
+
 	/*
 	 * The remaining fields are set by assign hooks associated with entries in
 	 * "vars".  They should not be set directly except by those hook
diff --git a/src/bin/psql/startup.c b/src/bin/psql/startup.c
index 85aac4a..b03ded4 100644
--- a/src/bin/psql/startup.c
+++ b/src/bin/psql/startup.c
@@ -128,6 +128,8 @@ main(int argc, char *argv[])
 	setvbuf(stderr, NULL, _IONBF, 0);
 #endif
 
+	pset.active_branch = true;
+
 	pset.progname = get_progname(argv[0]);
 
 	pset.db = NULL;
diff --git a/src/fe_utils/psqlscan.l b/src/fe_utils/psqlscan.l
index 1b29341..a09d404 100644
--- a/src/fe_utils/psqlscan.l
+++ b/src/fe_utils/psqlscan.l
@@ -904,6 +904,8 @@ psql_scan_create(const PsqlScanCallbacks *callbacks)
 
 	psql_scan_reset(state);
 
+	state->branch_stack = NULL;
+
 	return state;
 }
 
@@ -919,6 +921,13 @@ psql_scan_destroy(PsqlScanState state)
 
 	yylex_destroy(state->scanner);
 
+	while (state->branch_stack != NULL)
+	{
+		IfStackElem *p = state->branch_stack;
+		state->branch_stack = state->branch_stack->next;
+		free(p);
+	}
+
 	free(state);
 }
 
@@ -1426,3 +1435,88 @@ psqlscan_escape_variable(PsqlScanState state, const char *txt, int len,
 		psqlscan_emit(state, txt, len);
 	}
 }
+
+/*
+ * psqlscan_branch_empty
+ *
+ * True if there are no active \if-structures
+ */
+bool
+psqlscan_branch_empty(PsqlScanState state)
+{
+	return (state->branch_stack == NULL);
+}
+
+/*
+ * Fetch the current state of the top of the stack
+ */
+ifState
+psqlscan_branch_get_state(PsqlScanState state)
+{
+	if (psqlscan_branch_empty(state))
+		return IFSTATE_NONE;
+	return state->branch_stack->if_state;
+}
+
+/*
+ * psqlscan_branch_active
+ *
+ * True if the current \if-block (if any) is true and queries/commands
+ * should be executed.
+ */
+bool
+psqlscan_branch_active(PsqlScanState state)
+{
+	ifState s = psqlscan_branch_get_state(state);
+	return ((s == IFSTATE_NONE) ||
+			(s == IFSTATE_TRUE) ||
+			(s == IFSTATE_ELSE_TRUE));
+}
+
+
+/*
+ * psqlscan_branch_push
+ *
+ * Create a new \if branch.
+ */
+bool
+psqlscan_branch_push(PsqlScanState state, ifState new_state)
+{
+	IfStackElem *p = pg_malloc0(sizeof(IfStackElem));
+	p->if_state = new_state;
+	p->next = state->branch_stack;
+	state->branch_stack = p;
+	return true;
+}
+
+/*
+ * psqlscan_branch_set_state
+ *
+ * Change the state of the topmost branch.
+ * Returns false if there was branch state to set.
+ */
+bool
+psqlscan_branch_set_state(PsqlScanState state, ifState new_state)
+{
+	if (psqlscan_branch_empty(state))
+		return false;
+	state->branch_stack->if_state = new_state;
+	return true;
+}
+
+/*
+ * psqlscan_branch_end_state
+ *
+ * Destroy the topmost branch because and \endif was encountered.
+ * Returns false if there was no branch to end.
+ */
+bool
+psqlscan_branch_end_state(PsqlScanState state)
+{
+	IfStackElem *p = state->branch_stack;
+	if (!p)
+		return false;
+	state->branch_stack = state->branch_stack->next;
+	free(p);
+	return true;
+}
diff --git a/src/include/fe_utils/psqlscan_int.h b/src/include/fe_utils/psqlscan_int.h
index 0fddc7a..a24a5ac 100644
--- a/src/include/fe_utils/psqlscan_int.h
+++ b/src/include/fe_utils/psqlscan_int.h
@@ -75,6 +75,30 @@ typedef struct StackElem
 	struct StackElem *next;
 } StackElem;
 
+typedef enum _ifState
+{
+	IFSTATE_NONE = 0,	/* Not currently in an \if block */
+	IFSTATE_TRUE,		/* currently in an \if or \elif which is true
+						 * and all parent branches (if any) are true */
+	IFSTATE_FALSE,		/* currently in an \if or \elif which is false
+						 * but no true branch has yet been seen,
+						 * and all parent branches (if any) are true */
+	IFSTATE_IGNORED,	/* currently in an \elif which follows a true \if
+						 * or the whole \if is a child of a false parent */
+	IFSTATE_ELSE_TRUE,	/* currently in an \else which is true
+						 * and all parent branches (if any) are true */
+	IFSTATE_ELSE_FALSE	/* currently in an \else which is false or ignored */
+} ifState;
+
+/*
+ * The state of nested ifs is stored in a stack.
+ */
+typedef struct IfStackElem
+{
+	ifState		if_state;
+	struct IfStackElem *next;
+} IfStackElem;
+
 /*
  * All working state of the lexer must be stored in PsqlScanStateData
  * between calls.  This allows us to have multiple open lexer operations,
@@ -118,6 +142,11 @@ typedef struct PsqlScanStateData
 	 * Callback functions provided by the program making use of the lexer.
 	 */
 	const PsqlScanCallbacks *callbacks;
+
+	/*
+	 * \if branch state variables
+	 */
+	IfStackElem *branch_stack;
 } PsqlScanStateData;
 
 
@@ -141,4 +170,21 @@ extern void psqlscan_escape_variable(PsqlScanState state,
 						 const char *txt, int len,
 						 bool as_ident);
 
+/*
+ * branching commands
+ */
+extern bool psqlscan_branch_empty(PsqlScanState state);
+
+extern bool psqlscan_branch_active(PsqlScanState state);
+
+extern ifState psqlscan_branch_get_state(PsqlScanState state);
+
+extern bool psqlscan_branch_push(PsqlScanState state,
+									ifState new_state);
+
+extern bool psqlscan_branch_set_state(PsqlScanState state,
+									ifState new_state);
+
+extern bool psqlscan_branch_end_state(PsqlScanState state);
+
 #endif   /* PSQLSCAN_INT_H */
diff --git a/src/test/regress/expected/psql.out b/src/test/regress/expected/psql.out
index 464436a..5cc1130 100644
--- a/src/test/regress/expected/psql.out
+++ b/src/test/regress/expected/psql.out
@@ -2686,6 +2686,78 @@ deallocate q;
 \pset format aligned
 \pset expanded off
 \pset border 1
+\if true
+	\if 1
+		\if yes
+			\if on
+				\echo 'all true'
+all true
+			\else
+				\echo 'should not print #1-1'
+			\endif
+		\else
+			\echo 'should not print #1-2'
+		\endif
+	\else
+		\echo 'should not print #1-3'
+	\endif
+\else
+	\echo 'should not print #1-4'
+\endif
+\if false
+	\echo 'should not print #2-1'
+\elif 0
+	\echo 'should not print #2-2'
+\elif no
+	\echo 'should not print #2-3'
+\elif off
+	\echo 'should not print #2-4'
+\else
+	\echo 'all false'
+all false
+\endif
+\if true
+	\echo 'first thing true'
+first thing true
+\else
+	\echo 'should not print #3-1'
+\endif
+\if false
+	\echo 'should not print #4-1'
+\elif true
+	\echo 'second thing true'
+second thing true
+\else
+	\echo 'should not print #5-1'
+\endif
+\set var 'ab''cd'
+-- select :var;
+\if false
+  select :var ;
+\else
+  select 1;
+ ?column? 
+----------
+        1
+(1 row)
+
+\endif
+\endif
+encountered un-matched \endif
+\else
+encountered un-matched \else
+\elif
+encountered un-matched \elif
+\if true
+\else
+\else
+encountered \else after \else
+\endif
+\if false
+\else
+\elif
+encountered \elif after \else
+\endif
 -- SHOW_CONTEXT
 \set SHOW_CONTEXT never
 do $$
diff --git a/src/test/regress/sql/psql.sql b/src/test/regress/sql/psql.sql
index 900aa7e..8793aa2 100644
--- a/src/test/regress/sql/psql.sql
+++ b/src/test/regress/sql/psql.sql
@@ -357,6 +357,74 @@ deallocate q;
 \pset expanded off
 \pset border 1
 
+\if true
+	\if 1
+		\if yes
+			\if on
+				\echo 'all true'
+			\else
+				\echo 'should not print #1-1'
+			\endif
+		\else
+			\echo 'should not print #1-2'
+		\endif
+	\else
+		\echo 'should not print #1-3'
+	\endif
+\else
+	\echo 'should not print #1-4'
+\endif
+
+\if false
+	\echo 'should not print #2-1'
+\elif 0
+	\echo 'should not print #2-2'
+\elif no
+	\echo 'should not print #2-3'
+\elif off
+	\echo 'should not print #2-4'
+\else
+	\echo 'all false'
+\endif
+
+\if true
+	\echo 'first thing true'
+\else
+	\echo 'should not print #3-1'
+\endif
+
+\if false
+	\echo 'should not print #4-1'
+\elif true
+	\echo 'second thing true'
+\else
+	\echo 'should not print #5-1'
+\endif
+
+\set var 'ab''cd'
+-- select :var;
+\if false
+  select :var ;
+\else
+  select 1;
+\endif
+
+\endif
+
+\else
+
+\elif
+
+\if true
+\else
+\else
+\endif
+
+\if false
+\else
+\elif
+\endif
+
 -- SHOW_CONTEXT
 
 \set SHOW_CONTEXT never


-- 
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers

Attachments:

  [text/plain] 0001.if_endif.v3.diff (22.0K, ../../CADkLM=di=8WQRQDku6mfN=-pBqVQq_3osAARtVb6Tf0U8vyb7A@mail.gmail.com/3-0001.if_endif.v3.diff)
  download | inline diff:
diff --git a/doc/src/sgml/ref/psql-ref.sgml b/doc/src/sgml/ref/psql-ref.sgml
index 640fe12..fcf265b 100644
--- a/doc/src/sgml/ref/psql-ref.sgml
+++ b/doc/src/sgml/ref/psql-ref.sgml
@@ -2035,6 +2035,78 @@ hello 10
         </listitem>
       </varlistentry>
 
+      <varlistentry>
+        <term><literal>\if</literal> <replaceable class="parameter">expr</replaceable></term>
+        <term><literal>\elif</literal> <replaceable class="parameter">expr</replaceable></term>
+        <term><literal>\else</literal></term>
+        <term><literal>\endif</literal></term>
+        <listitem>
+        <para>
+        This group of commands implements nestable conditional blocks, like
+        this:
+        </para>
+<programlisting>
+SELECT
+    EXISTS(SELECT 1 FROM customer) as has_customers,
+    EXISTS(SELECT 1 FROM employee) as has_employees
+\gset
+\if :has_users
+    SELECT * FROM customer ORDER BY creation_date LIMIT 5;
+\elif :has_employees
+    \echo 'no customers found'
+    SELECT * FROM employee ORDER BY creation_date LIMIT 5;
+\else
+    \if yes
+        \echo 'No customers or employees'
+    \else
+        \echo 'this should never print'
+    \endif
+\endif
+</programlisting>
+        <para>
+        Conditional blocks must begin with a <command>\if</command> and end
+        with an <command>\endif</command>, and the pairs must be found in
+        the same source file. If an EOF is reached on the main file or an
+        <command>\include</command>-ed file before all 
+        <command>\if</command>-<command>\endif</command> are matched, then
+        psql will raise an error.
+        </para>
+        <para>
+        The <command>\if</command> and <command>\elif</command> commands
+        read the rest of the line and evaluate it as a boolean expression.
+        Currently, expressions are limited to a single unquoted string
+        which is evaluated like other options booleans, so the valid values
+        are any unabiguous case insensitive matches for one of:
+        <literal>true</literal>, <literal>false</literal>, <literal>1</literal>,
+        <literal>0</literal>, <literal>on</literal>, <literal>off</literal>,
+        <literal>yes</literal>, <literal>no</literal>.  So 
+        <literal>t</literal>, <literal>T</literal>, and <literal>tR</literal>
+        will all match <literal>true</literal>.
+        </para>
+        <para>
+        Queries within a false branch of a conditional block will not be
+        sent to the server.
+        </para>
+        <para>
+        Non-conditional <command>\</command>-commands within a false branch
+        of a conditional block will not be evaluated for correctness. The
+        command will be ignored along with all remaining input to the end
+        of the line.
+        </para>
+        <para>
+        Expressions on <command>\if</command> and <command>\elif</command>
+        commands within a false branch of a conditional block will not be
+        evaluated.
+        </para>
+        <para>
+        A conditional block can at most one <command>\else</command> command.
+        </para>
+        <para>
+        The <command>\elif</command> command cannot follow the
+        <command>\else</command> command.
+        </para>
+        </listitem>
+      </varlistentry>
 
       <varlistentry>
         <term><literal>\ir</literal> or <literal>\include_relative</literal> <replaceable class="parameter">filename</replaceable></term>
diff --git a/src/bin/psql/command.c b/src/bin/psql/command.c
index 0c164a3..8235015 100644
--- a/src/bin/psql/command.c
+++ b/src/bin/psql/command.c
@@ -49,6 +49,7 @@
 #include "psqlscanslash.h"
 #include "settings.h"
 #include "variables.h"
+#include "fe_utils/psqlscan_int.h"
 
 /*
  * Editable database object types.
@@ -132,7 +133,7 @@ HandleSlashCmds(PsqlScanState scan_state,
 		status = PSQL_CMD_ERROR;
 	}
 
-	if (status != PSQL_CMD_ERROR)
+	if (status != PSQL_CMD_ERROR && pset.active_branch)
 	{
 		/* eat any remaining arguments after a valid command */
 		/* note we suppress evaluation of backticks here */
@@ -194,6 +195,68 @@ read_connect_arg(PsqlScanState scan_state)
 	return result;
 }
 
+/*
+ * Read and interpret argument as a boolean expression.
+ * Return true if a boolean value was successfully parsed.
+ */
+static bool
+read_boolean_expression(PsqlScanState scan_state, char *action,
+						bool *result)
+{
+	bool	success = false;
+	char	*value = psql_scan_slash_option(scan_state,
+											OT_NORMAL, NULL, false);
+	/*
+	 * placeholder code until ParseVariableBool() ads error detection
+	 * once that patch is in place, use that instead
+	 */
+	if (value)
+	{
+		size_t		len;
+
+		if (value == NULL)
+			return false;			/* not set -> assume "off" */
+
+		len = strlen(value);
+
+		if ((pg_strncasecmp(value, "true", len) == 0) ||
+			(pg_strncasecmp(value, "yes", len) == 0) ||
+			(pg_strncasecmp(value, "on", (len > 2 ? len : 2)) == 0) ||
+			(pg_strcasecmp(value, "1") == 0))
+		{
+			success = true;
+			*result = true;
+		}
+		else if ((pg_strncasecmp(value, "false", len) == 0) ||
+				 (pg_strncasecmp(value, "no", len) == 0) ||
+				 (pg_strncasecmp(value, "off", (len > 2 ? len : 2)) == 0) ||
+				 (pg_strcasecmp(value, "0") == 0))
+		{
+			success = true;
+			*result = false;
+		}
+		else
+		{
+			psql_error("\\%s: invalid boolean expression: %s\n",
+						action, value);
+		}
+		free(value);
+	}
+	else
+	{
+		psql_error("\\%s: no expression given\n",action);
+	}
+	return success;
+}
+
+static bool
+is_branching_command(const char *cmd)
+{
+	return ((strcmp(cmd, "if") == 0 || \
+			strcmp(cmd, "elif") == 0 || \
+			strcmp(cmd, "else") == 0 || \
+			strcmp(cmd, "endif") == 0));
+}
 
 /*
  * Subroutine to actually try to execute a backslash command.
@@ -207,6 +270,14 @@ exec_command(const char *cmd,
 								 * failed */
 	backslashResult status = PSQL_CMD_SKIP_LINE;
 
+	if (!pset.active_branch && !is_branching_command(cmd) )
+	{
+		/* Continue with an empty buffer as if the command were never read */
+		resetPQExpBuffer(query_buf);
+		psql_scan_reset(scan_state);
+		return status;
+	}
+
 	/*
 	 * \a -- toggle field alignment This makes little sense but we keep it
 	 * around.
@@ -1000,6 +1071,141 @@ exec_command(const char *cmd,
 		}
 	}
 
+	else if (strcmp(cmd, "if") == 0)
+	{
+		ifState new_if_state = IFSTATE_IGNORED;
+		/*
+		 * only evaluate the expression for truth if the underlying
+		 * branch is active
+		 */
+		if (pset.active_branch)
+		{
+			bool if_true = false;
+			success = read_boolean_expression(scan_state, "if", &if_true);
+			if (success)
+			{
+				if (if_true)
+					new_if_state = IFSTATE_TRUE;
+				else
+					new_if_state = IFSTATE_FALSE;
+			}
+		}
+		if (success)
+		{
+			psqlscan_branch_push(scan_state,new_if_state);
+			pset.active_branch = psqlscan_branch_active(scan_state);
+		}
+		psql_scan_reset(scan_state);
+	}
+
+	else if (strcmp(cmd, "elif") == 0)
+	{
+		if (psqlscan_branch_empty(scan_state))
+		{
+			psql_error("encountered un-matched \\elif\n");
+			success = false;
+		}
+		else
+		{
+			bool elif_true = false;
+			switch (psqlscan_branch_get_state(scan_state))
+			{
+				case IFSTATE_IGNORED:
+					/*
+					 * inactive branch, do nothing:
+					 * either if-endif already had a true block,
+					 * or whole parent block is false.
+					 */
+					break;
+				case IFSTATE_TRUE:
+					/*
+					 * just finished true section of active branch
+					 * do not evaluate expression, just skip
+					 */
+					psqlscan_branch_set_state(scan_state, IFSTATE_IGNORED);
+					pset.active_branch = false;
+					break;
+				case IFSTATE_FALSE:
+					/*
+					 * have not yet found a true block in this if-endif,
+					 * determine if this section is true or not.
+					 */
+					/* switch variable expansion back on just for this line */
+					pset.active_branch = true;
+					success = read_boolean_expression(scan_state, "elif",
+														&elif_true);
+					pset.active_branch = false;
+					if (success)
+					{
+						if (elif_true)
+						{
+							psqlscan_branch_set_state(scan_state, IFSTATE_TRUE);
+							pset.active_branch = true;
+						}
+					}
+					break;
+				case IFSTATE_ELSE_TRUE:
+				case IFSTATE_ELSE_FALSE:
+					psql_error("encountered \\elif after \\else\n");
+					success = false;
+					break;
+				default:
+					break;
+			}
+		}
+		psql_scan_reset(scan_state);
+	}
+
+	else if (strcmp(cmd, "else") == 0)
+	{
+		if (psqlscan_branch_empty(scan_state))
+		{
+			psql_error("encountered un-matched \\else\n");
+			success = false;
+		}
+		else
+		{
+			switch (psqlscan_branch_get_state(scan_state))
+			{
+				case IFSTATE_TRUE:
+					/* just finished true section of active branch */
+				case IFSTATE_IGNORED:
+					/* whole branch was inactive */
+					psqlscan_branch_set_state(scan_state, IFSTATE_ELSE_FALSE);
+					pset.active_branch = false;
+					break;
+				case IFSTATE_FALSE:
+					/* just finished true section of active branch */
+					psqlscan_branch_set_state(scan_state, IFSTATE_ELSE_TRUE);
+					pset.active_branch = true;
+					break;
+				case IFSTATE_ELSE_TRUE:
+				case IFSTATE_ELSE_FALSE:
+					psql_error("encountered \\else after \\else\n");
+					success = false;
+					break;
+				default:
+					break;
+			}
+		}
+		psql_scan_reset(scan_state);
+	}
+
+	else if (strcmp(cmd, "endif") == 0)
+	{
+		if (psqlscan_branch_empty(scan_state))
+		{
+			psql_error("encountered un-matched \\endif\n");
+			success = false;
+		}
+		else
+		{
+			psqlscan_branch_end_state(scan_state);
+			pset.active_branch = psqlscan_branch_active(scan_state);
+		}
+		psql_scan_reset(scan_state);
+	}
+
 	/* \l is list databases */
 	else if (strcmp(cmd, "l") == 0 || strcmp(cmd, "list") == 0 ||
 			 strcmp(cmd, "l+") == 0 || strcmp(cmd, "list+") == 0)
diff --git a/src/bin/psql/common.c b/src/bin/psql/common.c
index e1b04de..a526008 100644
--- a/src/bin/psql/common.c
+++ b/src/bin/psql/common.c
@@ -126,6 +126,10 @@ psql_get_variable(const char *varname, bool escape, bool as_ident)
 	char	   *result;
 	const char *value;
 
+	/* do not expand variables the branch is inactive */
+	if (!pset.active_branch)
+		return NULL;
+
 	value = GetVariable(pset.vars, varname);
 	if (!value)
 		return NULL;
diff --git a/src/bin/psql/mainloop.c b/src/bin/psql/mainloop.c
index bb306a4..b8d4887 100644
--- a/src/bin/psql/mainloop.c
+++ b/src/bin/psql/mainloop.c
@@ -15,7 +15,7 @@
 #include "settings.h"
 
 #include "mb/pg_wchar.h"
-
+#include "fe_utils/psqlscan_int.h"
 
 /* callback functions for our flex lexer */
 const PsqlScanCallbacks psqlscan_callbacks = {
@@ -23,7 +23,6 @@ const PsqlScanCallbacks psqlscan_callbacks = {
 	psql_error
 };
 
-
 /*
  * Main processing loop for reading lines of input
  *	and sending them to the backend.
@@ -51,6 +50,9 @@ MainLoop(FILE *source)
 	volatile int count_eof = 0;
 	volatile bool die_on_error = false;
 
+	/* only needed at the end to detect unbalanced ifs in scan_state */
+	bool if_endifs_balanced = true;
+
 	/* Save the prior command source */
 	FILE	   *prev_cmd_source;
 	bool		prev_cmd_interactive;
@@ -285,21 +287,28 @@ MainLoop(FILE *source)
 			if (scan_result == PSCAN_SEMICOLON ||
 				(scan_result == PSCAN_EOL && pset.singleline))
 			{
-				/*
-				 * Save query in history.  We use history_buf to accumulate
-				 * multi-line queries into a single history entry.
-				 */
-				if (pset.cur_cmd_interactive && !line_saved_in_history)
+				if (pset.active_branch)
 				{
-					pg_append_history(line, history_buf);
-					pg_send_history(history_buf);
-					line_saved_in_history = true;
+					/*
+					 * Save query in history.  We use history_buf to accumulate
+					 * multi-line queries into a single history entry.
+					 */
+					if (pset.cur_cmd_interactive && !line_saved_in_history)
+					{
+						pg_append_history(line, history_buf);
+						pg_send_history(history_buf);
+						line_saved_in_history = true;
+					}
+
+					/* execute query */
+					success = SendQuery(query_buf->data);
 				}
+				else
+					success = true;
 
-				/* execute query */
-				success = SendQuery(query_buf->data);
 				slashCmdStatus = success ? PSQL_CMD_SEND : PSQL_CMD_ERROR;
 				pset.stmt_lineno = 1;
+				slashCmdStatus = success ? PSQL_CMD_SEND : PSQL_CMD_ERROR;
 
 				/* transfer query to previous_buf by pointer-swapping */
 				{
@@ -358,15 +367,21 @@ MainLoop(FILE *source)
 
 				if (slashCmdStatus == PSQL_CMD_SEND)
 				{
-					success = SendQuery(query_buf->data);
-
-					/* transfer query to previous_buf by pointer-swapping */
+					if (pset.active_branch)
 					{
-						PQExpBuffer swap_buf = previous_buf;
+						success = SendQuery(query_buf->data);
 
-						previous_buf = query_buf;
-						query_buf = swap_buf;
+						/* transfer query to previous_buf by pointer-swapping */
+						{
+							PQExpBuffer swap_buf = previous_buf;
+
+							previous_buf = query_buf;
+							query_buf = swap_buf;
+						}
 					}
+					else
+						success = true;
+
 					resetPQExpBuffer(query_buf);
 
 					/* flush any paren nesting info after forced send */
@@ -425,12 +440,17 @@ MainLoop(FILE *source)
 	if (query_buf->len > 0 && !pset.cur_cmd_interactive &&
 		successResult == EXIT_SUCCESS)
 	{
-		/* save query in history */
-		if (pset.cur_cmd_interactive)
-			pg_send_history(history_buf);
+		if (pset.active_branch)
+		{
+			/* save query in history */
+			if (pset.cur_cmd_interactive)
+				pg_send_history(history_buf);
 
-		/* execute query */
-		success = SendQuery(query_buf->data);
+			/* execute query */
+			success = SendQuery(query_buf->data);
+		}
+		else
+			success = true;
 
 		if (!success && die_on_error)
 			successResult = EXIT_USER;
@@ -451,11 +471,17 @@ MainLoop(FILE *source)
 	destroyPQExpBuffer(previous_buf);
 	destroyPQExpBuffer(history_buf);
 
+	if (slashCmdStatus != PSQL_CMD_TERMINATE)
+		if_endifs_balanced = psqlscan_branch_empty(scan_state);
+
 	psql_scan_destroy(scan_state);
 
 	pset.cur_cmd_source = prev_cmd_source;
 	pset.cur_cmd_interactive = prev_cmd_interactive;
 	pset.lineno = prev_lineno;
 
+	if (! if_endifs_balanced )
+		psql_error("found EOF before closing \\endif(s)\n");
+
 	return successResult;
 }	/* MainLoop() */
diff --git a/src/bin/psql/mainloop.h b/src/bin/psql/mainloop.h
index 228a5e0..47f4c32 100644
--- a/src/bin/psql/mainloop.h
+++ b/src/bin/psql/mainloop.h
@@ -14,4 +14,5 @@ extern const PsqlScanCallbacks psqlscan_callbacks;
 
 extern int	MainLoop(FILE *source);
 
+
 #endif   /* MAINLOOP_H */
diff --git a/src/bin/psql/settings.h b/src/bin/psql/settings.h
index 4c7c3b1..15d5599 100644
--- a/src/bin/psql/settings.h
+++ b/src/bin/psql/settings.h
@@ -114,6 +114,9 @@ typedef struct _psqlSettings
 
 	VariableSpace vars;			/* "shell variable" repository */
 
+	bool		active_branch;	/* true if session is not in an \if branch
+								 * or the current branch is true */
+
 	/*
 	 * The remaining fields are set by assign hooks associated with entries in
 	 * "vars".  They should not be set directly except by those hook
diff --git a/src/bin/psql/startup.c b/src/bin/psql/startup.c
index 85aac4a..b03ded4 100644
--- a/src/bin/psql/startup.c
+++ b/src/bin/psql/startup.c
@@ -128,6 +128,8 @@ main(int argc, char *argv[])
 	setvbuf(stderr, NULL, _IONBF, 0);
 #endif
 
+	pset.active_branch = true;
+
 	pset.progname = get_progname(argv[0]);
 
 	pset.db = NULL;
diff --git a/src/fe_utils/psqlscan.l b/src/fe_utils/psqlscan.l
index 1b29341..a09d404 100644
--- a/src/fe_utils/psqlscan.l
+++ b/src/fe_utils/psqlscan.l
@@ -904,6 +904,8 @@ psql_scan_create(const PsqlScanCallbacks *callbacks)
 
 	psql_scan_reset(state);
 
+	state->branch_stack = NULL;
+
 	return state;
 }
 
@@ -919,6 +921,13 @@ psql_scan_destroy(PsqlScanState state)
 
 	yylex_destroy(state->scanner);
 
+	while (state->branch_stack != NULL)
+	{
+		IfStackElem *p = state->branch_stack;
+		state->branch_stack = state->branch_stack->next;
+		free(p);
+	}
+
 	free(state);
 }
 
@@ -1426,3 +1435,88 @@ psqlscan_escape_variable(PsqlScanState state, const char *txt, int len,
 		psqlscan_emit(state, txt, len);
 	}
 }
+
+/*
+ * psqlscan_branch_empty
+ *
+ * True if there are no active \if-structures
+ */
+bool
+psqlscan_branch_empty(PsqlScanState state)
+{
+	return (state->branch_stack == NULL);
+}
+
+/*
+ * Fetch the current state of the top of the stack
+ */
+ifState
+psqlscan_branch_get_state(PsqlScanState state)
+{
+	if (psqlscan_branch_empty(state))
+		return IFSTATE_NONE;
+	return state->branch_stack->if_state;
+}
+
+/*
+ * psqlscan_branch_active
+ *
+ * True if the current \if-block (if any) is true and queries/commands
+ * should be executed.
+ */
+bool
+psqlscan_branch_active(PsqlScanState state)
+{
+	ifState s = psqlscan_branch_get_state(state);
+	return ((s == IFSTATE_NONE) ||
+			(s == IFSTATE_TRUE) ||
+			(s == IFSTATE_ELSE_TRUE));
+}
+
+
+/*
+ * psqlscan_branch_push
+ *
+ * Create a new \if branch.
+ */
+bool
+psqlscan_branch_push(PsqlScanState state, ifState new_state)
+{
+	IfStackElem *p = pg_malloc0(sizeof(IfStackElem));
+	p->if_state = new_state;
+	p->next = state->branch_stack;
+	state->branch_stack = p;
+	return true;
+}
+
+/*
+ * psqlscan_branch_set_state
+ *
+ * Change the state of the topmost branch.
+ * Returns false if there was branch state to set.
+ */
+bool
+psqlscan_branch_set_state(PsqlScanState state, ifState new_state)
+{
+	if (psqlscan_branch_empty(state))
+		return false;
+	state->branch_stack->if_state = new_state;
+	return true;
+}
+
+/*
+ * psqlscan_branch_end_state
+ *
+ * Destroy the topmost branch because and \endif was encountered.
+ * Returns false if there was no branch to end.
+ */
+bool
+psqlscan_branch_end_state(PsqlScanState state)
+{
+	IfStackElem *p = state->branch_stack;
+	if (!p)
+		return false;
+	state->branch_stack = state->branch_stack->next;
+	free(p);
+	return true;
+}
diff --git a/src/include/fe_utils/psqlscan_int.h b/src/include/fe_utils/psqlscan_int.h
index 0fddc7a..a24a5ac 100644
--- a/src/include/fe_utils/psqlscan_int.h
+++ b/src/include/fe_utils/psqlscan_int.h
@@ -75,6 +75,30 @@ typedef struct StackElem
 	struct StackElem *next;
 } StackElem;
 
+typedef enum _ifState
+{
+	IFSTATE_NONE = 0,	/* Not currently in an \if block */
+	IFSTATE_TRUE,		/* currently in an \if or \elif which is true
+						 * and all parent branches (if any) are true */
+	IFSTATE_FALSE,		/* currently in an \if or \elif which is false
+						 * but no true branch has yet been seen,
+						 * and all parent branches (if any) are true */
+	IFSTATE_IGNORED,	/* currently in an \elif which follows a true \if
+						 * or the whole \if is a child of a false parent */
+	IFSTATE_ELSE_TRUE,	/* currently in an \else which is true
+						 * and all parent branches (if any) are true */
+	IFSTATE_ELSE_FALSE	/* currently in an \else which is false or ignored */
+} ifState;
+
+/*
+ * The state of nested ifs is stored in a stack.
+ */
+typedef struct IfStackElem
+{
+	ifState		if_state;
+	struct IfStackElem *next;
+} IfStackElem;
+
 /*
  * All working state of the lexer must be stored in PsqlScanStateData
  * between calls.  This allows us to have multiple open lexer operations,
@@ -118,6 +142,11 @@ typedef struct PsqlScanStateData
 	 * Callback functions provided by the program making use of the lexer.
 	 */
 	const PsqlScanCallbacks *callbacks;
+
+	/*
+	 * \if branch state variables
+	 */
+	IfStackElem *branch_stack;
 } PsqlScanStateData;
 
 
@@ -141,4 +170,21 @@ extern void psqlscan_escape_variable(PsqlScanState state,
 						 const char *txt, int len,
 						 bool as_ident);
 
+/*
+ * branching commands
+ */
+extern bool psqlscan_branch_empty(PsqlScanState state);
+
+extern bool psqlscan_branch_active(PsqlScanState state);
+
+extern ifState psqlscan_branch_get_state(PsqlScanState state);
+
+extern bool psqlscan_branch_push(PsqlScanState state,
+									ifState new_state);
+
+extern bool psqlscan_branch_set_state(PsqlScanState state,
+									ifState new_state);
+
+extern bool psqlscan_branch_end_state(PsqlScanState state);
+
 #endif   /* PSQLSCAN_INT_H */
diff --git a/src/test/regress/expected/psql.out b/src/test/regress/expected/psql.out
index 464436a..5cc1130 100644
--- a/src/test/regress/expected/psql.out
+++ b/src/test/regress/expected/psql.out
@@ -2686,6 +2686,78 @@ deallocate q;
 \pset format aligned
 \pset expanded off
 \pset border 1
+\if true
+	\if 1
+		\if yes
+			\if on
+				\echo 'all true'
+all true
+			\else
+				\echo 'should not print #1-1'
+			\endif
+		\else
+			\echo 'should not print #1-2'
+		\endif
+	\else
+		\echo 'should not print #1-3'
+	\endif
+\else
+	\echo 'should not print #1-4'
+\endif
+\if false
+	\echo 'should not print #2-1'
+\elif 0
+	\echo 'should not print #2-2'
+\elif no
+	\echo 'should not print #2-3'
+\elif off
+	\echo 'should not print #2-4'
+\else
+	\echo 'all false'
+all false
+\endif
+\if true
+	\echo 'first thing true'
+first thing true
+\else
+	\echo 'should not print #3-1'
+\endif
+\if false
+	\echo 'should not print #4-1'
+\elif true
+	\echo 'second thing true'
+second thing true
+\else
+	\echo 'should not print #5-1'
+\endif
+\set var 'ab''cd'
+-- select :var;
+\if false
+  select :var ;
+\else
+  select 1;
+ ?column? 
+----------
+        1
+(1 row)
+
+\endif
+\endif
+encountered un-matched \endif
+\else
+encountered un-matched \else
+\elif
+encountered un-matched \elif
+\if true
+\else
+\else
+encountered \else after \else
+\endif
+\if false
+\else
+\elif
+encountered \elif after \else
+\endif
 -- SHOW_CONTEXT
 \set SHOW_CONTEXT never
 do $$
diff --git a/src/test/regress/sql/psql.sql b/src/test/regress/sql/psql.sql
index 900aa7e..8793aa2 100644
--- a/src/test/regress/sql/psql.sql
+++ b/src/test/regress/sql/psql.sql
@@ -357,6 +357,74 @@ deallocate q;
 \pset expanded off
 \pset border 1
 
+\if true
+	\if 1
+		\if yes
+			\if on
+				\echo 'all true'
+			\else
+				\echo 'should not print #1-1'
+			\endif
+		\else
+			\echo 'should not print #1-2'
+		\endif
+	\else
+		\echo 'should not print #1-3'
+	\endif
+\else
+	\echo 'should not print #1-4'
+\endif
+
+\if false
+	\echo 'should not print #2-1'
+\elif 0
+	\echo 'should not print #2-2'
+\elif no
+	\echo 'should not print #2-3'
+\elif off
+	\echo 'should not print #2-4'
+\else
+	\echo 'all false'
+\endif
+
+\if true
+	\echo 'first thing true'
+\else
+	\echo 'should not print #3-1'
+\endif
+
+\if false
+	\echo 'should not print #4-1'
+\elif true
+	\echo 'second thing true'
+\else
+	\echo 'should not print #5-1'
+\endif
+
+\set var 'ab''cd'
+-- select :var;
+\if false
+  select :var ;
+\else
+  select 1;
+\endif
+
+\endif
+
+\else
+
+\elif
+
+\if true
+\else
+\else
+\endif
+
+\if false
+\else
+\elif
+\endif
+
 -- SHOW_CONTEXT
 
 \set SHOW_CONTEXT never


^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-01-28 07:38  Fabien COELHO <coelho@cri.ensmp.fr>
  parent: Corey Huinker <corey.huinker@gmail.com>
  0 siblings, 1 reply; 232+ messages in thread

From: Fabien COELHO @ 2017-01-28 07:38 UTC (permalink / raw)
  To: Corey Huinker <corey.huinker@gmail.com>; +Cc: Daniel Verite <daniel@manitou-mail.org>; pgsql-hackers


Hello Corey,

> And here it is

About the patch v3:

## DOCUMENTATION

I'm wondering what pg would do on "EXISTS(SELECT 1 FROM customer)" if 
there are many employees. EXPLAIN suggests a seq_scan, which seems bad. 
With "(SELECT COUNT(*) FROM pgbench_accounts) <> 0" pg seems to generate 
an index only scan on a large table, so maybe it is a better way to do it. 
It seems strange that there is no better way to do that in a relational 
tool, the relational model being an extension of set theory... and there 
is no easy way (?) to check whether a set is empty.

"""If an EOF is reached on the main file or an 
<command>\include</command>-ed file before all 
<command>\if</command>-<command>\endif</command> are matched, then psql 
will raise an error."""

In sentence above: "before all" -> "before all local"? "then" -> ""?

"other options booleans" -> "other booleans of options"? or "options' 
booleans" maybe, but that is for people?

"unabigous" -> "unambiguous"

I think that the three paragraph explanation about non evaluation could be 
factor into one, maybe something like: """Lines within false branches are 
not evaluated in any way: queries are not sent to the server, non 
conditional commands are not evaluated but bluntly ignored, nested if 
expressions in such branches are also not evaluated but are tallied to 
check for nesting."""

I would suggest to merge elif/else constraints by describing what is 
expected rather than what is not expected. """An \if command may contain 
any number of \elif clauses and may end with one \else clause""".


## CODE

In "read_boolean_expression":

  + if (value)

"if (value != NULL)" is usually used, I think.

  + if (value == NULL)
  +   return false; /* not set -> assume "off" */

This is dead code, because value has been checked to be non NULL a few 
lines above.

  + (pg_strncasecmp(value, "on", (len > 2 ? len : 2)) == 0)
  + (pg_strncasecmp(value, "off", (len > 2 ? len : 2)) == 0)

Hmmm, not easy to parse. Maybe it deserves a comment?
"check at least two chars to distinguish on & off"

",action" -> ", action" (space after commas).

The "result" is not set on errors, but maybe it should be set to false 
anyway and explicitely, instead of relying on some prior initialization?
Or document that the result is not set on errors.

if command:

   if (is active) {
     success = ...
     if (success) {
       ...
     }
   }
   if (success) {
     ...
   }

The second test on success may not rely on the value set above. That looks 
very strange. ISTM that the state should be pushed whether parsing 
succeeded or not. Moreover, it results in:

   \if ERROR
      \echo X
   \else
      \echo Y
   \endif

having both X & Y printed and error reported on else and endif. I think 
that an expression error should just put the stuff in ignore state.


On "else" when in state ignored, ISTM that it should remain in state 
ignore, not switch to else-false.


Comment about "IFSTATE_FALSE" talks about the state being true, maybe a 
copy-paste error?

In comments: "... variables the branch" -> "variables if the branch"

The "if_endifs_balanced" variable is not very useful. Maybe just the test 
and error reporting in the right place:

  if (... && !psqlscan_branch_empty(scan_state))
    psql_error("found EOF before closing \\endif(s)\n");



  +
   #endif   /* MAINLOOP_H */


  -
  /*
   * Main processing loop for reading lines of input
   *     and sending them to the backend.

Do not add/remove empty lines in places unrelated to the patch?


History saving: I'm wondering whether all read line should be put into 
history, whether executed or not.

Is it possible to make some of the added functions static? If so, do it.

I checked that it does stop on errors with -v ON_ERROR_STOP=1. However I 
would be more at ease if this was tested somewhere.

-- 
Fabien.


-- 
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers



^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-01-28 17:46  Corey Huinker <corey.huinker@gmail.com>
  parent: Fabien COELHO <coelho@cri.ensmp.fr>
  0 siblings, 2 replies; 232+ messages in thread

From: Corey Huinker @ 2017-01-28 17:46 UTC (permalink / raw)
  To: Fabien COELHO <coelho@cri.ensmp.fr>; +Cc: Daniel Verite <daniel@manitou-mail.org>; pgsql-hackers

>
>
> I'm wondering what pg would do on "EXISTS(SELECT 1 FROM customer)" if
> there are many employees. EXPLAIN suggests a seq_scan, which seems bad.
> With "(SELECT COUNT(*) FROM pgbench_accounts) <> 0" pg seems to generate an
> index only scan on a large table, so maybe it is a better way to do it. It
> seems strange that there is no better way to do that in a relational tool,
> the relational model being an extension of set theory... and there is no
> easy way (?) to check whether a set is empty.
>

I believe that the scan stops on the first row it finds, because the
EXITS() clause is met. But it's not relevant to the documentation, I simply
wanted to demonstrate some results that couldn't be resolved at parse time,
so that the \if tests were meaningful. If the query example is distracting
from the point of the documentation, we should change it.


>
> """If an EOF is reached on the main file or an
> <command>\include</command>-ed file before all
> <command>\if</command>-<command>\endif</command> are matched, then psql
> will raise an error."""
>
> In sentence above: "before all" -> "before all local"? "then" -> ""?
>

+1

>
> "other options booleans" -> "other booleans of options"? or "options'
> booleans" maybe, but that is for people?
>

+1

>
> "unabigous" -> "unambiguous"
>

+1


>
> I think that the three paragraph explanation about non evaluation could be
> factor into one, maybe something like: """Lines within false branches are
> not evaluated in any way: queries are not sent to the server, non
> conditional commands are not evaluated but bluntly ignored, nested if
> expressions in such branches are also not evaluated but are tallied to
> check for nesting."""
>
> I would suggest to merge elif/else constraints by describing what is
> expected rather than what is not expected. """An \if command may contain
> any number of \elif clauses and may end with one \else clause""".
>

I'll give it another shot, as I forgot to mention the non-evaluation of
expressions in dead branches.



>
>
> ## CODE
>
> In "read_boolean_expression":
>
>  + if (value)
>
> "if (value != NULL)" is usually used, I think.
>
>  + if (value == NULL)
>  +   return false; /* not set -> assume "off" */
>
> This is dead code, because value has been checked to be non NULL a few
> lines above.
>
>  + (pg_strncasecmp(value, "on", (len > 2 ? len : 2)) == 0)
>  + (pg_strncasecmp(value, "off", (len > 2 ? len : 2)) == 0)
>
> Hmmm, not easy to parse. Maybe it deserves a comment?
> "check at least two chars to distinguish on & off"
>
> ",action" -> ", action" (space after commas).
>
> The "result" is not set on errors, but maybe it should be set to false
> anyway and explicitely, instead of relying on some prior initialization?
> Or document that the result is not set on errors.
>

This is code lifted from variable.c's ParseVariableBool().  When the other
patch for "psql hooks" is committed (the one that detects when the string
wasn't a valid boolean), this code will go away and we'll just use
ParseVariableBool() again.


>
> if command:
>
>   if (is active) {
>     success = ...
>     if (success) {
>       ...
>     }
>   }
>   if (success) {
>     ...
>   }
>
> The second test on success may not rely on the value set above. That looks
> very strange. ISTM that the state should be pushed whether parsing
> succeeded or not. Moreover, it results in:
>
>   \if ERROR
>      \echo X
>   \else
>      \echo Y
>   \endif
>
> having both X & Y printed and error reported on else and endif. I think
> that an expression error should just put the stuff in ignore state.
>

Not just false, but ignore the whole if-endif? interesting. I hadn't
thought of that. Can do.


>
>
> On "else" when in state ignored, ISTM that it should remain in state
> ignore, not switch to else-false.
>

That's how I know if this is the first "else" I encountered. I could split
the if-state back into a struct of booleans if you think that makes more
sense.



>
>
> Comment about "IFSTATE_FALSE" talks about the state being true, maybe a
> copy-paste error?
>

Yes.


>
> In comments: "... variables the branch" -> "variables if the branch"
>

Yes.


>
> The "if_endifs_balanced" variable is not very useful. Maybe just the test
> and error reporting in the right place:
>
>  if (... && !psqlscan_branch_empty(scan_state))
>    psql_error("found EOF before closing \\endif(s)\n");
>

+1
I think I got the idea at some point that psql_error broke out of the
current execution block.


> History saving: I'm wondering whether all read line should be put into
> history, whether executed or not.
>

Good question. I gave it some thought and I decided it shouldn't.  First,
because history is a set of statements that were attempted, and those
statements were not. But perhaps more importantly, because the statement
could have contained an expandable variable, and since that variable would
not be evaluated the SQL stored would be subtly altered from the original
intent, perhaps in ways that might drastically alter the meaning of the
statement. A highly contrived example:

\set clause 'where cust_id = 1'
\if false
delete from customers :clause;
\endif


So yeah, it just seemed easier to not store in history.


> Is it possible to make some of the added functions static? If so, do it.
>

I try to. I think some of the functions that used to be called in
mainloop.c or command.c might not be anymore, and those can be made static.
I'll recheck which ones can be.


> I checked that it does stop on errors with -v ON_ERROR_STOP=1. However I
> would be more at ease if this was tested somewhere.


Yes, TAP tests forthcoming. I'll probably put out one more intermediate
patch to get the 'just-ignore-til-endif' functionality of an invalid \if or
\elseif, but the final push for a committed patch will have to wait until
after the ParseVariableBool() issue is worked out.

^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-01-29 08:35  Fabien COELHO <coelho@cri.ensmp.fr>
  parent: Corey Huinker <corey.huinker@gmail.com>
  1 sibling, 3 replies; 232+ messages in thread

From: Fabien COELHO @ 2017-01-29 08:35 UTC (permalink / raw)
  To: Corey Huinker <corey.huinker@gmail.com>; +Cc: Daniel Verite <daniel@manitou-mail.org>; pgsql-hackers


Hello,

>> I'm wondering what pg would do on "EXISTS(SELECT 1 FROM customer)" if
>> there are many employees. [...]
>
> I believe that the scan stops on the first row it finds, because the
> EXITS() clause is met.

Hmmm... That is not so clear from "EXPLAIN" output:

  Result  (cost=0.03..0.04 rows=1 width=1)
   InitPlan 1 (returns $0)
   ->  Seq Scan on ...  (cost=0.00..263981.69 rows=10001769 width=0)

There is a plan for the sub-query, so it looks like it is actually fully 
executed. Maybe adding "LIMIT 1" would be better?

> But it's not relevant to the documentation, I simply wanted to 
> demonstrate some results that couldn't be resolved at parse time, so 
> that the \if tests were meaningful. If the query example is distracting 
> from the point of the documentation, we should change it.

My point is that examples about one thing can be interpreted as example 
for other things which is also done in the example, so it is better to do 
everything right.


>> In "read_boolean_expression": [...]

> This is code lifted from variable.c's ParseVariableBool().  When the other
> patch for "psql hooks" is committed (the one that detects when the string
> wasn't a valid boolean), this code will go away and we'll just use
> ParseVariableBool() again.

Hmmm. Copy-pasting is bad enough, and "when the other patch is committed" 
is an unknown, so I would still suggest to fix obvious defects at least 
(eg dead code which may result in compiler warnings, inconsistent 
comments...).

>> [...] The second test on success may not rely on the value set above. 
>> That looks very strange. ISTM that the state should be pushed whether 
>> parsing succeeded or not. Moreover, it results in:
>>
>>   \if ERROR
>>      \echo X
>>   \else
>>      \echo Y
>>   \endif
>>
>> having both X & Y printed and error reported on else and endif. I think
>> that an expression error should just put the stuff in ignore state.
>
> Not just false, but ignore the whole if-endif? interesting. I hadn't
> thought of that. Can do.

My point was that you must at least push something, otherwise both 
branches are executed (!), and some commands could be attached to 
upper-level conditions:

   \if true
     \if ERROR
       ...
     \endif // this becomes "if true \endif"
     ...
   \endif // this becomes an error

As for which state is pushed, it is indeed debatable. I do think that 
pushing ignore on errors is a better/less risky behavior, but other 
people' opinion may differ.

>> On "else" when in state ignored, ISTM that it should remain in state
>> ignore, not switch to else-false.
>
> That's how I know if this is the first "else" I encountered.

Ok, my mistake. Maybe expand the comment a little bit if appropriate.

>> History saving: I'm wondering whether all read line should be put into
>> history, whether executed or not.
>
> Good question. I gave it some thought and I decided it shouldn't.  First,
> because history is a set of statements that were attempted, and those
> statements were not. But perhaps more importantly, because the statement
> could have contained an expandable variable, and since that variable would
> not be evaluated the SQL stored would be subtly altered from the original
> intent, perhaps in ways that might drastically alter the meaning of the
> statement. A highly contrived example:
>
> \set clause 'where cust_id = 1'
> \if false
> delete from customers :clause;
> \endif

Hmmm.

> So yeah, it just seemed easier to not store in history.

Hmmm.

As I recall, history is only for interactive mode. If I really typed 
something, I'm expecting to get it by visiting previous commands, because 
I certainly do not want to retype it again.

For your above example, maybe I would reedit the clause definition, 
then want to execute the delete.

-- 
Fabien.


-- 
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers



^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-01-29 20:40  Corey Huinker <corey.huinker@gmail.com>
  parent: Fabien COELHO <coelho@cri.ensmp.fr>
  2 siblings, 0 replies; 232+ messages in thread

From: Corey Huinker @ 2017-01-29 20:40 UTC (permalink / raw)
  To: Fabien COELHO <coelho@cri.ensmp.fr>; +Cc: Daniel Verite <daniel@manitou-mail.org>; pgsql-hackers

>
> My point is that examples about one thing can be interpreted as example
> for other things which is also done in the example, so it is better to do
> everything right.
>

Fair enough. I'll rewrite the examples to use pk lookups. I doubt the query
plan for those will change much in the future.


> Hmmm. Copy-pasting is bad enough, and "when the other patch is committed"
> is an unknown, so I would still suggest to fix obvious defects at least (eg
> dead code which may result in compiler warnings, inconsistent comments...).
>

It was do that or pause this work until that unknown was resolved.



>
> My point was that you must at least push something, otherwise both
> branches are executed (!), and some commands could be attached to
> upper-level conditions:
>
>
> As for which state is pushed, it is indeed debatable. I do think that
> pushing ignore on errors is a better/less risky behavior, but other people'
> opinion may differ.


+1




>
>
> On "else" when in state ignored, ISTM that it should remain in state
>>> ignore, not switch to else-false.
>>>
>>
>> That's how I know if this is the first "else" I encountered.
>>
>
> Ok, my mistake. Maybe expand the comment a little bit if appropriate.


+1


>
> As I recall, history is only for interactive mode. If I really typed
> something, I'm expecting to get it by visiting previous commands, because I
> certainly do not want to retype it again.
>
> For your above example, maybe I would reedit the clause definition, then
> want to execute the delete.


Good points, and history does save the string with the variable in it, not
the resolved string that was sent (or not sent) to the server.

^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-01-29 21:49  Jim Nasby <Jim.Nasby@BlueTreble.com>
  parent: Fabien COELHO <coelho@cri.ensmp.fr>
  2 siblings, 0 replies; 232+ messages in thread

From: Jim Nasby @ 2017-01-29 21:49 UTC (permalink / raw)
  To: Fabien COELHO <coelho@cri.ensmp.fr>; Corey Huinker <corey.huinker@gmail.com>; +Cc: Daniel Verite <daniel@manitou-mail.org>; pgsql-hackers

On 1/29/17 2:35 AM, Fabien COELHO wrote:
>>> I'm wondering what pg would do on "EXISTS(SELECT 1 FROM customer)" if
>>> there are many employees. [...]
>>
>> I believe that the scan stops on the first row it finds, because the
>> EXITS() clause is met.
>
> Hmmm... That is not so clear from "EXPLAIN" output:

You need to use a better test case...

> explain analyze select exists(select 1 from generate_series(1,99999) gs);
>                                                           QUERY PLAN
> -------------------------------------------------------------------------------------------------------------------------------
>  Result  (cost=0.01..0.02 rows=1 width=1) (actual time=26.278..26.278 rows=1 loops=1)
>    InitPlan 1 (returns $0)
>      ->  Function Scan on generate_series gs  (cost=0.00..10.00 rows=1000 width=0) (actual time=26.271..26.271 rows=1 loops=1)
>  Planning time: 6.568 ms
>  Execution time: 48.917 ms
> (5 rows)

In any case, +1 for not promoting count(*) <> 0; that's a really, really 
bad way to test for existence.
-- 
Jim Nasby, Data Architect, Blue Treble Consulting, Austin TX
Experts in Analytics, Data Architecture and PostgreSQL
Data in Trouble? Get it in Treble! http://BlueTreble.com
855-TREBLE2 (855-873-2532)


-- 
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers



^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-01-30 16:57  Daniel Verite <daniel@manitou-mail.org>
  parent: Corey Huinker <corey.huinker@gmail.com>
  1 sibling, 1 reply; 232+ messages in thread

From: Daniel Verite @ 2017-01-30 16:57 UTC (permalink / raw)
  To: Corey Huinker <corey.huinker@gmail.com>; +Cc: Fabien COELHO <coelho@cri.ensmp.fr>; pgsql-hackers

	Corey Huinker wrote:

> >   \if ERROR
> >      \echo X
> >   \else
> >      \echo Y
> >   \endif
> >
> > having both X & Y printed and error reported on else and endif. I think
> > that an expression error should just put the stuff in ignore state.
> >
> 
> Not just false, but ignore the whole if-endif? interesting. I hadn't
> thought of that. Can do.

If we use the Unix shell as a model, in POSIX "test" and  "if"
are such that an evaluation error (exit status>1) leads to the same
flow than when evaluating to false (exit status=1).

References I can find:

test:
http://pubs.opengroup.org/onlinepubs/9699919799/utilities/test.html

if:
http://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_09_04_07

BTW, in "set -e" mode, it also says that a failure to evaluate an "if"
 expression does not lead to the script stopping:
<quote>
  The -e setting shall be ignored when executing the compound list
  following the while, until, if, or elif reserved word, a pipeline
  beginning with the ! reserved word, or any command of an AND-OR list
  other than the last
</quote>

So psql is not following that model with ON_ERROR_STOP if it exits
with an error when unable to evaluate an "if" expression.
I'm not implying that we should necessarily adopt the shell behavior,
but as these choices have certainly been made in POSIX for good
reasons, we should make sure to think twice about why they don't
apply to psql.


Best regards,
-- 
Daniel Vérité
PostgreSQL-powered mailer: http://www.manitou-mail.org
Twitter: @DanielVerite


-- 
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers



^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-01-30 17:35  Fabien COELHO <coelho@cri.ensmp.fr>
  parent: Daniel Verite <daniel@manitou-mail.org>
  0 siblings, 0 replies; 232+ messages in thread

From: Fabien COELHO @ 2017-01-30 17:35 UTC (permalink / raw)
  To: Daniel Verite <daniel@manitou-mail.org>; +Cc: Corey Huinker <corey.huinker@gmail.com>; pgsql-hackers


Hello Daniel,

> [...] So psql is not following that model with ON_ERROR_STOP if it exits 
> with an error when unable to evaluate an "if" expression. I'm not 
> implying that we should necessarily adopt the shell behavior, but as 
> these choices have certainly been made in POSIX for good reasons, we 
> should make sure to think twice about why they don't apply to psql.

Interesting point.

The shell is about processes, and if relies on the status code returned, 
with 0 meaning true, and anything else, which is somehow a process error, 
meaning false. So there is no way to distinguish false from process error 
in this system, because the status is just one integer.

However, a syntax error, for instance with a shell internal test, leads to 
nothing being executed:

    bash> if [[ bad syntax ]] ; then echo then ; else echo else ; fi
    -bash: conditional binary operator expected
    -bash: syntax error near `syntax'
    # nothing is echoed

Another example with python in interactive mode:

    python> if 1+: print 1; else print 0
    SyntaxError: invalid syntax
    # nothing is printed

So rejecting execution altogether on syntax errors is somehow a common 
practice.

-- 
Fabien.


-- 
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers



^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-01-31 06:04  Fabien COELHO <coelho@cri.ensmp.fr>
  parent: Fabien COELHO <coelho@cri.ensmp.fr>
  2 siblings, 1 reply; 232+ messages in thread

From: Fabien COELHO @ 2017-01-31 06:04 UTC (permalink / raw)
  To: Corey Huinker <corey.huinker@gmail.com>; +Cc: Daniel Verite <daniel@manitou-mail.org>; pgsql-hackers


>> This is code lifted from variable.c's ParseVariableBool().  When the other
>> patch for "psql hooks" is committed (the one that detects when the string
>> wasn't a valid boolean), this code will go away and we'll just use
>> ParseVariableBool() again.

The ParseVariableBool function has been updated, and the new version is 
much cleaner, including all fixes that I suggested in your copy, so you 
can use it in your patch.

-- 
Fabien.


-- 
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers



^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-01-31 17:16  Corey Huinker <corey.huinker@gmail.com>
  parent: Fabien COELHO <coelho@cri.ensmp.fr>
  0 siblings, 1 reply; 232+ messages in thread

From: Corey Huinker @ 2017-01-31 17:16 UTC (permalink / raw)
  To: Fabien COELHO <coelho@cri.ensmp.fr>; +Cc: Daniel Verite <daniel@manitou-mail.org>; pgsql-hackers

On Tue, Jan 31, 2017 at 1:04 AM, Fabien COELHO <coelho@cri.ensmp.fr> wrote:

>
> This is code lifted from variable.c's ParseVariableBool().  When the other
>>> patch for "psql hooks" is committed (the one that detects when the string
>>> wasn't a valid boolean), this code will go away and we'll just use
>>> ParseVariableBool() again.
>>>
>>
> The ParseVariableBool function has been updated, and the new version is
> much cleaner, including all fixes that I suggested in your copy, so you can
> use it in your patch.
>
> --
> Fabien.
>

I see there's still a lot of activity in the thread, I can't tell if it's
directly related to ParseVariableBool() or in the way it is called. Should
I wait for the dust to settle over there?

^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-01-31 18:15  Tom Lane <tgl@sss.pgh.pa.us>
  parent: Corey Huinker <corey.huinker@gmail.com>
  0 siblings, 1 reply; 232+ messages in thread

From: Tom Lane @ 2017-01-31 18:15 UTC (permalink / raw)
  To: Corey Huinker <corey.huinker@gmail.com>; +Cc: Fabien COELHO <coelho@cri.ensmp.fr>; Daniel Verite <daniel@manitou-mail.org>; pgsql-hackers

Corey Huinker <corey.huinker@gmail.com> writes:
> On Tue, Jan 31, 2017 at 1:04 AM, Fabien COELHO <coelho@cri.ensmp.fr> wrote:
>> The ParseVariableBool function has been updated, and the new version is
>> much cleaner, including all fixes that I suggested in your copy, so you can
>> use it in your patch.

> I see there's still a lot of activity in the thread, I can't tell if it's
> directly related to ParseVariableBool() or in the way it is called. Should
> I wait for the dust to settle over there?

I think ParseVariableBool is only likely to change to reject a NULL value
rather than silently interpreting it as FALSE, which is the way it is in
HEAD right now.  That behavior is a leftover hack, really, and moving the
treatment of unset values upstream seems a lot cleaner.  See my draft
patch at
https://www.postgresql.org/message-id/30629.1485881533@sss.pgh.pa.us

			regards, tom lane


-- 
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers



^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-02-01 08:27  Corey Huinker <corey.huinker@gmail.com>
  parent: Tom Lane <tgl@sss.pgh.pa.us>
  0 siblings, 2 replies; 232+ messages in thread

From: Corey Huinker @ 2017-02-01 08:27 UTC (permalink / raw)
  To: Tom Lane <tgl@sss.pgh.pa.us>; +Cc: Fabien COELHO <coelho@cri.ensmp.fr>; Daniel Verite <daniel@manitou-mail.org>; pgsql-hackers

>
>
> I think ParseVariableBool is only likely to change to reject a NULL value
> rather than silently interpreting it as FALSE, which is the way it is in
> HEAD right now.  That behavior is a leftover hack, really, and moving the
> treatment of unset values upstream seems a lot cleaner.  See my draft
> patch at
> https://www.postgresql.org/message-id/30629.1485881533@sss.pgh.pa.us
>
>                         regards, tom lane
>


Updated patch:
- rebased on post-psql hooks master
- took nearly every suggestion for change to documentation
- \if ERROR will throw the entire \if..\endif into IGNORE mode
- state is now pushed on all \ifs
- reinstated leveraging of ParseVariableBool
- history is now kept in interactive mode regardless of \if-truth
- reworked coding example to cause less agita
- removed MainLoop "are endifs balanced" variable in favor of in-place
check which respects ON_ERROR_STOP.
- make changes to psql/Makefile to enable TAP tests and created t/ directory
- wrote an intentionally failing TAP test to see if "make check" executes
it. it does not. need help.

I'm hoping my failure in that last bit is easy to spot/fix, so I can move
forward with testing unbalanced branching, etc.
diff --git a/doc/src/sgml/ref/psql-ref.sgml b/doc/src/sgml/ref/psql-ref.sgml
index 4e51e90..aad62ac 100644
--- a/doc/src/sgml/ref/psql-ref.sgml
+++ b/doc/src/sgml/ref/psql-ref.sgml
@@ -2035,6 +2035,67 @@ hello 10
         </listitem>
       </varlistentry>
 
+      <varlistentry>
+        <term><literal>\if</literal> <replaceable class="parameter">expr</replaceable></term>
+        <term><literal>\elif</literal> <replaceable class="parameter">expr</replaceable></term>
+        <term><literal>\else</literal></term>
+        <term><literal>\endif</literal></term>
+        <listitem>
+        <para>
+        This group of commands implements nestable conditional blocks, like
+        this:
+        </para>
+<programlisting>
+SELECT
+    EXISTS(SELECT 1 FROM customer WHERE customer_id = 123) as is_customer,
+    EXISTS(SELECT 1 FROM employee WHERE employee_id = 456) as is_employee
+\gset
+\if :is_customer
+    SELECT * FROM customer WHERE customer_id = 123;
+\elif :is_employee
+    \echo 'is not a customer but is an employee'
+    SELECT * FROM employee WHERE employee_id = 456;
+\else
+    \if yes
+        \echo 'not a customer or employee'
+    \else
+        \echo 'this should never print'
+    \endif
+\endif
+</programlisting>
+        <para>
+        Conditional blocks must begin with a <command>\if</command> and end
+        with an <command>\endif</command>, and the pairs must be found in
+        the same source file. If an EOF is reached on the main file or an
+        <command>\include</command>-ed file before all local
+        <command>\if</command>-<command>\endif</command> are matched, then
+        psql will raise an error.
+        </para>
+        <para>
+        A conditional block can have any number of 
+        <command>\elif</command> clauses, which may optionally be followed by a
+        single <command>\else</command> clause.
+        </para>
+        <para>
+        The <command>\if</command> and <command>\elif</command> commands
+        read the rest of the line and evaluate it as a boolean expression.
+        Currently, expressions are limited to a single unquoted string
+        which are evaluated like other on/off options, so the valid values
+        are any unambiguous case insensitive matches for one of:
+        <literal>true</literal>, <literal>false</literal>, <literal>1</literal>,
+        <literal>0</literal>, <literal>on</literal>, <literal>off</literal>,
+        <literal>yes</literal>, <literal>no</literal>.  So 
+        <literal>t</literal>, <literal>T</literal>, and <literal>tR</literal>
+        will all match <literal>true</literal>.
+        </para>
+        <para>
+        Lines within false branches are not evaluated in any way: queries are
+        not sent to the server, non-conditional commands are not evaluated but
+        bluntly ignored, nested if-expressions in such branches are also not
+        evaluated but are tallied to check for proper nesting.
+        </para>
+        </listitem>
+      </varlistentry>
 
       <varlistentry>
         <term><literal>\ir</literal> or <literal>\include_relative</literal> <replaceable class="parameter">filename</replaceable></term>
diff --git a/src/bin/psql/Makefile b/src/bin/psql/Makefile
index c53733f..7a418c6 100644
--- a/src/bin/psql/Makefile
+++ b/src/bin/psql/Makefile
@@ -61,8 +61,16 @@ uninstall:
 
 clean distclean:
 	rm -f psql$(X) $(OBJS) lex.backup
+	rm -rf tmp_check
 
 # files removed here are supposed to be in the distribution tarball,
 # so do not clean them in the clean/distclean rules
 maintainer-clean: distclean
 	rm -f sql_help.h sql_help.c psqlscanslash.c
+
+
+check:
+	$(prove_check)
+
+installcheck:
+	$(prove_installcheck)
diff --git a/src/bin/psql/command.c b/src/bin/psql/command.c
index f17f610..a916671 100644
--- a/src/bin/psql/command.c
+++ b/src/bin/psql/command.c
@@ -49,6 +49,7 @@
 #include "psqlscanslash.h"
 #include "settings.h"
 #include "variables.h"
+#include "fe_utils/psqlscan_int.h"
 
 /*
  * Editable database object types.
@@ -132,7 +133,7 @@ HandleSlashCmds(PsqlScanState scan_state,
 		status = PSQL_CMD_ERROR;
 	}
 
-	if (status != PSQL_CMD_ERROR)
+	if (status != PSQL_CMD_ERROR && pset.active_branch)
 	{
 		/* eat any remaining arguments after a valid command */
 		/* note we suppress evaluation of backticks here */
@@ -194,6 +195,29 @@ read_connect_arg(PsqlScanState scan_state)
 	return result;
 }
 
+/*
+ * Read and interpret argument as a boolean expression.
+ * Return true if a boolean value was successfully parsed.
+ */
+static bool
+read_boolean_expression(PsqlScanState scan_state, char *action,
+						bool *result)
+{
+	char	*value = psql_scan_slash_option(scan_state,
+											OT_NORMAL, NULL, false);
+	bool	success = ParseVariableBool(value, action, result);
+	free(value);
+	return success;
+}
+
+static bool
+is_branching_command(const char *cmd)
+{
+	return ((strcmp(cmd, "if") == 0 || \
+			strcmp(cmd, "elif") == 0 || \
+			strcmp(cmd, "else") == 0 || \
+			strcmp(cmd, "endif") == 0));
+}
 
 /*
  * Subroutine to actually try to execute a backslash command.
@@ -207,6 +231,14 @@ exec_command(const char *cmd,
 								 * failed */
 	backslashResult status = PSQL_CMD_SKIP_LINE;
 
+	if (!pset.active_branch && !is_branching_command(cmd) )
+	{
+		/* Continue with an empty buffer as if the command were never read */
+		resetPQExpBuffer(query_buf);
+		psql_scan_reset(scan_state);
+		return status;
+	}
+
 	/*
 	 * \a -- toggle field alignment This makes little sense but we keep it
 	 * around.
@@ -1006,6 +1038,160 @@ exec_command(const char *cmd,
 		}
 	}
 
+	/*
+	 * \if <expr> is the beginning of an \if..\endif block.
+	 * <expr> must be a valid boolean expression, or the whole block will be
+	 * ignored.
+	 * If this \if is itself a part of a branch that is false/ignored, it too
+	 * will automatically be ignored.
+	 */
+	else if (strcmp(cmd, "if") == 0)
+	{
+		ifState new_if_state = IFSTATE_IGNORED;
+		/*
+		 * only evaluate the expression for truth if the underlying
+		 * branch is active
+		 */
+		if (pset.active_branch)
+		{
+			bool if_true = false;
+			success = read_boolean_expression(scan_state, "\\if <expr>", &if_true);
+			if (success)
+				new_if_state = (if_true) ? IFSTATE_TRUE : IFSTATE_FALSE;
+		}
+		psqlscan_branch_push(scan_state,new_if_state);
+		pset.active_branch = psqlscan_branch_active(scan_state);
+		psql_scan_reset(scan_state);
+	}
+
+	/*
+	 * \elif <expr> is part of an \if..\endif block
+	 * <expr> will only be evalated for boolean truth if no previous
+	 * \if or \endif in the block has evaluated to true and the \if..\endif
+	 * block is not itself being ignored.
+	 * in the event that <expr> does not conform to a proper boolean expression,
+	 * all following statements in the block will be ignored until \endif is
+	 * encountered.
+	 *
+	 */
+	else if (strcmp(cmd, "elif") == 0)
+	{
+		if (psqlscan_branch_empty(scan_state))
+		{
+			psql_error("encountered un-matched \\elif\n");
+			success = false;
+		}
+		else
+		{
+			bool elif_true = false;
+			switch (psqlscan_branch_get_state(scan_state))
+			{
+				case IFSTATE_IGNORED:
+					/*
+					 * inactive branch, do nothing:
+					 * either if-endif already had a true block,
+					 * or whole parent block is false.
+					 */
+					break;
+				case IFSTATE_TRUE:
+					/*
+					 * just finished true section of active branch
+					 * do not evaluate expression, just skip
+					 */
+					psqlscan_branch_set_state(scan_state, IFSTATE_IGNORED);
+					pset.active_branch = false;
+					break;
+				case IFSTATE_FALSE:
+					/*
+					 * have not yet found a true block in this if-endif,
+					 * determine if this section is true or not.
+					 * variable expansion must be temporarily turned back
+					 * on to read the boolean expression.
+					 */
+					pset.active_branch = true;
+					success = read_boolean_expression(scan_state, "\\elif <expr>",
+														&elif_true);
+					pset.active_branch = false;
+					if (!success)
+						psqlscan_branch_set_state(scan_state, IFSTATE_IGNORED);
+					else if (elif_true)
+						psqlscan_branch_set_state(scan_state, IFSTATE_TRUE);
+					pset.active_branch = psqlscan_branch_active(scan_state);
+					break;
+				case IFSTATE_ELSE_TRUE:
+				case IFSTATE_ELSE_FALSE:
+					psql_error("encountered \\elif after \\else\n");
+					success = false;
+					break;
+				default:
+					break;
+			}
+		}
+		psql_scan_reset(scan_state);
+	}
+
+	/*
+	 * \else is part of an \if..\endif block
+	 * the statements within an \else branch will only be executed if
+	 * all previous \if and \endif expressions evaluated to false
+	 * and the block was not itself being ignored.
+	 */
+	else if (strcmp(cmd, "else") == 0)
+	{
+		if (psqlscan_branch_empty(scan_state))
+		{
+			psql_error("encountered un-matched \\else\n");
+			success = false;
+		}
+		else
+		{
+			switch (psqlscan_branch_get_state(scan_state))
+			{
+				case IFSTATE_TRUE:
+				case IFSTATE_IGNORED:
+					/*
+					 * either just finished true section of an active branch,
+					 * or whole branch was inactive. either way, be on the
+					 * lookout for any invalid \endif or \else commands
+					 */
+					psqlscan_branch_set_state(scan_state, IFSTATE_ELSE_FALSE);
+					break;
+				case IFSTATE_FALSE:
+					/* just finished false section of an active branch */
+					psqlscan_branch_set_state(scan_state, IFSTATE_ELSE_TRUE);
+					pset.active_branch = true;
+					break;
+				case IFSTATE_ELSE_TRUE:
+				case IFSTATE_ELSE_FALSE:
+					psql_error("encountered \\else after \\else\n");
+					success = false;
+					break;
+				default:
+					break;
+			}
+		}
+		pset.active_branch = psqlscan_branch_active(scan_state);
+		psql_scan_reset(scan_state);
+	}
+
+	/*
+	 * \endif - closing statment of an \if...\endif block
+	 */
+	else if (strcmp(cmd, "endif") == 0)
+	{
+		if (psqlscan_branch_empty(scan_state))
+		{
+			psql_error("encountered un-matched \\endif\n");
+			success = false;
+		}
+		else
+		{
+			psqlscan_branch_end_state(scan_state);
+			pset.active_branch = psqlscan_branch_active(scan_state);
+		}
+		psql_scan_reset(scan_state);
+	}
+
 	/* \l is list databases */
 	else if (strcmp(cmd, "l") == 0 || strcmp(cmd, "list") == 0 ||
 			 strcmp(cmd, "l+") == 0 || strcmp(cmd, "list+") == 0)
diff --git a/src/bin/psql/common.c b/src/bin/psql/common.c
index 6e3acdc..9f1a072 100644
--- a/src/bin/psql/common.c
+++ b/src/bin/psql/common.c
@@ -119,6 +119,11 @@ setQFout(const char *fname)
  * If "escape" is true, return the value suitably quoted and escaped,
  * as an identifier or string literal depending on "as_ident".
  * (Failure in escaping should lead to returning NULL.)
+ *
+ * Variables are not expanded if the current branch is inactive
+ * (part of an \if..\endif section which is false). \elif branches
+ * will need temporarily mark the branch active in order to
+ * properly evaluate conditionals.
  */
 char *
 psql_get_variable(const char *varname, bool escape, bool as_ident)
@@ -126,6 +131,10 @@ psql_get_variable(const char *varname, bool escape, bool as_ident)
 	char	   *result;
 	const char *value;
 
+	/* do not expand variables if the branch is inactive */
+	if (!pset.active_branch)
+		return NULL;
+
 	value = GetVariable(pset.vars, varname);
 	if (!value)
 		return NULL;
diff --git a/src/bin/psql/mainloop.c b/src/bin/psql/mainloop.c
index dc25b4b..9c609b4 100644
--- a/src/bin/psql/mainloop.c
+++ b/src/bin/psql/mainloop.c
@@ -15,7 +15,7 @@
 #include "settings.h"
 
 #include "mb/pg_wchar.h"
-
+#include "fe_utils/psqlscan_int.h"
 
 /* callback functions for our flex lexer */
 const PsqlScanCallbacks psqlscan_callbacks = {
@@ -23,7 +23,6 @@ const PsqlScanCallbacks psqlscan_callbacks = {
 	psql_error
 };
 
-
 /*
  * Main processing loop for reading lines of input
  *	and sending them to the backend.
@@ -296,10 +295,15 @@ MainLoop(FILE *source)
 					line_saved_in_history = true;
 				}
 
-				/* execute query */
-				success = SendQuery(query_buf->data);
+				/* execute query if branch is active */
+				if (pset.active_branch)
+					success = SendQuery(query_buf->data);
+				else
+					success = true;
+
 				slashCmdStatus = success ? PSQL_CMD_SEND : PSQL_CMD_ERROR;
 				pset.stmt_lineno = 1;
+				slashCmdStatus = success ? PSQL_CMD_SEND : PSQL_CMD_ERROR;
 
 				/* transfer query to previous_buf by pointer-swapping */
 				{
@@ -358,7 +362,11 @@ MainLoop(FILE *source)
 
 				if (slashCmdStatus == PSQL_CMD_SEND)
 				{
-					success = SendQuery(query_buf->data);
+					/* ignore queries on inactive branches */
+					if (pset.active_branch)
+						success = SendQuery(query_buf->data);
+					else
+						success = true;
 
 					/* transfer query to previous_buf by pointer-swapping */
 					{
@@ -367,6 +375,7 @@ MainLoop(FILE *source)
 						previous_buf = query_buf;
 						query_buf = swap_buf;
 					}
+
 					resetPQExpBuffer(query_buf);
 
 					/* flush any paren nesting info after forced send */
@@ -429,8 +438,11 @@ MainLoop(FILE *source)
 		if (pset.cur_cmd_interactive)
 			pg_send_history(history_buf);
 
-		/* execute query */
-		success = SendQuery(query_buf->data);
+		/* execute query if branch is active*/
+		if (pset.active_branch)
+			success = SendQuery(query_buf->data);
+		else
+			success = true;
 
 		if (!success && die_on_error)
 			successResult = EXIT_USER;
@@ -451,6 +463,14 @@ MainLoop(FILE *source)
 	destroyPQExpBuffer(previous_buf);
 	destroyPQExpBuffer(history_buf);
 
+	/* check for unbalanced \if-\endifs unless user explicitly quit */
+	if (slashCmdStatus != PSQL_CMD_TERMINATE && !psqlscan_branch_empty(scan_state))
+	{
+		psql_error("found EOF before closing \\endif(s)\n");
+		if (die_on_error)
+			successResult = EXIT_USER;
+	}
+
 	psql_scan_destroy(scan_state);
 
 	pset.cur_cmd_source = prev_cmd_source;
diff --git a/src/bin/psql/mainloop.h b/src/bin/psql/mainloop.h
index 228a5e0..47f4c32 100644
--- a/src/bin/psql/mainloop.h
+++ b/src/bin/psql/mainloop.h
@@ -14,4 +14,5 @@ extern const PsqlScanCallbacks psqlscan_callbacks;
 
 extern int	MainLoop(FILE *source);
 
+
 #endif   /* MAINLOOP_H */
diff --git a/src/bin/psql/settings.h b/src/bin/psql/settings.h
index 4c7c3b1..15d5599 100644
--- a/src/bin/psql/settings.h
+++ b/src/bin/psql/settings.h
@@ -114,6 +114,9 @@ typedef struct _psqlSettings
 
 	VariableSpace vars;			/* "shell variable" repository */
 
+	bool		active_branch;	/* true if session is not in an \if branch
+								 * or the current branch is true */
+
 	/*
 	 * The remaining fields are set by assign hooks associated with entries in
 	 * "vars".  They should not be set directly except by those hook
diff --git a/src/bin/psql/startup.c b/src/bin/psql/startup.c
index 0574b5b..df25864 100644
--- a/src/bin/psql/startup.c
+++ b/src/bin/psql/startup.c
@@ -128,6 +128,8 @@ main(int argc, char *argv[])
 	setvbuf(stderr, NULL, _IONBF, 0);
 #endif
 
+	pset.active_branch = true;
+
 	pset.progname = get_progname(argv[0]);
 
 	pset.db = NULL;
diff --git a/src/bin/psql/t/001_if.pl b/src/bin/psql/t/001_if.pl
new file mode 100644
index 0000000..e8cc897
--- /dev/null
+++ b/src/bin/psql/t/001_if.pl
@@ -0,0 +1,25 @@
+use strict;
+use warnings;
+
+use PostgresNode;
+use TestLib;
+use Test::More tests => 1;
+
+#
+# test invalid \if respects ON_ERROR_STOP
+#
+my $stdout;
+my $stderr;
+my $node = get_new_node('master');
+$node->init;
+$node->start;
+
+my $retcode = $node->psql('postgres', '\if invalid_expression',
+		stdout => \$stdout, stderr => \$stderr,
+		on_error_stop => 1);
+is($retcode,'0','Invalid \if respects ON_ERROR_STOP');
+
+$node->teardown_node;
+
+
+
diff --git a/src/fe_utils/psqlscan.l b/src/fe_utils/psqlscan.l
index 1b29341..a09d404 100644
--- a/src/fe_utils/psqlscan.l
+++ b/src/fe_utils/psqlscan.l
@@ -904,6 +904,8 @@ psql_scan_create(const PsqlScanCallbacks *callbacks)
 
 	psql_scan_reset(state);
 
+	state->branch_stack = NULL;
+
 	return state;
 }
 
@@ -919,6 +921,13 @@ psql_scan_destroy(PsqlScanState state)
 
 	yylex_destroy(state->scanner);
 
+	while (state->branch_stack != NULL)
+	{
+		IfStackElem *p = state->branch_stack;
+		state->branch_stack = state->branch_stack->next;
+		free(p);
+	}
+
 	free(state);
 }
 
@@ -1426,3 +1435,88 @@ psqlscan_escape_variable(PsqlScanState state, const char *txt, int len,
 		psqlscan_emit(state, txt, len);
 	}
 }
+
+/*
+ * psqlscan_branch_empty
+ *
+ * True if there are no active \if-structures
+ */
+bool
+psqlscan_branch_empty(PsqlScanState state)
+{
+	return (state->branch_stack == NULL);
+}
+
+/*
+ * Fetch the current state of the top of the stack
+ */
+ifState
+psqlscan_branch_get_state(PsqlScanState state)
+{
+	if (psqlscan_branch_empty(state))
+		return IFSTATE_NONE;
+	return state->branch_stack->if_state;
+}
+
+/*
+ * psqlscan_branch_active
+ *
+ * True if the current \if-block (if any) is true and queries/commands
+ * should be executed.
+ */
+bool
+psqlscan_branch_active(PsqlScanState state)
+{
+	ifState s = psqlscan_branch_get_state(state);
+	return ((s == IFSTATE_NONE) ||
+			(s == IFSTATE_TRUE) ||
+			(s == IFSTATE_ELSE_TRUE));
+}
+
+
+/*
+ * psqlscan_branch_push
+ *
+ * Create a new \if branch.
+ */
+bool
+psqlscan_branch_push(PsqlScanState state, ifState new_state)
+{
+	IfStackElem *p = pg_malloc0(sizeof(IfStackElem));
+	p->if_state = new_state;
+	p->next = state->branch_stack;
+	state->branch_stack = p;
+	return true;
+}
+
+/*
+ * psqlscan_branch_set_state
+ *
+ * Change the state of the topmost branch.
+ * Returns false if there was branch state to set.
+ */
+bool
+psqlscan_branch_set_state(PsqlScanState state, ifState new_state)
+{
+	if (psqlscan_branch_empty(state))
+		return false;
+	state->branch_stack->if_state = new_state;
+	return true;
+}
+
+/*
+ * psqlscan_branch_end_state
+ *
+ * Destroy the topmost branch because and \endif was encountered.
+ * Returns false if there was no branch to end.
+ */
+bool
+psqlscan_branch_end_state(PsqlScanState state)
+{
+	IfStackElem *p = state->branch_stack;
+	if (!p)
+		return false;
+	state->branch_stack = state->branch_stack->next;
+	free(p);
+	return true;
+}
diff --git a/src/include/fe_utils/psqlscan_int.h b/src/include/fe_utils/psqlscan_int.h
index 0fddc7a..a24a5ac 100644
--- a/src/include/fe_utils/psqlscan_int.h
+++ b/src/include/fe_utils/psqlscan_int.h
@@ -75,6 +75,30 @@ typedef struct StackElem
 	struct StackElem *next;
 } StackElem;
 
+typedef enum _ifState
+{
+	IFSTATE_NONE = 0,	/* Not currently in an \if block */
+	IFSTATE_TRUE,		/* currently in an \if or \elif which is true
+						 * and all parent branches (if any) are true */
+	IFSTATE_FALSE,		/* currently in an \if or \elif which is false
+						 * but no true branch has yet been seen,
+						 * and all parent branches (if any) are true */
+	IFSTATE_IGNORED,	/* currently in an \elif which follows a true \if
+						 * or the whole \if is a child of a false parent */
+	IFSTATE_ELSE_TRUE,	/* currently in an \else which is true
+						 * and all parent branches (if any) are true */
+	IFSTATE_ELSE_FALSE	/* currently in an \else which is false or ignored */
+} ifState;
+
+/*
+ * The state of nested ifs is stored in a stack.
+ */
+typedef struct IfStackElem
+{
+	ifState		if_state;
+	struct IfStackElem *next;
+} IfStackElem;
+
 /*
  * All working state of the lexer must be stored in PsqlScanStateData
  * between calls.  This allows us to have multiple open lexer operations,
@@ -118,6 +142,11 @@ typedef struct PsqlScanStateData
 	 * Callback functions provided by the program making use of the lexer.
 	 */
 	const PsqlScanCallbacks *callbacks;
+
+	/*
+	 * \if branch state variables
+	 */
+	IfStackElem *branch_stack;
 } PsqlScanStateData;
 
 
@@ -141,4 +170,21 @@ extern void psqlscan_escape_variable(PsqlScanState state,
 						 const char *txt, int len,
 						 bool as_ident);
 
+/*
+ * branching commands
+ */
+extern bool psqlscan_branch_empty(PsqlScanState state);
+
+extern bool psqlscan_branch_active(PsqlScanState state);
+
+extern ifState psqlscan_branch_get_state(PsqlScanState state);
+
+extern bool psqlscan_branch_push(PsqlScanState state,
+									ifState new_state);
+
+extern bool psqlscan_branch_set_state(PsqlScanState state,
+									ifState new_state);
+
+extern bool psqlscan_branch_end_state(PsqlScanState state);
+
 #endif   /* PSQLSCAN_INT_H */
diff --git a/src/test/regress/expected/psql.out b/src/test/regress/expected/psql.out
index 420825a..ade98c6 100644
--- a/src/test/regress/expected/psql.out
+++ b/src/test/regress/expected/psql.out
@@ -2695,6 +2695,84 @@ deallocate q;
 \pset format aligned
 \pset expanded off
 \pset border 1
+\if true
+	\if 1
+		\if yes
+			\if on
+				\echo 'all true'
+all true
+			\else
+				\echo 'should not print #1-1'
+			\endif
+		\else
+			\echo 'should not print #1-2'
+		\endif
+	\else
+		\echo 'should not print #1-3'
+	\endif
+\else
+	\echo 'should not print #1-4'
+\endif
+\if false
+	\echo 'should not print #2-1'
+\elif 0
+	\echo 'should not print #2-2'
+\elif no
+	\echo 'should not print #2-3'
+\elif off
+	\echo 'should not print #2-4'
+\else
+	\echo 'all false'
+all false
+\endif
+\if true
+	\echo 'first thing true'
+first thing true
+\else
+	\echo 'should not print #3-1'
+\endif
+\if false
+	\echo 'should not print #4-1'
+\elif true
+	\echo 'second thing true'
+second thing true
+\else
+	\echo 'should not print #5-1'
+\endif
+\if invalid_boolean_expression
+unrecognized value "invalid_boolean_expression" for "\if <expr>": boolean expected
+	\echo 'should not print #6-1'
+\else
+	\echo 'should not print because whole if-then is wrecked #6-2'
+\endif
+\set var 'ab''cd'
+-- select :var;
+\if false
+  select :var ;
+\else
+  select 1;
+ ?column? 
+----------
+        1
+(1 row)
+
+\endif
+\endif
+encountered un-matched \endif
+\else
+encountered un-matched \else
+\elif
+encountered un-matched \elif
+\if true
+\else
+\else
+encountered \else after \else
+\endif
+\if false
+\else
+\elif
+encountered \elif after \else
+\endif
 -- SHOW_CONTEXT
 \set SHOW_CONTEXT never
 do $$
diff --git a/src/test/regress/sql/psql.sql b/src/test/regress/sql/psql.sql
index 79624b9..482bab8 100644
--- a/src/test/regress/sql/psql.sql
+++ b/src/test/regress/sql/psql.sql
@@ -365,6 +365,80 @@ deallocate q;
 \pset expanded off
 \pset border 1
 
+\if true
+	\if 1
+		\if yes
+			\if on
+				\echo 'all true'
+			\else
+				\echo 'should not print #1-1'
+			\endif
+		\else
+			\echo 'should not print #1-2'
+		\endif
+	\else
+		\echo 'should not print #1-3'
+	\endif
+\else
+	\echo 'should not print #1-4'
+\endif
+
+\if false
+	\echo 'should not print #2-1'
+\elif 0
+	\echo 'should not print #2-2'
+\elif no
+	\echo 'should not print #2-3'
+\elif off
+	\echo 'should not print #2-4'
+\else
+	\echo 'all false'
+\endif
+
+\if true
+	\echo 'first thing true'
+\else
+	\echo 'should not print #3-1'
+\endif
+
+\if false
+	\echo 'should not print #4-1'
+\elif true
+	\echo 'second thing true'
+\else
+	\echo 'should not print #5-1'
+\endif
+
+\if invalid_boolean_expression
+	\echo 'should not print #6-1'
+\else
+	\echo 'should not print because whole if-then is wrecked #6-2'
+\endif
+
+\set var 'ab''cd'
+-- select :var;
+\if false
+  select :var ;
+\else
+  select 1;
+\endif
+
+\endif
+
+\else
+
+\elif
+
+\if true
+\else
+\else
+\endif
+
+\if false
+\else
+\elif
+\endif
+
 -- SHOW_CONTEXT
 
 \set SHOW_CONTEXT never


-- 
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers

Attachments:

  [text/plain] 0001.if_endif.v4.diff (22.7K, ../../CADkLM=fdBs+G1QrUvqu5MxW7jGg-ULZFcM3Fd2kev6fjrp7-0g@mail.gmail.com/3-0001.if_endif.v4.diff)
  download | inline diff:
diff --git a/doc/src/sgml/ref/psql-ref.sgml b/doc/src/sgml/ref/psql-ref.sgml
index 4e51e90..aad62ac 100644
--- a/doc/src/sgml/ref/psql-ref.sgml
+++ b/doc/src/sgml/ref/psql-ref.sgml
@@ -2035,6 +2035,67 @@ hello 10
         </listitem>
       </varlistentry>
 
+      <varlistentry>
+        <term><literal>\if</literal> <replaceable class="parameter">expr</replaceable></term>
+        <term><literal>\elif</literal> <replaceable class="parameter">expr</replaceable></term>
+        <term><literal>\else</literal></term>
+        <term><literal>\endif</literal></term>
+        <listitem>
+        <para>
+        This group of commands implements nestable conditional blocks, like
+        this:
+        </para>
+<programlisting>
+SELECT
+    EXISTS(SELECT 1 FROM customer WHERE customer_id = 123) as is_customer,
+    EXISTS(SELECT 1 FROM employee WHERE employee_id = 456) as is_employee
+\gset
+\if :is_customer
+    SELECT * FROM customer WHERE customer_id = 123;
+\elif :is_employee
+    \echo 'is not a customer but is an employee'
+    SELECT * FROM employee WHERE employee_id = 456;
+\else
+    \if yes
+        \echo 'not a customer or employee'
+    \else
+        \echo 'this should never print'
+    \endif
+\endif
+</programlisting>
+        <para>
+        Conditional blocks must begin with a <command>\if</command> and end
+        with an <command>\endif</command>, and the pairs must be found in
+        the same source file. If an EOF is reached on the main file or an
+        <command>\include</command>-ed file before all local
+        <command>\if</command>-<command>\endif</command> are matched, then
+        psql will raise an error.
+        </para>
+        <para>
+        A conditional block can have any number of 
+        <command>\elif</command> clauses, which may optionally be followed by a
+        single <command>\else</command> clause.
+        </para>
+        <para>
+        The <command>\if</command> and <command>\elif</command> commands
+        read the rest of the line and evaluate it as a boolean expression.
+        Currently, expressions are limited to a single unquoted string
+        which are evaluated like other on/off options, so the valid values
+        are any unambiguous case insensitive matches for one of:
+        <literal>true</literal>, <literal>false</literal>, <literal>1</literal>,
+        <literal>0</literal>, <literal>on</literal>, <literal>off</literal>,
+        <literal>yes</literal>, <literal>no</literal>.  So 
+        <literal>t</literal>, <literal>T</literal>, and <literal>tR</literal>
+        will all match <literal>true</literal>.
+        </para>
+        <para>
+        Lines within false branches are not evaluated in any way: queries are
+        not sent to the server, non-conditional commands are not evaluated but
+        bluntly ignored, nested if-expressions in such branches are also not
+        evaluated but are tallied to check for proper nesting.
+        </para>
+        </listitem>
+      </varlistentry>
 
       <varlistentry>
         <term><literal>\ir</literal> or <literal>\include_relative</literal> <replaceable class="parameter">filename</replaceable></term>
diff --git a/src/bin/psql/Makefile b/src/bin/psql/Makefile
index c53733f..7a418c6 100644
--- a/src/bin/psql/Makefile
+++ b/src/bin/psql/Makefile
@@ -61,8 +61,16 @@ uninstall:
 
 clean distclean:
 	rm -f psql$(X) $(OBJS) lex.backup
+	rm -rf tmp_check
 
 # files removed here are supposed to be in the distribution tarball,
 # so do not clean them in the clean/distclean rules
 maintainer-clean: distclean
 	rm -f sql_help.h sql_help.c psqlscanslash.c
+
+
+check:
+	$(prove_check)
+
+installcheck:
+	$(prove_installcheck)
diff --git a/src/bin/psql/command.c b/src/bin/psql/command.c
index f17f610..a916671 100644
--- a/src/bin/psql/command.c
+++ b/src/bin/psql/command.c
@@ -49,6 +49,7 @@
 #include "psqlscanslash.h"
 #include "settings.h"
 #include "variables.h"
+#include "fe_utils/psqlscan_int.h"
 
 /*
  * Editable database object types.
@@ -132,7 +133,7 @@ HandleSlashCmds(PsqlScanState scan_state,
 		status = PSQL_CMD_ERROR;
 	}
 
-	if (status != PSQL_CMD_ERROR)
+	if (status != PSQL_CMD_ERROR && pset.active_branch)
 	{
 		/* eat any remaining arguments after a valid command */
 		/* note we suppress evaluation of backticks here */
@@ -194,6 +195,29 @@ read_connect_arg(PsqlScanState scan_state)
 	return result;
 }
 
+/*
+ * Read and interpret argument as a boolean expression.
+ * Return true if a boolean value was successfully parsed.
+ */
+static bool
+read_boolean_expression(PsqlScanState scan_state, char *action,
+						bool *result)
+{
+	char	*value = psql_scan_slash_option(scan_state,
+											OT_NORMAL, NULL, false);
+	bool	success = ParseVariableBool(value, action, result);
+	free(value);
+	return success;
+}
+
+static bool
+is_branching_command(const char *cmd)
+{
+	return ((strcmp(cmd, "if") == 0 || \
+			strcmp(cmd, "elif") == 0 || \
+			strcmp(cmd, "else") == 0 || \
+			strcmp(cmd, "endif") == 0));
+}
 
 /*
  * Subroutine to actually try to execute a backslash command.
@@ -207,6 +231,14 @@ exec_command(const char *cmd,
 								 * failed */
 	backslashResult status = PSQL_CMD_SKIP_LINE;
 
+	if (!pset.active_branch && !is_branching_command(cmd) )
+	{
+		/* Continue with an empty buffer as if the command were never read */
+		resetPQExpBuffer(query_buf);
+		psql_scan_reset(scan_state);
+		return status;
+	}
+
 	/*
 	 * \a -- toggle field alignment This makes little sense but we keep it
 	 * around.
@@ -1006,6 +1038,160 @@ exec_command(const char *cmd,
 		}
 	}
 
+	/*
+	 * \if <expr> is the beginning of an \if..\endif block.
+	 * <expr> must be a valid boolean expression, or the whole block will be
+	 * ignored.
+	 * If this \if is itself a part of a branch that is false/ignored, it too
+	 * will automatically be ignored.
+	 */
+	else if (strcmp(cmd, "if") == 0)
+	{
+		ifState new_if_state = IFSTATE_IGNORED;
+		/*
+		 * only evaluate the expression for truth if the underlying
+		 * branch is active
+		 */
+		if (pset.active_branch)
+		{
+			bool if_true = false;
+			success = read_boolean_expression(scan_state, "\\if <expr>", &if_true);
+			if (success)
+				new_if_state = (if_true) ? IFSTATE_TRUE : IFSTATE_FALSE;
+		}
+		psqlscan_branch_push(scan_state,new_if_state);
+		pset.active_branch = psqlscan_branch_active(scan_state);
+		psql_scan_reset(scan_state);
+	}
+
+	/*
+	 * \elif <expr> is part of an \if..\endif block
+	 * <expr> will only be evalated for boolean truth if no previous
+	 * \if or \endif in the block has evaluated to true and the \if..\endif
+	 * block is not itself being ignored.
+	 * in the event that <expr> does not conform to a proper boolean expression,
+	 * all following statements in the block will be ignored until \endif is
+	 * encountered.
+	 *
+	 */
+	else if (strcmp(cmd, "elif") == 0)
+	{
+		if (psqlscan_branch_empty(scan_state))
+		{
+			psql_error("encountered un-matched \\elif\n");
+			success = false;
+		}
+		else
+		{
+			bool elif_true = false;
+			switch (psqlscan_branch_get_state(scan_state))
+			{
+				case IFSTATE_IGNORED:
+					/*
+					 * inactive branch, do nothing:
+					 * either if-endif already had a true block,
+					 * or whole parent block is false.
+					 */
+					break;
+				case IFSTATE_TRUE:
+					/*
+					 * just finished true section of active branch
+					 * do not evaluate expression, just skip
+					 */
+					psqlscan_branch_set_state(scan_state, IFSTATE_IGNORED);
+					pset.active_branch = false;
+					break;
+				case IFSTATE_FALSE:
+					/*
+					 * have not yet found a true block in this if-endif,
+					 * determine if this section is true or not.
+					 * variable expansion must be temporarily turned back
+					 * on to read the boolean expression.
+					 */
+					pset.active_branch = true;
+					success = read_boolean_expression(scan_state, "\\elif <expr>",
+														&elif_true);
+					pset.active_branch = false;
+					if (!success)
+						psqlscan_branch_set_state(scan_state, IFSTATE_IGNORED);
+					else if (elif_true)
+						psqlscan_branch_set_state(scan_state, IFSTATE_TRUE);
+					pset.active_branch = psqlscan_branch_active(scan_state);
+					break;
+				case IFSTATE_ELSE_TRUE:
+				case IFSTATE_ELSE_FALSE:
+					psql_error("encountered \\elif after \\else\n");
+					success = false;
+					break;
+				default:
+					break;
+			}
+		}
+		psql_scan_reset(scan_state);
+	}
+
+	/*
+	 * \else is part of an \if..\endif block
+	 * the statements within an \else branch will only be executed if
+	 * all previous \if and \endif expressions evaluated to false
+	 * and the block was not itself being ignored.
+	 */
+	else if (strcmp(cmd, "else") == 0)
+	{
+		if (psqlscan_branch_empty(scan_state))
+		{
+			psql_error("encountered un-matched \\else\n");
+			success = false;
+		}
+		else
+		{
+			switch (psqlscan_branch_get_state(scan_state))
+			{
+				case IFSTATE_TRUE:
+				case IFSTATE_IGNORED:
+					/*
+					 * either just finished true section of an active branch,
+					 * or whole branch was inactive. either way, be on the
+					 * lookout for any invalid \endif or \else commands
+					 */
+					psqlscan_branch_set_state(scan_state, IFSTATE_ELSE_FALSE);
+					break;
+				case IFSTATE_FALSE:
+					/* just finished false section of an active branch */
+					psqlscan_branch_set_state(scan_state, IFSTATE_ELSE_TRUE);
+					pset.active_branch = true;
+					break;
+				case IFSTATE_ELSE_TRUE:
+				case IFSTATE_ELSE_FALSE:
+					psql_error("encountered \\else after \\else\n");
+					success = false;
+					break;
+				default:
+					break;
+			}
+		}
+		pset.active_branch = psqlscan_branch_active(scan_state);
+		psql_scan_reset(scan_state);
+	}
+
+	/*
+	 * \endif - closing statment of an \if...\endif block
+	 */
+	else if (strcmp(cmd, "endif") == 0)
+	{
+		if (psqlscan_branch_empty(scan_state))
+		{
+			psql_error("encountered un-matched \\endif\n");
+			success = false;
+		}
+		else
+		{
+			psqlscan_branch_end_state(scan_state);
+			pset.active_branch = psqlscan_branch_active(scan_state);
+		}
+		psql_scan_reset(scan_state);
+	}
+
 	/* \l is list databases */
 	else if (strcmp(cmd, "l") == 0 || strcmp(cmd, "list") == 0 ||
 			 strcmp(cmd, "l+") == 0 || strcmp(cmd, "list+") == 0)
diff --git a/src/bin/psql/common.c b/src/bin/psql/common.c
index 6e3acdc..9f1a072 100644
--- a/src/bin/psql/common.c
+++ b/src/bin/psql/common.c
@@ -119,6 +119,11 @@ setQFout(const char *fname)
  * If "escape" is true, return the value suitably quoted and escaped,
  * as an identifier or string literal depending on "as_ident".
  * (Failure in escaping should lead to returning NULL.)
+ *
+ * Variables are not expanded if the current branch is inactive
+ * (part of an \if..\endif section which is false). \elif branches
+ * will need temporarily mark the branch active in order to
+ * properly evaluate conditionals.
  */
 char *
 psql_get_variable(const char *varname, bool escape, bool as_ident)
@@ -126,6 +131,10 @@ psql_get_variable(const char *varname, bool escape, bool as_ident)
 	char	   *result;
 	const char *value;
 
+	/* do not expand variables if the branch is inactive */
+	if (!pset.active_branch)
+		return NULL;
+
 	value = GetVariable(pset.vars, varname);
 	if (!value)
 		return NULL;
diff --git a/src/bin/psql/mainloop.c b/src/bin/psql/mainloop.c
index dc25b4b..9c609b4 100644
--- a/src/bin/psql/mainloop.c
+++ b/src/bin/psql/mainloop.c
@@ -15,7 +15,7 @@
 #include "settings.h"
 
 #include "mb/pg_wchar.h"
-
+#include "fe_utils/psqlscan_int.h"
 
 /* callback functions for our flex lexer */
 const PsqlScanCallbacks psqlscan_callbacks = {
@@ -23,7 +23,6 @@ const PsqlScanCallbacks psqlscan_callbacks = {
 	psql_error
 };
 
-
 /*
  * Main processing loop for reading lines of input
  *	and sending them to the backend.
@@ -296,10 +295,15 @@ MainLoop(FILE *source)
 					line_saved_in_history = true;
 				}
 
-				/* execute query */
-				success = SendQuery(query_buf->data);
+				/* execute query if branch is active */
+				if (pset.active_branch)
+					success = SendQuery(query_buf->data);
+				else
+					success = true;
+
 				slashCmdStatus = success ? PSQL_CMD_SEND : PSQL_CMD_ERROR;
 				pset.stmt_lineno = 1;
+				slashCmdStatus = success ? PSQL_CMD_SEND : PSQL_CMD_ERROR;
 
 				/* transfer query to previous_buf by pointer-swapping */
 				{
@@ -358,7 +362,11 @@ MainLoop(FILE *source)
 
 				if (slashCmdStatus == PSQL_CMD_SEND)
 				{
-					success = SendQuery(query_buf->data);
+					/* ignore queries on inactive branches */
+					if (pset.active_branch)
+						success = SendQuery(query_buf->data);
+					else
+						success = true;
 
 					/* transfer query to previous_buf by pointer-swapping */
 					{
@@ -367,6 +375,7 @@ MainLoop(FILE *source)
 						previous_buf = query_buf;
 						query_buf = swap_buf;
 					}
+
 					resetPQExpBuffer(query_buf);
 
 					/* flush any paren nesting info after forced send */
@@ -429,8 +438,11 @@ MainLoop(FILE *source)
 		if (pset.cur_cmd_interactive)
 			pg_send_history(history_buf);
 
-		/* execute query */
-		success = SendQuery(query_buf->data);
+		/* execute query if branch is active*/
+		if (pset.active_branch)
+			success = SendQuery(query_buf->data);
+		else
+			success = true;
 
 		if (!success && die_on_error)
 			successResult = EXIT_USER;
@@ -451,6 +463,14 @@ MainLoop(FILE *source)
 	destroyPQExpBuffer(previous_buf);
 	destroyPQExpBuffer(history_buf);
 
+	/* check for unbalanced \if-\endifs unless user explicitly quit */
+	if (slashCmdStatus != PSQL_CMD_TERMINATE && !psqlscan_branch_empty(scan_state))
+	{
+		psql_error("found EOF before closing \\endif(s)\n");
+		if (die_on_error)
+			successResult = EXIT_USER;
+	}
+
 	psql_scan_destroy(scan_state);
 
 	pset.cur_cmd_source = prev_cmd_source;
diff --git a/src/bin/psql/mainloop.h b/src/bin/psql/mainloop.h
index 228a5e0..47f4c32 100644
--- a/src/bin/psql/mainloop.h
+++ b/src/bin/psql/mainloop.h
@@ -14,4 +14,5 @@ extern const PsqlScanCallbacks psqlscan_callbacks;
 
 extern int	MainLoop(FILE *source);
 
+
 #endif   /* MAINLOOP_H */
diff --git a/src/bin/psql/settings.h b/src/bin/psql/settings.h
index 4c7c3b1..15d5599 100644
--- a/src/bin/psql/settings.h
+++ b/src/bin/psql/settings.h
@@ -114,6 +114,9 @@ typedef struct _psqlSettings
 
 	VariableSpace vars;			/* "shell variable" repository */
 
+	bool		active_branch;	/* true if session is not in an \if branch
+								 * or the current branch is true */
+
 	/*
 	 * The remaining fields are set by assign hooks associated with entries in
 	 * "vars".  They should not be set directly except by those hook
diff --git a/src/bin/psql/startup.c b/src/bin/psql/startup.c
index 0574b5b..df25864 100644
--- a/src/bin/psql/startup.c
+++ b/src/bin/psql/startup.c
@@ -128,6 +128,8 @@ main(int argc, char *argv[])
 	setvbuf(stderr, NULL, _IONBF, 0);
 #endif
 
+	pset.active_branch = true;
+
 	pset.progname = get_progname(argv[0]);
 
 	pset.db = NULL;
diff --git a/src/bin/psql/t/001_if.pl b/src/bin/psql/t/001_if.pl
new file mode 100644
index 0000000..e8cc897
--- /dev/null
+++ b/src/bin/psql/t/001_if.pl
@@ -0,0 +1,25 @@
+use strict;
+use warnings;
+
+use PostgresNode;
+use TestLib;
+use Test::More tests => 1;
+
+#
+# test invalid \if respects ON_ERROR_STOP
+#
+my $stdout;
+my $stderr;
+my $node = get_new_node('master');
+$node->init;
+$node->start;
+
+my $retcode = $node->psql('postgres', '\if invalid_expression',
+		stdout => \$stdout, stderr => \$stderr,
+		on_error_stop => 1);
+is($retcode,'0','Invalid \if respects ON_ERROR_STOP');
+
+$node->teardown_node;
+
+
+
diff --git a/src/fe_utils/psqlscan.l b/src/fe_utils/psqlscan.l
index 1b29341..a09d404 100644
--- a/src/fe_utils/psqlscan.l
+++ b/src/fe_utils/psqlscan.l
@@ -904,6 +904,8 @@ psql_scan_create(const PsqlScanCallbacks *callbacks)
 
 	psql_scan_reset(state);
 
+	state->branch_stack = NULL;
+
 	return state;
 }
 
@@ -919,6 +921,13 @@ psql_scan_destroy(PsqlScanState state)
 
 	yylex_destroy(state->scanner);
 
+	while (state->branch_stack != NULL)
+	{
+		IfStackElem *p = state->branch_stack;
+		state->branch_stack = state->branch_stack->next;
+		free(p);
+	}
+
 	free(state);
 }
 
@@ -1426,3 +1435,88 @@ psqlscan_escape_variable(PsqlScanState state, const char *txt, int len,
 		psqlscan_emit(state, txt, len);
 	}
 }
+
+/*
+ * psqlscan_branch_empty
+ *
+ * True if there are no active \if-structures
+ */
+bool
+psqlscan_branch_empty(PsqlScanState state)
+{
+	return (state->branch_stack == NULL);
+}
+
+/*
+ * Fetch the current state of the top of the stack
+ */
+ifState
+psqlscan_branch_get_state(PsqlScanState state)
+{
+	if (psqlscan_branch_empty(state))
+		return IFSTATE_NONE;
+	return state->branch_stack->if_state;
+}
+
+/*
+ * psqlscan_branch_active
+ *
+ * True if the current \if-block (if any) is true and queries/commands
+ * should be executed.
+ */
+bool
+psqlscan_branch_active(PsqlScanState state)
+{
+	ifState s = psqlscan_branch_get_state(state);
+	return ((s == IFSTATE_NONE) ||
+			(s == IFSTATE_TRUE) ||
+			(s == IFSTATE_ELSE_TRUE));
+}
+
+
+/*
+ * psqlscan_branch_push
+ *
+ * Create a new \if branch.
+ */
+bool
+psqlscan_branch_push(PsqlScanState state, ifState new_state)
+{
+	IfStackElem *p = pg_malloc0(sizeof(IfStackElem));
+	p->if_state = new_state;
+	p->next = state->branch_stack;
+	state->branch_stack = p;
+	return true;
+}
+
+/*
+ * psqlscan_branch_set_state
+ *
+ * Change the state of the topmost branch.
+ * Returns false if there was branch state to set.
+ */
+bool
+psqlscan_branch_set_state(PsqlScanState state, ifState new_state)
+{
+	if (psqlscan_branch_empty(state))
+		return false;
+	state->branch_stack->if_state = new_state;
+	return true;
+}
+
+/*
+ * psqlscan_branch_end_state
+ *
+ * Destroy the topmost branch because and \endif was encountered.
+ * Returns false if there was no branch to end.
+ */
+bool
+psqlscan_branch_end_state(PsqlScanState state)
+{
+	IfStackElem *p = state->branch_stack;
+	if (!p)
+		return false;
+	state->branch_stack = state->branch_stack->next;
+	free(p);
+	return true;
+}
diff --git a/src/include/fe_utils/psqlscan_int.h b/src/include/fe_utils/psqlscan_int.h
index 0fddc7a..a24a5ac 100644
--- a/src/include/fe_utils/psqlscan_int.h
+++ b/src/include/fe_utils/psqlscan_int.h
@@ -75,6 +75,30 @@ typedef struct StackElem
 	struct StackElem *next;
 } StackElem;
 
+typedef enum _ifState
+{
+	IFSTATE_NONE = 0,	/* Not currently in an \if block */
+	IFSTATE_TRUE,		/* currently in an \if or \elif which is true
+						 * and all parent branches (if any) are true */
+	IFSTATE_FALSE,		/* currently in an \if or \elif which is false
+						 * but no true branch has yet been seen,
+						 * and all parent branches (if any) are true */
+	IFSTATE_IGNORED,	/* currently in an \elif which follows a true \if
+						 * or the whole \if is a child of a false parent */
+	IFSTATE_ELSE_TRUE,	/* currently in an \else which is true
+						 * and all parent branches (if any) are true */
+	IFSTATE_ELSE_FALSE	/* currently in an \else which is false or ignored */
+} ifState;
+
+/*
+ * The state of nested ifs is stored in a stack.
+ */
+typedef struct IfStackElem
+{
+	ifState		if_state;
+	struct IfStackElem *next;
+} IfStackElem;
+
 /*
  * All working state of the lexer must be stored in PsqlScanStateData
  * between calls.  This allows us to have multiple open lexer operations,
@@ -118,6 +142,11 @@ typedef struct PsqlScanStateData
 	 * Callback functions provided by the program making use of the lexer.
 	 */
 	const PsqlScanCallbacks *callbacks;
+
+	/*
+	 * \if branch state variables
+	 */
+	IfStackElem *branch_stack;
 } PsqlScanStateData;
 
 
@@ -141,4 +170,21 @@ extern void psqlscan_escape_variable(PsqlScanState state,
 						 const char *txt, int len,
 						 bool as_ident);
 
+/*
+ * branching commands
+ */
+extern bool psqlscan_branch_empty(PsqlScanState state);
+
+extern bool psqlscan_branch_active(PsqlScanState state);
+
+extern ifState psqlscan_branch_get_state(PsqlScanState state);
+
+extern bool psqlscan_branch_push(PsqlScanState state,
+									ifState new_state);
+
+extern bool psqlscan_branch_set_state(PsqlScanState state,
+									ifState new_state);
+
+extern bool psqlscan_branch_end_state(PsqlScanState state);
+
 #endif   /* PSQLSCAN_INT_H */
diff --git a/src/test/regress/expected/psql.out b/src/test/regress/expected/psql.out
index 420825a..ade98c6 100644
--- a/src/test/regress/expected/psql.out
+++ b/src/test/regress/expected/psql.out
@@ -2695,6 +2695,84 @@ deallocate q;
 \pset format aligned
 \pset expanded off
 \pset border 1
+\if true
+	\if 1
+		\if yes
+			\if on
+				\echo 'all true'
+all true
+			\else
+				\echo 'should not print #1-1'
+			\endif
+		\else
+			\echo 'should not print #1-2'
+		\endif
+	\else
+		\echo 'should not print #1-3'
+	\endif
+\else
+	\echo 'should not print #1-4'
+\endif
+\if false
+	\echo 'should not print #2-1'
+\elif 0
+	\echo 'should not print #2-2'
+\elif no
+	\echo 'should not print #2-3'
+\elif off
+	\echo 'should not print #2-4'
+\else
+	\echo 'all false'
+all false
+\endif
+\if true
+	\echo 'first thing true'
+first thing true
+\else
+	\echo 'should not print #3-1'
+\endif
+\if false
+	\echo 'should not print #4-1'
+\elif true
+	\echo 'second thing true'
+second thing true
+\else
+	\echo 'should not print #5-1'
+\endif
+\if invalid_boolean_expression
+unrecognized value "invalid_boolean_expression" for "\if <expr>": boolean expected
+	\echo 'should not print #6-1'
+\else
+	\echo 'should not print because whole if-then is wrecked #6-2'
+\endif
+\set var 'ab''cd'
+-- select :var;
+\if false
+  select :var ;
+\else
+  select 1;
+ ?column? 
+----------
+        1
+(1 row)
+
+\endif
+\endif
+encountered un-matched \endif
+\else
+encountered un-matched \else
+\elif
+encountered un-matched \elif
+\if true
+\else
+\else
+encountered \else after \else
+\endif
+\if false
+\else
+\elif
+encountered \elif after \else
+\endif
 -- SHOW_CONTEXT
 \set SHOW_CONTEXT never
 do $$
diff --git a/src/test/regress/sql/psql.sql b/src/test/regress/sql/psql.sql
index 79624b9..482bab8 100644
--- a/src/test/regress/sql/psql.sql
+++ b/src/test/regress/sql/psql.sql
@@ -365,6 +365,80 @@ deallocate q;
 \pset expanded off
 \pset border 1
 
+\if true
+	\if 1
+		\if yes
+			\if on
+				\echo 'all true'
+			\else
+				\echo 'should not print #1-1'
+			\endif
+		\else
+			\echo 'should not print #1-2'
+		\endif
+	\else
+		\echo 'should not print #1-3'
+	\endif
+\else
+	\echo 'should not print #1-4'
+\endif
+
+\if false
+	\echo 'should not print #2-1'
+\elif 0
+	\echo 'should not print #2-2'
+\elif no
+	\echo 'should not print #2-3'
+\elif off
+	\echo 'should not print #2-4'
+\else
+	\echo 'all false'
+\endif
+
+\if true
+	\echo 'first thing true'
+\else
+	\echo 'should not print #3-1'
+\endif
+
+\if false
+	\echo 'should not print #4-1'
+\elif true
+	\echo 'second thing true'
+\else
+	\echo 'should not print #5-1'
+\endif
+
+\if invalid_boolean_expression
+	\echo 'should not print #6-1'
+\else
+	\echo 'should not print because whole if-then is wrecked #6-2'
+\endif
+
+\set var 'ab''cd'
+-- select :var;
+\if false
+  select :var ;
+\else
+  select 1;
+\endif
+
+\endif
+
+\else
+
+\elif
+
+\if true
+\else
+\else
+\endif
+
+\if false
+\else
+\elif
+\endif
+
 -- SHOW_CONTEXT
 
 \set SHOW_CONTEXT never


^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-02-01 09:48  Fabien COELHO <coelho@cri.ensmp.fr>
  parent: Corey Huinker <corey.huinker@gmail.com>
  1 sibling, 1 reply; 232+ messages in thread

From: Fabien COELHO @ 2017-02-01 09:48 UTC (permalink / raw)
  To: Corey Huinker <corey.huinker@gmail.com>; +Cc: Tom Lane <tgl@sss.pgh.pa.us>; Daniel Verite <daniel@manitou-mail.org>; pgsql-hackers


Hello Corey,

Some comments about v4:

Patch applies. "git apply" complained about a space or line somewhere, not 
sure why. make check ok.

> - rebased on post-psql hooks master

Good.

> - took nearly every suggestion for change to documentation

Indeed. Looks ok to me.

> - \if ERROR will throw the entire \if..\endif into IGNORE mode

Ok. I think that it is the better behavior, but other people opinion may 
differ. Opinions are welcome.

> - state is now pushed on all \ifs

Ok.

> - reinstated leveraging of ParseVariableBool

Ok.

> - history is now kept in interactive mode regardless of \if-truth

Ok.

> - reworked coding example to cause less agita

Yep.

> - removed MainLoop "are endifs balanced" variable in favor of in-place
> check which respects ON_ERROR_STOP.

Ok.

> - make changes to psql/Makefile to enable TAP tests and created t/ directory
> - wrote an intentionally failing TAP test to see if "make check" executes
> it. it does not. need help.

A failing test expects code 3, not 0 as written in "t/001_if.pl". With

   is($retcode,'3','Invalid \if respects ON_ERROR_STOP');

instead, the tests succeeds because psql returned 3.

More check should be done about stdout to check that it failed for the 
expected reasons though. And maybe more tests could be added to trigger 
all possible state transition errors (eg else after else, elif after else, 
endif without if, if without endif, whatever...).

> I'm hoping my failure in that last bit is easy to spot/fix, so I can move
> forward with testing unbalanced branching, etc.

Other comments and suggestions:

Variable "slashCmdStatus" is set twice in 3 lines in "mainloop.c"?

There is a spurious empty line added at the very end of "mainloop.h":

   +
    #endif   /* MAINLOOP_H */


I would suggest to add a short one line comment before each test to 
explain what is being tested, like "-- test \elif execution", "-- test 
\else execution"...

Debatable suggestion about "psql_branch_empty": the function name somehow 
suggests an "empty branch", where it is really testing that the stack is 
empty. Maybe the function could be removed and "psql_branch_get_state(...) 
== IF_STATE_NONE" used instead. Not sure.

"psql_branch_end_state": it is a pop, it could be named "psql_branch_pop" 
which would be symmetrical to "psql_branch_push"? Or maybe push should be 
named "begin_state" or "new_state"...

C style details: I would avoid non mandatory parentheses, eg:

   +       return ((strcmp(cmd, "if") == 0 || \
   +                       strcmp(cmd, "elif") == 0 || \
   +                       strcmp(cmd, "else") == 0 || \
   +                       strcmp(cmd, "endif") == 0));

I would remove the external double parentheses (( ... )). Also I'm not 
sure why there are end-of-line backslashes on the first instance, maybe a 
macro turned into a function?

   +       return ((s == IFSTATE_NONE) ||
   +                       (s == IFSTATE_TRUE) ||
   +                       (s == IFSTATE_ELSE_TRUE));

I would remove all parenthenses.

  +       return (state->branch_stack == NULL);

Idem.

-- 
Fabien.


-- 
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers



^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-02-01 11:31  Erik Rijkers <er@xs4all.nl>
  parent: Corey Huinker <corey.huinker@gmail.com>
  1 sibling, 1 reply; 232+ messages in thread

From: Erik Rijkers @ 2017-02-01 11:31 UTC (permalink / raw)
  To: Corey Huinker <corey.huinker@gmail.com>; +Cc: Tom Lane <tgl@sss.pgh.pa.us>; Fabien COELHO <coelho@cri.ensmp.fr>; Daniel Verite <daniel@manitou-mail.org>; pgsql-hackers; pgsql-hackers-owner@postgresql.org

On 2017-02-01 09:27, Corey Huinker wrote:
>  0001.if_endif.v4.diff

A few thoughts after a quick try:

I dislike the ease with which one gets stuck inside an \if block, in 
interactive mode.

(for instance, in my very first session, I tried   '\? \if'  to see if 
there is more info in that help-screen, but it only displays the normal 
help screen.  But after that one cannot exit with  \q  anymore, and 
there is no feedback of any kind (prompt?) in which black hole one has 
ended up.  Only a \endif  provides rescue.)

Therefore making it possible to break out of \if-mode with Ctrl-C would 
be an improvement, I think.
I would even prefer it when  \q would exit psql always, even from within 
\if-mode.

Also, shouldn't  the prompt change inside an \if block?

thanks,

Erik Rijkers



-- 
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers



^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-02-01 13:03  Corey Huinker <corey.huinker@gmail.com>
  parent: Erik Rijkers <er@xs4all.nl>
  0 siblings, 1 reply; 232+ messages in thread

From: Corey Huinker @ 2017-02-01 13:03 UTC (permalink / raw)
  To: Erik Rijkers <er@xs4all.nl>; +Cc: Tom Lane <tgl@sss.pgh.pa.us>; Fabien COELHO <coelho@cri.ensmp.fr>; Daniel Verite <daniel@manitou-mail.org>; pgsql-hackers; pgsql-hackers-owner@postgresql.org

On Wed, Feb 1, 2017 at 6:31 AM, Erik Rijkers <er@xs4all.nl> wrote:

> On 2017-02-01 09:27, Corey Huinker wrote:
>
>>  0001.if_endif.v4.diff
>>
>
> A few thoughts after a quick try:
>
> I dislike the ease with which one gets stuck inside an \if block, in
> interactive mode.
>
> (for instance, in my very first session, I tried   '\? \if'  to see if
> there is more info in that help-screen, but it only displays the normal
> help screen.  But after that one cannot exit with  \q  anymore, and there
> is no feedback of any kind (prompt?) in which black hole one has ended up.
> Only a \endif  provides rescue.)
>

Good find. I'll have to bulk up the help text.
This raises a question: in interactive mode, should we give some feedback
as to the result of an \if or \elif test? (see below)


>
> Therefore making it possible to break out of \if-mode with Ctrl-C would be
> an improvement, I think.
> I would even prefer it when  \q would exit psql always, even from within
> \if-mode.
>

This whole thing got started with a \quit_if <expr> command, and it was
pointed out that

\if :condition
   \q
\endif

SELECT ... FROM ...


would be preferable. So I don't think we can do that. At least not in
non-interactive mode.

As for CTRL-C, I've never looked into what psql does with CTRL-C, so I
don't know if it's possible, let alone desirable.


>
> Also, shouldn't  the prompt change inside an \if block?
>

That's a good question. I could see us finding ways to print the t/f of
whether a branch is active or not, but I'd like to hear from more people
before diving into something like that.

^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-02-01 13:18  Corey Huinker <corey.huinker@gmail.com>
  parent: Fabien COELHO <coelho@cri.ensmp.fr>
  0 siblings, 3 replies; 232+ messages in thread

From: Corey Huinker @ 2017-02-01 13:18 UTC (permalink / raw)
  To: Fabien COELHO <coelho@cri.ensmp.fr>; +Cc: Tom Lane <tgl@sss.pgh.pa.us>; Daniel Verite <daniel@manitou-mail.org>; pgsql-hackers

>
> - wrote an intentionally failing TAP test to see if "make check" executes
>> it. it does not. need help.
>>
>
> A failing test expects code 3, not 0 as written in "t/001_if.pl". With
>
>   is($retcode,'3','Invalid \if respects ON_ERROR_STOP');
>
> instead, the tests succeeds because psql returned 3.
>

Right. What I meant was, no matter how I changed that test, I could not get
it to fail, which made me think it was not executing at all. What do I need
to do to get TAP tests running? I must be missing something.


> More check should be done about stdout to check that it failed for the
> expected reasons though. And maybe more tests could be added to trigger all
> possible state transition errors (eg else after else, elif after else,
> endif without if, if without endif, whatever...).


Agreed. But I couldn't build further on the test without being sure it was
being run.


>
> Other comments and suggestions:
>
> Variable "slashCmdStatus" is set twice in 3 lines in "mainloop.c"?
>

I think that's a merge error from rebasing. Will fix.


>
> There is a spurious empty line added at the very end of "mainloop.h":
>
>   +
>    #endif   /* MAINLOOP_H */
>

Not in my diff, but that's been coming and going in your diff reviews.


>
>
> I would suggest to add a short one line comment before each test to
> explain what is being tested, like "-- test \elif execution", "-- test
> \else execution"...
>

Where are you suggesting this?


>
> Debatable suggestion about "psql_branch_empty": the function name somehow
> suggests an "empty branch", where it is really testing that the stack is
> empty. Maybe the function could be removed and "psql_branch_get_state(...)
> == IF_STATE_NONE" used instead. Not sure.
>

The name isn't great. Maybe psql_branch_stack_empty()?

"psql_branch_end_state": it is a pop, it could be named "psql_branch_pop"
> which would be symmetrical to "psql_branch_push"? Or maybe push should be
> named "begin_state" or "new_state"...
>

Yeah, we either need to go fully with telling the programmer that it's a
stack (push/pop/empty) or (begin_branch/end_branch/not_branching). I'm
inclined to go full-stack, as it were.



>
> C style details: I would avoid non mandatory parentheses, eg:
>
>   +       return ((strcmp(cmd, "if") == 0 || \
>   +                       strcmp(cmd, "elif") == 0 || \
>   +                       strcmp(cmd, "else") == 0 || \
>   +                       strcmp(cmd, "endif") == 0));
>
> I would remove the external double parentheses (( ... )). Also I'm not
> sure why there are end-of-line backslashes on the first instance, maybe a
> macro turned into a function?
>

I copied that from somewhere, and I don't remember where. I think the test
was originally nested much further before being moved to its own function.
Can fix.


>
>   +       return ((s == IFSTATE_NONE) ||
>   +                       (s == IFSTATE_TRUE) ||
>   +                       (s == IFSTATE_ELSE_TRUE));
>
> I would remove all parenthenses.
>

+1


>
>  +       return (state->branch_stack == NULL);
>
> Idem.


+1

^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-02-01 13:25  Fabien COELHO <coelho@cri.ensmp.fr>
  parent: Corey Huinker <corey.huinker@gmail.com>
  0 siblings, 1 reply; 232+ messages in thread

From: Fabien COELHO @ 2017-02-01 13:25 UTC (permalink / raw)
  To: Corey Huinker <corey.huinker@gmail.com>; +Cc: Erik Rijkers <er@xs4all.nl>; Tom Lane <tgl@sss.pgh.pa.us>; Daniel Verite <daniel@manitou-mail.org>; pgsql-hackers; pgsql-hackers-owner@postgresql.org


> Good find. I'll have to bulk up the help text.

Yes.

> This raises a question: in interactive mode, should we give some feedback
> as to the result of an \if or \elif test? (see below)

Obviously \if makes more sense for scripting.

However I would say yes, it should provide some feedback... This means 
probably adding a new prompt substitution "%<something>". In the worst 
case, the prompt should reflect the current stack, or at least the top of 
the task...

Maybe use "%?" which could be substituted by:

     empty stack   -> ""
     ignore state  -> "." or "(i)"
     *_true state  -> "t" or "(t)"
     *_false state -> "f" or "(f)"

     calvin=>   \if true
     calvin=(t)>  \echo "running..."
       running...
     calvin=(t)>  \else
     calvin=(f)>   whatever
     calvin=(f)>  \endif
     calvin=>


>> Therefore making it possible to break out of \if-mode with Ctrl-C would be
>> an improvement, I think.
>> I would even prefer it when  \q would exit psql always, even from within
>> \if-mode.
> So I don't think we can do that. At least not in non-interactive mode.

Yep.

> As for CTRL-C, I've never looked into what psql does with CTRL-C, so I
> don't know if it's possible, let alone desirable.

I think that ctrl-c should abandon current command, which is what the user 
expect when things go wrong. I would suggest to pop the stack on ctrl-C on 
an empty input, eg:

   calvin=> \if true
   calvin=(t)> SELECT
   calvin-(t)>   <ctrl-C>
   calvin=(t)> <ctrl-C>
   calvin=>

>> Also, shouldn't  the prompt change inside an \if block?
>
> That's a good question. I could see us finding ways to print the t/f of
> whether a branch is active or not, but I'd like to hear from more people
> before diving into something like that.

See above.

Adding a state indicator is probably ok, the key question is whether the 
default prompt is changed.

-- 
Fabien.


-- 
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers



^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-02-01 13:33  Fabien COELHO <fabien.coelho@mines-paristech.fr>
  parent: Corey Huinker <corey.huinker@gmail.com>
  2 siblings, 1 reply; 232+ messages in thread

From: Fabien COELHO @ 2017-02-01 13:33 UTC (permalink / raw)
  To: Corey Huinker <corey.huinker@gmail.com>; +Cc: Tom Lane <tgl@sss.pgh.pa.us>; Daniel Verite <daniel@manitou-mail.org>; pgsql-hackers


Hello,

> What do I need to do to get TAP tests running?

I misunderstood. You need to configure with "--enable-tap-tests".

>> There is a spurious empty line added at the very end of "mainloop.h":
>>
>>   +
>>    #endif   /* MAINLOOP_H */
>
> Not in my diff, but that's been coming and going in your diff reviews.

Strange. Maybe this is linked to the warning displayed with "git apply" 
when I apply the diff.

>> I would suggest to add a short one line comment before each test to
>> explain what is being tested, like "-- test \elif execution", "-- test
>> \else execution"...
>
> Where are you suggesting this?

In "regress/sql/psql.sql", in front of each group which starts a test.

>> Debatable suggestion about "psql_branch_empty":
>
> The name isn't great. Maybe psql_branch_stack_empty()?

Yep, maybe, or "empty_stack" or "stack_is_empty" or IDK...

> "psql_branch_end_state": it is a pop, it could be named "psql_branch_pop"
>
> Yeah, we either need to go fully with telling the programmer that it's a
> stack (push/pop/empty) or (begin_branch/end_branch/not_branching). I'm
> inclined to go full-stack, as it were.

Anything consistent is ok. I'm fine with calling a stack a stack:-)

-- 
Fabien.


-- 
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers



^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-02-01 13:48  Erik Rijkers <er@xs4all.nl>
  parent: Corey Huinker <corey.huinker@gmail.com>
  2 siblings, 1 reply; 232+ messages in thread

From: Erik Rijkers @ 2017-02-01 13:48 UTC (permalink / raw)
  To: Corey Huinker <corey.huinker@gmail.com>; +Cc: Fabien COELHO <coelho@cri.ensmp.fr>; Tom Lane <tgl@sss.pgh.pa.us>; Daniel Verite <daniel@manitou-mail.org>; pgsql-hackers; pgsql-hackers-owner@postgresql.org

On 2017-02-01 14:18, Corey Huinker wrote:
> to do to get TAP tests running? I must be missing something.

Guesswork on my part:

Add  --enable-tap-tests option  on ./configure

Run   make check-world   (as opposed to  just  make check )


Erik Rijkers


-- 
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers



^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-02-01 13:53  Corey Huinker <corey.huinker@gmail.com>
  parent: Erik Rijkers <er@xs4all.nl>
  0 siblings, 1 reply; 232+ messages in thread

From: Corey Huinker @ 2017-02-01 13:53 UTC (permalink / raw)
  To: Erik Rijkers <er@xs4all.nl>; +Cc: Fabien COELHO <coelho@cri.ensmp.fr>; Tom Lane <tgl@sss.pgh.pa.us>; Daniel Verite <daniel@manitou-mail.org>; pgsql-hackers; pgsql-hackers-owner@postgresql.org

>
>
> Add  --enable-tap-tests option  on ./configure
>

This much I had already done.


>
> Run   make check-world   (as opposed to  just  make check )


I'll give that a shot.

^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-02-01 14:00  Fabien COELHO <coelho@cri.ensmp.fr>
  0 siblings, 1 reply; 232+ messages in thread

From: Fabien COELHO @ 2017-02-01 14:00 UTC (permalink / raw)
  To: Corey Huinker <corey.huinker@gmail.com>; +Cc: Erik Rijkers <er@xs4all.nl>; Tom Lane <tgl@sss.pgh.pa.us>; Daniel Verite <daniel@manitou-mail.org>; pgsql-hackers; pgsql-hackers-owner@postgresql.org


>> Run   make check-world   (as opposed to  just  make check )
>
> I'll give that a shot.

You can also run "make check" directly in the "src/bin/psql" directory.

-- 
Fabien.


-- 
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers



^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-02-01 14:28  Tom Lane <tgl@sss.pgh.pa.us>
  parent: Corey Huinker <corey.huinker@gmail.com>
  2 siblings, 0 replies; 232+ messages in thread

From: Tom Lane @ 2017-02-01 14:28 UTC (permalink / raw)
  To: Corey Huinker <corey.huinker@gmail.com>; +Cc: Fabien COELHO <coelho@cri.ensmp.fr>; Daniel Verite <daniel@manitou-mail.org>; pgsql-hackers

Corey Huinker <corey.huinker@gmail.com> writes:
> Right. What I meant was, no matter how I changed that test, I could not get
> it to fail, which made me think it was not executing at all. What do I need
> to do to get TAP tests running? I must be missing something.

configure --enable-tap-tests, perhaps?

			regards, tom lane


-- 
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers



^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-02-01 15:33  Fabien COELHO <coelho@cri.ensmp.fr>
  parent: Fabien COELHO <fabien.coelho@mines-paristech.fr>
  0 siblings, 0 replies; 232+ messages in thread

From: Fabien COELHO @ 2017-02-01 15:33 UTC (permalink / raw)
  To: Corey Huinker <corey.huinker@gmail.com>; +Cc: pgsql-hackers


<sorry, resent, wrong from again *$%@#&!?>

Hello Corey,

>> There is a spurious empty line added at the very end of "mainloop.h":
>>
>>   +
>>    #endif   /* MAINLOOP_H */
> 
> Not in my diff, but that's been coming and going in your diff reviews.

Strange. Maybe this is linked to the warning displayed with "git apply" when 
I apply the diff.

>> I would suggest to add a short one line comment before each test to
>> explain what is being tested, like "-- test \elif execution", "-- test
>> \else execution"...
> 
> Where are you suggesting this?

In "regress/sql/psql.sql", in front of each group which starts a test.

>> Debatable suggestion about "psql_branch_empty":
> 
> The name isn't great. Maybe psql_branch_stack_empty()?

  Yep, maybe, or "empty_stack" or "stack_is_empty" or IDK...

> "psql_branch_end_state": it is a pop, it could be named "psql_branch_pop"
> 
> Yeah, we either need to go fully with telling the programmer that it's a
> stack (push/pop/empty) or (begin_branch/end_branch/not_branching). I'm
> inclined to go full-stack, as it were.

Anything consistent is ok. I'm fine with calling a stack a stack:-)

-- 
Fabien.


-- 
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers



^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-02-01 17:58  Corey Huinker <corey.huinker@gmail.com>
  parent: Fabien COELHO <coelho@cri.ensmp.fr>
  0 siblings, 1 reply; 232+ messages in thread

From: Corey Huinker @ 2017-02-01 17:58 UTC (permalink / raw)
  To: Fabien COELHO <coelho@cri.ensmp.fr>; +Cc: Erik Rijkers <er@xs4all.nl>; Tom Lane <tgl@sss.pgh.pa.us>; Daniel Verite <daniel@manitou-mail.org>; pgsql-hackers; pgsql-hackers-owner@postgresql.org

>
> However I would say yes, it should provide some feedback... This means
> probably adding a new prompt substitution "%<something>". In the worst
> case, the prompt should reflect the current stack, or at least the top of
> the task...
>

We could just issue interactive-only warnings when:
- A user types a branching condition command which sets the branch inactive
- A user types a command or query when the current branch is inactive.

The warnings could be specific about state, something like:

psql session is now in an inactive \if branch. No queries will be executed
and only branching commands (\if, \elif, \else, \endif) will be evaluated.

psql session is now in an inactive \elif branch. No queries will be
executed and only branching commands (\if, \elif, \else, \endif) will be
evaluated.

psql session is now in an inactive \else branch. No queries will be
executed and only branching commands (\if, \endif) will be evaluated.



This could of course be done in addition to prompt changes, and is
orthogonal to the CTRL-c  option. I'd like more input before moving forward
on either of those, as they have a good chance to clobber other expected
behaviors.

^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-02-01 18:09  Corey Huinker <corey.huinker@gmail.com>
  parent: Corey Huinker <corey.huinker@gmail.com>
  0 siblings, 0 replies; 232+ messages in thread

From: Corey Huinker @ 2017-02-01 18:09 UTC (permalink / raw)
  To: Erik Rijkers <er@xs4all.nl>; +Cc: Fabien COELHO <coelho@cri.ensmp.fr>; Tom Lane <tgl@sss.pgh.pa.us>; Daniel Verite <daniel@manitou-mail.org>; pgsql-hackers; pgsql-hackers-owner@postgresql.org

On Wed, Feb 1, 2017 at 8:53 AM, Corey Huinker <corey.huinker@gmail.com>
wrote:

>
>> Run   make check-world   (as opposed to  just  make check )
>
>
> I'll give that a shot.
>

That was it. Tests don't run if you don't invoke them. Thanks.

^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-02-01 18:12  Corey Huinker <corey.huinker@gmail.com>
  parent: Fabien COELHO <coelho@cri.ensmp.fr>
  0 siblings, 0 replies; 232+ messages in thread

From: Corey Huinker @ 2017-02-01 18:12 UTC (permalink / raw)
  To: Fabien COELHO <coelho@cri.ensmp.fr>; +Cc: Erik Rijkers <er@xs4all.nl>; Tom Lane <tgl@sss.pgh.pa.us>; Daniel Verite <daniel@manitou-mail.org>; pgsql-hackers; pgsql-hackers-owner@postgresql.org

>
>
> You can also run "make check" directly in the "src/bin/psql" directory.


Previously, that didn't do anything, but now that I've created a TAP test
it does. It doesn't, however, run the psql regress tests. But at least I
can use the two commands in combination and not have to run *all* TAP tests
outside of psql.

^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-02-01 20:03  Fabien COELHO <coelho@cri.ensmp.fr>
  parent: Corey Huinker <corey.huinker@gmail.com>
  0 siblings, 1 reply; 232+ messages in thread

From: Fabien COELHO @ 2017-02-01 20:03 UTC (permalink / raw)
  To: Corey Huinker <corey.huinker@gmail.com>; +Cc: Erik Rijkers <er@xs4all.nl>; Tom Lane <tgl@sss.pgh.pa.us>; Daniel Verite <daniel@manitou-mail.org>; pgsql-hackers; pgsql-hackers-owner@postgresql.org


Hello,

> We could just issue interactive-only warnings when:
> - A user types a branching condition command which sets the branch inactive
> - A user types a command or query when the current branch is inactive.
>
> The warnings could be specific about state, something like:
>
> psql session is now in an inactive \if branch. No queries will be executed
> and only branching commands (\if, \elif, \else, \endif) will be evaluated.
> [...]

My 0.02€: it looks too verbose, should stay on one short line. Maybe:

   (in|)active (\if|\elif|\else), (execut|ignor)ing commands

Although there is some redundancy...

    calvin=>    \if true
      active \if: executing commands
    calvin=(t)> \echo ok
      ok
    calvin=(t)> \else
      inactive \else: skipping commands
    calvin=(f)> ...

Maybe it could be controlled, say based on VERBOSITY setting (which really 
controls verbosity of error reports) or some other.

I'm unsure whether it is a good idea, I like terse interfaces, but this is 
just an opinion.

-- 
Fabien.
-- 
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers



^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-02-01 21:58  Jim Nasby <Jim.Nasby@BlueTreble.com>
  parent: Fabien COELHO <coelho@cri.ensmp.fr>
  0 siblings, 1 reply; 232+ messages in thread

From: Jim Nasby @ 2017-02-01 21:58 UTC (permalink / raw)
  To: Fabien COELHO <coelho@cri.ensmp.fr>; Corey Huinker <corey.huinker@gmail.com>; +Cc: Erik Rijkers <er@xs4all.nl>; Tom Lane <tgl@sss.pgh.pa.us>; Daniel Verite <daniel@manitou-mail.org>; pgsql-hackers; pgsql-hackers-owner@postgresql.org

On 2/1/17 12:03 PM, Fabien COELHO wrote:
> I'm unsure whether it is a good idea, I like terse interfaces, but this
> is just an opinion.

I think the issue here is that the original case for this is a user 
accidentally getting into an \if and then having no clue what's going 
on. That's similar to what happens when you miss a quote or a semicolon. 
We handle those cases with %R, and I think %R needs to support if as well.

Perhaps there's value to providing more info (active branch, etc), but 
ISTM trying to do that will just confuse the original (%R) case.
-- 
Jim Nasby, Data Architect, Blue Treble Consulting, Austin TX
Experts in Analytics, Data Architecture and PostgreSQL
Data in Trouble? Get it in Treble! http://BlueTreble.com
855-TREBLE2 (855-873-2532)


-- 
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers



^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-02-02 22:39  Corey Huinker <corey.huinker@gmail.com>
  parent: Jim Nasby <Jim.Nasby@BlueTreble.com>
  0 siblings, 2 replies; 232+ messages in thread

From: Corey Huinker @ 2017-02-02 22:39 UTC (permalink / raw)
  To: Jim Nasby <Jim.Nasby@bluetreble.com>; +Cc: Fabien COELHO <coelho@cri.ensmp.fr>; Erik Rijkers <er@xs4all.nl>; Tom Lane <tgl@sss.pgh.pa.us>; Daniel Verite <daniel@manitou-mail.org>; pgsql-hackers; pgsql-hackers-owner@postgresql.org

On Wed, Feb 1, 2017 at 4:58 PM, Jim Nasby <Jim.Nasby@bluetreble.com> wrote:

> I think the issue here is that the original case for this is a user
> accidentally getting into an \if and then having no clue what's going on.
> That's similar to what happens when you miss a quote or a semicolon. We
> handle those cases with %R, and I think %R needs to support if as well.
>
> Perhaps there's value to providing more info (active branch, etc), but
> ISTM trying to do that will just confuse the original (%R) case.
>

Jim,

After spending a few minutes to familiarize myself with %R, I'm in
agreement with your second statement (adding if-else to %R will just
confuse %R). However, your first statement seems to indicate the opposite.
Can you elaborate?

All,
As it is, I've added interactive mode psql_error notifications about the
resulting branching state of any branching commands, and any attempt to
send non-branching commands or queries while in an inactive branch will
generate a psql_error saying that the command was ignored. Waiting til I
get what should or shouldn't be done about prompts before issuing the next
patch revision.

^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-02-02 23:29  Corey Huinker <corey.huinker@gmail.com>
  parent: Corey Huinker <corey.huinker@gmail.com>
  1 sibling, 1 reply; 232+ messages in thread

From: Corey Huinker @ 2017-02-02 23:29 UTC (permalink / raw)
  To: Jim Nasby <Jim.Nasby@bluetreble.com>; +Cc: Fabien COELHO <coelho@cri.ensmp.fr>; Erik Rijkers <er@xs4all.nl>; Tom Lane <tgl@sss.pgh.pa.us>; Daniel Verite <daniel@manitou-mail.org>; pgsql-hackers; pgsql-hackers-owner@postgresql.org

>
>
> All,
> As it is, I've added interactive mode psql_error notifications about the
> resulting branching state of any branching commands, and any attempt to
> send non-branching commands or queries while in an inactive branch will
> generate a psql_error saying that the command was ignored. Waiting til I
> get what should or shouldn't be done about prompts before issuing the next
> patch revision.
>

So far, interactive branching information will look like this (it prints on
every branching command and on every ignored command):

# \if true
active \if, executing commands
# select 1;
 ?column?
----------
        1
(1 row)

Time: 0.282 ms
# \else
inactive \else, ignoring commands
# select 1;
inside inactive branch, query ignored.
# select
... # 1;
inside inactive branch, query ignored.
# \endif
active \endif, executing commands
# \if false
inactive \if, ignoring commands
# \i file_name
inside inactive branch, command ignored.
# \elif false
inactive \elif, ignoring commands
# \else
active \else, executing commands
# \endif
active \endif, executing commands


Comments welcome.

^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-02-03 01:32  Tom Lane <tgl@sss.pgh.pa.us>
  parent: Corey Huinker <corey.huinker@gmail.com>
  0 siblings, 1 reply; 232+ messages in thread

From: Tom Lane @ 2017-02-03 01:32 UTC (permalink / raw)
  To: Corey Huinker <corey.huinker@gmail.com>; +Cc: Jim Nasby <Jim.Nasby@bluetreble.com>; Fabien COELHO <coelho@cri.ensmp.fr>; Erik Rijkers <er@xs4all.nl>; Daniel Verite <daniel@manitou-mail.org>; pgsql-hackers; pgsql-hackers-owner@postgresql.org

Corey Huinker <corey.huinker@gmail.com> writes:
>> As it is, I've added interactive mode psql_error notifications about the
>> resulting branching state of any branching commands, and any attempt to
>> send non-branching commands or queries while in an inactive branch will
>> generate a psql_error saying that the command was ignored. Waiting til I
>> get what should or shouldn't be done about prompts before issuing the next
>> patch revision.

On reflection, it seems fairly improbable to me that people would use
\if and friends interactively.  They're certainly useful for scripting,
but would you really type commands that you know are going to be ignored?

Therefore, I don't think we should stress out about fitting branching
activity into the prompts.  That's just not the use-case.  (Note: we
might well have to reconsider that if we get looping, but for now it's
not a problem.)  Moreover, if someone is confused because they don't
realize they're inside a failed \if, it's unlikely that a subtle change in
the prompt would help them.  So your more in-the-face approach of printing
messages seems good to me.

> So far, interactive branching information will look like this (it prints on
> every branching command and on every ignored command):

This seems more or less reasonable, although:

> # \endif
> active \endif, executing commands

looks a bit weird.  Maybe instead say "exited \if, executing commands"?

BTW, what is your policy about nesting these things in include files?
My immediate inclination is that if we hit EOF with open \if state,
we should drop it and revert to the state in the surrounding file.
Otherwise things will be way too confusing.

			regards, tom lane


-- 
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers



^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-02-03 02:06  Corey Huinker <corey.huinker@gmail.com>
  parent: Tom Lane <tgl@sss.pgh.pa.us>
  0 siblings, 1 reply; 232+ messages in thread

From: Corey Huinker @ 2017-02-03 02:06 UTC (permalink / raw)
  To: Tom Lane <tgl@sss.pgh.pa.us>; +Cc: Jim Nasby <Jim.Nasby@bluetreble.com>; Fabien COELHO <coelho@cri.ensmp.fr>; Erik Rijkers <er@xs4all.nl>; Daniel Verite <daniel@manitou-mail.org>; pgsql-hackers; pgsql-hackers-owner@postgresql.org

>
>
> On reflection, it seems fairly improbable to me that people would use
> \if and friends interactively.  They're certainly useful for scripting,
> but would you really type commands that you know are going to be ignored?
>

I'm thinking the one use-case is where a person is debugging a
non-interactive script, cuts and pastes it into an interactive script, and
then scrolls through command history to fix the bits that didn't work. So,
no, you wouldn't *type* them per se, but you'd want the session as if you
had. The if-then barking might really be useful in that context.


>
> Therefore, I don't think we should stress out about fitting branching
> activity into the prompts.  That's just not the use-case.  (Note: we
> might well have to reconsider that if we get looping, but for now it's
> not a problem.)  Moreover, if someone is confused because they don't
> realize they're inside a failed \if, it's unlikely that a subtle change in
> the prompt would help them.  So your more in-the-face approach of printing
> messages seems good to me.
>

Glad you like the barking. I'm happy to let the prompt issue rest for now,
we can always add it later.

If we DID want it, however, I don't think it'll be hard to add a special
prompt (Thinking %T or %Y because they both look like branches, heh), and
it could print the if-state stack, maybe something like:

\if true
  \if true
     \if false
        \if true

With a prompt1 of '%T> ' Would then resolve to

ttfi>

for true, true, false, ignored.

This is just idle musing, I'm perfectly happy to leave it out entirely.


> This seems more or less reasonable, although:
>
> > # \endif
> > active \endif, executing commands
>
> looks a bit weird.  Maybe instead say "exited \if, executing commands"?
>

+1


>
> BTW, what is your policy about nesting these things in include files?
> My immediate inclination is that if we hit EOF with open \if state,
> we should drop it and revert to the state in the surrounding file.
> Otherwise things will be way too confusing.
>

That's how it works now if you have ON_ERROR_STOP off, plus an error
message telling you about the imbalance. If you have ON_ERROR_STOP on, it's
fatal.

All \if-\endif pairs must be balanced within a file (well, within a
MainLoop, but to the user it looks like a file). Every new file opened via
\i or \ir starts a new if-stack. Because commands in an inactive branch are
never executed, we don't have to worry about the state of the parent stack
when we do a \i, because we know it's trues all the way down.

We chose this not so much because if-endif needed it (we could have thrown
it into the pset struct just as easily), but because of the issues that
might come up with a \while loop: needing to remember previous GOTO points
in a file (if the input even *is* a file...) is going to be hard enough,
remembering them across files would be harder, and further complicated by
the possibility that a file \included on one iteration might not be
included on the next (or vice versa)...and like you said, way too confusing.

^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-02-03 05:57  Fabien COELHO <coelho@cri.ensmp.fr>
  parent: Corey Huinker <corey.huinker@gmail.com>
  0 siblings, 1 reply; 232+ messages in thread

From: Fabien COELHO @ 2017-02-03 05:57 UTC (permalink / raw)
  To: Corey Huinker <corey.huinker@gmail.com>; +Cc: Tom Lane <tgl@sss.pgh.pa.us>; Jim Nasby <Jim.Nasby@bluetreble.com>; Erik Rijkers <er@xs4all.nl>; Daniel Verite <daniel@manitou-mail.org>; pgsql-hackers; pgsql-hackers-owner@postgresql.org


Hello Corey,

> Glad you like the barking. I'm happy to let the prompt issue rest for now,
> we can always add it later.
>
> If we DID want it, however, I don't think it'll be hard to add a special
> prompt (Thinking %T or %Y because they both look like branches, heh),

Ah!:-) T may stand for Tree, but Y looks a little bit more like branches. 
Maybe Y for Yew.

> With a prompt1 of '%T> ' Would then resolve to "ttfi" [...]
> This is just idle musing, I'm perfectly happy to leave it out entirely.

I like it. I would prefer to have it available, but my advice is to follow 
committer' opinions. At the minimum, there must be some trace, either 
"barking" or "prompting".

-- 
Fabien.


-- 
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers



^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-02-03 07:16  Corey Huinker <corey.huinker@gmail.com>
  parent: Fabien COELHO <coelho@cri.ensmp.fr>
  0 siblings, 2 replies; 232+ messages in thread

From: Corey Huinker @ 2017-02-03 07:16 UTC (permalink / raw)
  To: Fabien COELHO <coelho@cri.ensmp.fr>; +Cc: Tom Lane <tgl@sss.pgh.pa.us>; Jim Nasby <Jim.Nasby@bluetreble.com>; Erik Rijkers <er@xs4all.nl>; Daniel Verite <daniel@manitou-mail.org>; pgsql-hackers; pgsql-hackers-owner@postgresql.org

On Fri, Feb 3, 2017 at 12:57 AM, Fabien COELHO <coelho@cri.ensmp.fr> wrote:

>
> Hello Corey,
>
> Glad you like the barking. I'm happy to let the prompt issue rest for now,
>> we can always add it later.
>>
>> If we DID want it, however, I don't think it'll be hard to add a special
>> prompt (Thinking %T or %Y because they both look like branches, heh),
>>
>
> Ah!:-) T may stand for Tree, but Y looks a little bit more like branches.
> Maybe Y for Yew.
>

Well played. The %Y prompt can be a separate patch.

New patch. Highlights:
- rebased to master as of ten minutes ago
- Interactive barking on branching state changes, commands typed while in
inactive state
- Help text. New block in help text called "Conditionals"
- SendQuery calls in mainloop.c are all encapsulated in send_query() to
ensure the same if-active and if-interactive logic is used
- Exactly one perl TAP test, testing ON_ERROR_STOP. I predict more will be
needed, but I'm not sure what coverage is desired
- I also predict that my TAP test style is pathetic
- regression tests now have comments to explain purpose
diff --git a/doc/src/sgml/ref/psql-ref.sgml b/doc/src/sgml/ref/psql-ref.sgml
index ae58708..c0ba4c4 100644
--- a/doc/src/sgml/ref/psql-ref.sgml
+++ b/doc/src/sgml/ref/psql-ref.sgml
@@ -2035,6 +2035,67 @@ hello 10
         </listitem>
       </varlistentry>
 
+      <varlistentry>
+        <term><literal>\if</literal> <replaceable class="parameter">expr</replaceable></term>
+        <term><literal>\elif</literal> <replaceable class="parameter">expr</replaceable></term>
+        <term><literal>\else</literal></term>
+        <term><literal>\endif</literal></term>
+        <listitem>
+        <para>
+        This group of commands implements nestable conditional blocks, like
+        this:
+        </para>
+<programlisting>
+SELECT
+    EXISTS(SELECT 1 FROM customer WHERE customer_id = 123) as is_customer,
+    EXISTS(SELECT 1 FROM employee WHERE employee_id = 456) as is_employee
+\gset
+\if :is_customer
+    SELECT * FROM customer WHERE customer_id = 123;
+\elif :is_employee
+    \echo 'is not a customer but is an employee'
+    SELECT * FROM employee WHERE employee_id = 456;
+\else
+    \if yes
+        \echo 'not a customer or employee'
+    \else
+        \echo 'this should never print'
+    \endif
+\endif
+</programlisting>
+        <para>
+        Conditional blocks must begin with a <command>\if</command> and end
+        with an <command>\endif</command>, and the pairs must be found in
+        the same source file. If an EOF is reached on the main file or an
+        <command>\include</command>-ed file before all local
+        <command>\if</command>-<command>\endif</command> are matched, then
+        psql will raise an error.
+        </para>
+        <para>
+        A conditional block can have any number of 
+        <command>\elif</command> clauses, which may optionally be followed by a
+        single <command>\else</command> clause.
+        </para>
+        <para>
+        The <command>\if</command> and <command>\elif</command> commands
+        read the rest of the line and evaluate it as a boolean expression.
+        Currently, expressions are limited to a single unquoted string
+        which are evaluated like other on/off options, so the valid values
+        are any unambiguous case insensitive matches for one of:
+        <literal>true</literal>, <literal>false</literal>, <literal>1</literal>,
+        <literal>0</literal>, <literal>on</literal>, <literal>off</literal>,
+        <literal>yes</literal>, <literal>no</literal>.  So 
+        <literal>t</literal>, <literal>T</literal>, and <literal>tR</literal>
+        will all match <literal>true</literal>.
+        </para>
+        <para>
+        Lines within false branches are not evaluated in any way: queries are
+        not sent to the server, non-conditional commands are not evaluated but
+        bluntly ignored, nested if-expressions in such branches are also not
+        evaluated but are tallied to check for proper nesting.
+        </para>
+        </listitem>
+      </varlistentry>
 
       <varlistentry>
         <term><literal>\ir</literal> or <literal>\include_relative</literal> <replaceable class="parameter">filename</replaceable></term>
diff --git a/src/bin/psql/Makefile b/src/bin/psql/Makefile
index c53733f..7a418c6 100644
--- a/src/bin/psql/Makefile
+++ b/src/bin/psql/Makefile
@@ -61,8 +61,16 @@ uninstall:
 
 clean distclean:
 	rm -f psql$(X) $(OBJS) lex.backup
+	rm -rf tmp_check
 
 # files removed here are supposed to be in the distribution tarball,
 # so do not clean them in the clean/distclean rules
 maintainer-clean: distclean
 	rm -f sql_help.h sql_help.c psqlscanslash.c
+
+
+check:
+	$(prove_check)
+
+installcheck:
+	$(prove_installcheck)
diff --git a/src/bin/psql/command.c b/src/bin/psql/command.c
index f17f610..dcf567e 100644
--- a/src/bin/psql/command.c
+++ b/src/bin/psql/command.c
@@ -49,6 +49,7 @@
 #include "psqlscanslash.h"
 #include "settings.h"
 #include "variables.h"
+#include "fe_utils/psqlscan_int.h"
 
 /*
  * Editable database object types.
@@ -132,7 +133,7 @@ HandleSlashCmds(PsqlScanState scan_state,
 		status = PSQL_CMD_ERROR;
 	}
 
-	if (status != PSQL_CMD_ERROR)
+	if (status != PSQL_CMD_ERROR && pset.active_branch)
 	{
 		/* eat any remaining arguments after a valid command */
 		/* note we suppress evaluation of backticks here */
@@ -194,6 +195,30 @@ read_connect_arg(PsqlScanState scan_state)
 	return result;
 }
 
+/*
+ * Read and interpret argument as a boolean expression.
+ * Return true if a boolean value was successfully parsed.
+ */
+static bool
+read_boolean_expression(PsqlScanState scan_state, char *action,
+						bool *result)
+{
+	char	*value = psql_scan_slash_option(scan_state,
+											OT_NORMAL, NULL, false);
+	bool	success = ParseVariableBool(value, action, result);
+	free(value);
+	return success;
+}
+
+/*
+ * Return true if the command given is a branching command.
+ */
+static bool
+is_branching_command(const char *cmd)
+{
+	return (strcmp(cmd, "if") == 0 || strcmp(cmd, "elif") == 0
+			|| strcmp(cmd, "else") == 0 || strcmp(cmd, "endif") == 0);
+}
 
 /*
  * Subroutine to actually try to execute a backslash command.
@@ -207,6 +232,17 @@ exec_command(const char *cmd,
 								 * failed */
 	backslashResult status = PSQL_CMD_SKIP_LINE;
 
+	if (!pset.active_branch && !is_branching_command(cmd) )
+	{
+		if (pset.cur_cmd_interactive)
+			psql_error("inside inactive branch, command ignored.\n");
+
+		/* Continue with an empty buffer as if the command were never read */
+		resetPQExpBuffer(query_buf);
+		psql_scan_reset(scan_state);
+		return status;
+	}
+
 	/*
 	 * \a -- toggle field alignment This makes little sense but we keep it
 	 * around.
@@ -1006,6 +1042,176 @@ exec_command(const char *cmd,
 		}
 	}
 
+	/*
+	 * \if <expr> is the beginning of an \if..\endif block.
+	 * <expr> must be a valid boolean expression, or the whole block will be
+	 * ignored.
+	 * If this \if is itself a part of a branch that is false/ignored, it too
+	 * will automatically be ignored.
+	 */
+	else if (strcmp(cmd, "if") == 0)
+	{
+		ifState new_if_state = IFSTATE_IGNORED;
+		/*
+		 * only evaluate the expression for truth if the underlying
+		 * branch is active
+		 */
+		if (pset.active_branch)
+		{
+			bool if_true = false;
+			success = read_boolean_expression(scan_state, "\\if <expr>", &if_true);
+			if (success)
+				new_if_state = (if_true) ? IFSTATE_TRUE : IFSTATE_FALSE;
+		}
+		psqlscan_branch_push(scan_state,new_if_state);
+		pset.active_branch = psqlscan_branch_active(scan_state);
+		psql_scan_reset(scan_state);
+		if (pset.cur_cmd_interactive && success)
+			psql_error("entered if: %s, %s commands\n",
+						(pset.active_branch) ? "active" : "inactive",
+						(pset.active_branch) ? "executing" : "ignoring");
+	}
+
+	/*
+	 * \elif <expr> is part of an \if..\endif block
+	 * <expr> will only be evalated for boolean truth if no previous
+	 * \if or \endif in the block has evaluated to true and the \if..\endif
+	 * block is not itself being ignored.
+	 * in the event that <expr> does not conform to a proper boolean expression,
+	 * all following statements in the block will be ignored until \endif is
+	 * encountered.
+	 *
+	 */
+	else if (strcmp(cmd, "elif") == 0)
+	{
+		if (psqlscan_branch_stack_empty(scan_state))
+		{
+			psql_error("encountered un-matched \\elif\n");
+			success = false;
+		}
+		else
+		{
+			bool elif_true = false;
+			switch (psqlscan_branch_get_state(scan_state))
+			{
+				case IFSTATE_IGNORED:
+					/*
+					 * inactive branch, do nothing:
+					 * either if-endif already had a true block,
+					 * or whole parent block is false.
+					 */
+					break;
+				case IFSTATE_TRUE:
+					/*
+					 * just finished true section of active branch
+					 * do not evaluate expression, just skip
+					 */
+					psqlscan_branch_set_state(scan_state, IFSTATE_IGNORED);
+					pset.active_branch = false;
+					break;
+				case IFSTATE_FALSE:
+					/*
+					 * have not yet found a true block in this if-endif,
+					 * determine if this section is true or not.
+					 * variable expansion must be temporarily turned back
+					 * on to read the boolean expression.
+					 */
+					pset.active_branch = true;
+					success = read_boolean_expression(scan_state, "\\elif <expr>",
+														&elif_true);
+					pset.active_branch = false;
+					if (!success)
+						psqlscan_branch_set_state(scan_state, IFSTATE_IGNORED);
+					else if (elif_true)
+						psqlscan_branch_set_state(scan_state, IFSTATE_TRUE);
+					pset.active_branch = psqlscan_branch_active(scan_state);
+					break;
+				case IFSTATE_ELSE_TRUE:
+				case IFSTATE_ELSE_FALSE:
+					psql_error("encountered \\elif after \\else\n");
+					success = false;
+					break;
+				default:
+					break;
+			}
+		}
+		psql_scan_reset(scan_state);
+		if (pset.cur_cmd_interactive && success)
+			psql_error("entered elif: %s, %s commands\n",
+						(pset.active_branch) ? "active" : "inactive",
+						(pset.active_branch) ? "executing" : "ignoring");
+	}
+
+	/*
+	 * \else is part of an \if..\endif block
+	 * the statements within an \else branch will only be executed if
+	 * all previous \if and \endif expressions evaluated to false
+	 * and the block was not itself being ignored.
+	 */
+	else if (strcmp(cmd, "else") == 0)
+	{
+		if (psqlscan_branch_stack_empty(scan_state))
+		{
+			psql_error("encountered un-matched \\else\n");
+			success = false;
+		}
+		else
+		{
+			switch (psqlscan_branch_get_state(scan_state))
+			{
+				case IFSTATE_TRUE:
+				case IFSTATE_IGNORED:
+					/*
+					 * either just finished true section of an active branch,
+					 * or whole branch was inactive. either way, be on the
+					 * lookout for any invalid \endif or \else commands
+					 */
+					psqlscan_branch_set_state(scan_state, IFSTATE_ELSE_FALSE);
+					break;
+				case IFSTATE_FALSE:
+					/* just finished false section of an active branch */
+					psqlscan_branch_set_state(scan_state, IFSTATE_ELSE_TRUE);
+					pset.active_branch = true;
+					break;
+				case IFSTATE_ELSE_TRUE:
+				case IFSTATE_ELSE_FALSE:
+					psql_error("encountered \\else after \\else\n");
+					success = false;
+					break;
+				default:
+					break;
+			}
+		}
+		pset.active_branch = psqlscan_branch_active(scan_state);
+		psql_scan_reset(scan_state);
+		if (pset.cur_cmd_interactive && success)
+			psql_error("entered else: %s, %s commands\n",
+						(pset.active_branch) ? "active" : "inactive",
+						(pset.active_branch) ? "executing" : "ignoring");
+	}
+
+	/*
+	 * \endif - closing statment of an \if...\endif block
+	 */
+	else if (strcmp(cmd, "endif") == 0)
+	{
+		if (psqlscan_branch_stack_empty(scan_state))
+		{
+			psql_error("encountered un-matched \\endif\n");
+			success = false;
+		}
+		else
+		{
+			psqlscan_branch_pop(scan_state);
+			pset.active_branch = psqlscan_branch_active(scan_state);
+		}
+		psql_scan_reset(scan_state);
+		if (pset.cur_cmd_interactive && success)
+			psql_error("exited if: %s, %s commands\n",
+						(pset.active_branch) ? "active" : "inactive",
+						(pset.active_branch) ? "executing" : "ignoring");
+	}
+
 	/* \l is list databases */
 	else if (strcmp(cmd, "l") == 0 || strcmp(cmd, "list") == 0 ||
 			 strcmp(cmd, "l+") == 0 || strcmp(cmd, "list+") == 0)
diff --git a/src/bin/psql/common.c b/src/bin/psql/common.c
index 6e3acdc..9f1a072 100644
--- a/src/bin/psql/common.c
+++ b/src/bin/psql/common.c
@@ -119,6 +119,11 @@ setQFout(const char *fname)
  * If "escape" is true, return the value suitably quoted and escaped,
  * as an identifier or string literal depending on "as_ident".
  * (Failure in escaping should lead to returning NULL.)
+ *
+ * Variables are not expanded if the current branch is inactive
+ * (part of an \if..\endif section which is false). \elif branches
+ * will need temporarily mark the branch active in order to
+ * properly evaluate conditionals.
  */
 char *
 psql_get_variable(const char *varname, bool escape, bool as_ident)
@@ -126,6 +131,10 @@ psql_get_variable(const char *varname, bool escape, bool as_ident)
 	char	   *result;
 	const char *value;
 
+	/* do not expand variables if the branch is inactive */
+	if (!pset.active_branch)
+		return NULL;
+
 	value = GetVariable(pset.vars, varname);
 	if (!value)
 		return NULL;
diff --git a/src/bin/psql/help.c b/src/bin/psql/help.c
index 3e3cab4..543b0d5 100644
--- a/src/bin/psql/help.c
+++ b/src/bin/psql/help.c
@@ -307,6 +307,21 @@ slashUsage(unsigned short int pager)
 					  "  \\lo_list\n"
 					  "  \\lo_unlink LOBOID      large object operations\n"));
 
+	fprintf(output, _("Conditionals\n"));
+	fprintf(output, _("  \\if <expr>             begin a conditional block, and execute subsequent\n"
+					  "                          commands/queires if <expr> is true, otherwise\n"
+					  "                          skip them without evaluation\n"));
+	fprintf(output, _("  \\elif <expr>           within a conditional block, exectue subsequennt\n"
+					  "                          commands/queires if <expr> is true and all\n"
+					  "                          previous \\if and \\elif expressions were false\n"));
+	fprintf(output, _("  \\elif <expr>           within a conditional block, exectue subsequennt\n"
+					  "                          commands/queires only if all previous \\if and\n"
+					  "                          \\elif expressions were false\n"));
+	fprintf(output, _("  \\endif                 end a conditional block, restoring\n"
+					  "                          executing/skipping state to what it was before\n"
+					  "                          the matching \\if command.\n"));
+	fprintf(output, "\n");
+
 	ClosePager(output);
 }
 
diff --git a/src/bin/psql/mainloop.c b/src/bin/psql/mainloop.c
index 6e358e2..ed0330d 100644
--- a/src/bin/psql/mainloop.c
+++ b/src/bin/psql/mainloop.c
@@ -15,7 +15,7 @@
 #include "settings.h"
 
 #include "mb/pg_wchar.h"
-
+#include "fe_utils/psqlscan_int.h"
 
 /* callback functions for our flex lexer */
 const PsqlScanCallbacks psqlscan_callbacks = {
@@ -23,6 +23,22 @@ const PsqlScanCallbacks psqlscan_callbacks = {
 	psql_error
 };
 
+/*
+ * execute query if branch is active.
+ * warn interactive users about ignored queries.
+ */
+static
+bool send_query(const char *query)
+{
+	/* execute query if branch is active */
+	if (pset.active_branch)
+		return SendQuery(query);
+
+	if (pset.cur_cmd_interactive)
+		psql_error("inside inactive branch, query ignored.\n");
+
+	return true;
+}
 
 /*
  * Main processing loop for reading lines of input
@@ -296,8 +312,8 @@ MainLoop(FILE *source)
 					line_saved_in_history = true;
 				}
 
-				/* execute query */
-				success = SendQuery(query_buf->data);
+				success = send_query(query_buf->data);
+
 				slashCmdStatus = success ? PSQL_CMD_SEND : PSQL_CMD_ERROR;
 				pset.stmt_lineno = 1;
 
@@ -358,7 +374,7 @@ MainLoop(FILE *source)
 
 				if (slashCmdStatus == PSQL_CMD_SEND)
 				{
-					success = SendQuery(query_buf->data);
+					success = send_query(query_buf->data);
 
 					/* transfer query to previous_buf by pointer-swapping */
 					{
@@ -367,6 +383,7 @@ MainLoop(FILE *source)
 						previous_buf = query_buf;
 						query_buf = swap_buf;
 					}
+
 					resetPQExpBuffer(query_buf);
 
 					/* flush any paren nesting info after forced send */
@@ -429,8 +446,7 @@ MainLoop(FILE *source)
 		if (pset.cur_cmd_interactive)
 			pg_send_history(history_buf);
 
-		/* execute query */
-		success = SendQuery(query_buf->data);
+		success = send_query(query_buf->data);
 
 		if (!success && die_on_error)
 			successResult = EXIT_USER;
@@ -451,6 +467,15 @@ MainLoop(FILE *source)
 	destroyPQExpBuffer(previous_buf);
 	destroyPQExpBuffer(history_buf);
 
+	/* check for unbalanced \if-\endifs unless user explicitly quit */
+	if (slashCmdStatus != PSQL_CMD_TERMINATE
+		&& !psqlscan_branch_stack_empty(scan_state))
+	{
+		psql_error("found EOF before closing \\endif(s)\n");
+		if (die_on_error)
+			successResult = EXIT_USER;
+	}
+
 	psql_scan_destroy(scan_state);
 
 	pset.cur_cmd_source = prev_cmd_source;
diff --git a/src/bin/psql/settings.h b/src/bin/psql/settings.h
index 195f5a1..c8aeab6 100644
--- a/src/bin/psql/settings.h
+++ b/src/bin/psql/settings.h
@@ -114,6 +114,9 @@ typedef struct _psqlSettings
 
 	VariableSpace vars;			/* "shell variable" repository */
 
+	bool		active_branch;	/* true if session is not in an \if branch
+								 * or the current branch is true */
+
 	/*
 	 * The remaining fields are set by assign hooks associated with entries in
 	 * "vars".  They should not be set directly except by those hook
diff --git a/src/bin/psql/startup.c b/src/bin/psql/startup.c
index 88d686a..5c8760a 100644
--- a/src/bin/psql/startup.c
+++ b/src/bin/psql/startup.c
@@ -128,6 +128,8 @@ main(int argc, char *argv[])
 	setvbuf(stderr, NULL, _IONBF, 0);
 #endif
 
+	pset.active_branch = true;
+
 	pset.progname = get_progname(argv[0]);
 
 	pset.db = NULL;
diff --git a/src/bin/psql/t/001_if.pl b/src/bin/psql/t/001_if.pl
new file mode 100644
index 0000000..2ed01c5
--- /dev/null
+++ b/src/bin/psql/t/001_if.pl
@@ -0,0 +1,32 @@
+use strict;
+use warnings;
+
+use Config;
+use PostgresNode;
+use TestLib;
+use Test::More tests => 3;
+
+#
+# test invalid \if respects ON_ERROR_STOP
+#
+my $stdout;
+my $stderr;
+my $node = get_new_node('master');
+$node->init;
+$node->start;
+
+my $script_1 = q(\if invalid_expression
+);
+
+my $stderr_1  = q(psql:<stdin>:1: unrecognized value "invalid_expression" for "\if <expr>": boolean expected
+psql:<stdin>:1: found EOF before closing \endif(s));
+
+my $retcode = $node->psql('postgres', $script_1,
+		stdout => \$stdout, stderr => \$stderr,
+		on_error_stop => 1);
+is($retcode,'3','Invalid \if respects ON_ERROR_STOP');
+is($stdout,'','STDOUT mismatch');
+is($stderr, $stderr_1, 'STDERR mismatch');
+
+
+$node->teardown_node;
diff --git a/src/fe_utils/psqlscan.l b/src/fe_utils/psqlscan.l
index 1b29341..998630a 100644
--- a/src/fe_utils/psqlscan.l
+++ b/src/fe_utils/psqlscan.l
@@ -904,6 +904,8 @@ psql_scan_create(const PsqlScanCallbacks *callbacks)
 
 	psql_scan_reset(state);
 
+	state->branch_stack = NULL;
+
 	return state;
 }
 
@@ -919,6 +921,13 @@ psql_scan_destroy(PsqlScanState state)
 
 	yylex_destroy(state->scanner);
 
+	while (state->branch_stack != NULL)
+	{
+		IfStackElem *p = state->branch_stack;
+		state->branch_stack = state->branch_stack->next;
+		free(p);
+	}
+
 	free(state);
 }
 
@@ -1426,3 +1435,86 @@ psqlscan_escape_variable(PsqlScanState state, const char *txt, int len,
 		psqlscan_emit(state, txt, len);
 	}
 }
+
+/*
+ * psqlscan_branch_stack_empty
+ *
+ * True if there are no active \if-structures
+ */
+bool
+psqlscan_branch_stack_empty(PsqlScanState state)
+{
+	return state->branch_stack == NULL;
+}
+
+/*
+ * Fetch the current state of the top of the stack
+ */
+ifState
+psqlscan_branch_get_state(PsqlScanState state)
+{
+	if (psqlscan_branch_stack_empty(state))
+		return IFSTATE_NONE;
+	return state->branch_stack->if_state;
+}
+
+/*
+ * psqlscan_branch_active
+ *
+ * True if the current \if-block (if any) is true and queries/commands
+ * should be executed.
+ */
+bool
+psqlscan_branch_active(PsqlScanState state)
+{
+	ifState s = psqlscan_branch_get_state(state);
+	return s == IFSTATE_NONE || s == IFSTATE_TRUE || s == IFSTATE_ELSE_TRUE;
+}
+
+
+/*
+ * psqlscan_branch_push
+ *
+ * Create a new \if branch.
+ */
+bool
+psqlscan_branch_push(PsqlScanState state, ifState new_state)
+{
+	IfStackElem *p = pg_malloc0(sizeof(IfStackElem));
+	p->if_state = new_state;
+	p->next = state->branch_stack;
+	state->branch_stack = p;
+	return true;
+}
+
+/*
+ * psqlscan_branch_set_state
+ *
+ * Change the state of the topmost branch.
+ * Returns false if there was branch state to set.
+ */
+bool
+psqlscan_branch_set_state(PsqlScanState state, ifState new_state)
+{
+	if (psqlscan_branch_stack_empty(state))
+		return false;
+	state->branch_stack->if_state = new_state;
+	return true;
+}
+
+/*
+ * psqlscan_branch_pop
+ *
+ * Destroy the topmost branch because and \endif was encountered.
+ * Returns false if there was no branch to end.
+ */
+bool
+psqlscan_branch_pop(PsqlScanState state)
+{
+	IfStackElem *p = state->branch_stack;
+	if (!p)
+		return false;
+	state->branch_stack = state->branch_stack->next;
+	free(p);
+	return true;
+}
diff --git a/src/include/fe_utils/psqlscan_int.h b/src/include/fe_utils/psqlscan_int.h
index 0fddc7a..321d455 100644
--- a/src/include/fe_utils/psqlscan_int.h
+++ b/src/include/fe_utils/psqlscan_int.h
@@ -75,6 +75,30 @@ typedef struct StackElem
 	struct StackElem *next;
 } StackElem;
 
+typedef enum _ifState
+{
+	IFSTATE_NONE = 0,	/* Not currently in an \if block */
+	IFSTATE_TRUE,		/* currently in an \if or \elif which is true
+						 * and all parent branches (if any) are true */
+	IFSTATE_FALSE,		/* currently in an \if or \elif which is false
+						 * but no true branch has yet been seen,
+						 * and all parent branches (if any) are true */
+	IFSTATE_IGNORED,	/* currently in an \elif which follows a true \if
+						 * or the whole \if is a child of a false parent */
+	IFSTATE_ELSE_TRUE,	/* currently in an \else which is true
+						 * and all parent branches (if any) are true */
+	IFSTATE_ELSE_FALSE	/* currently in an \else which is false or ignored */
+} ifState;
+
+/*
+ * The state of nested ifs is stored in a stack.
+ */
+typedef struct IfStackElem
+{
+	ifState		if_state;
+	struct IfStackElem *next;
+} IfStackElem;
+
 /*
  * All working state of the lexer must be stored in PsqlScanStateData
  * between calls.  This allows us to have multiple open lexer operations,
@@ -118,6 +142,11 @@ typedef struct PsqlScanStateData
 	 * Callback functions provided by the program making use of the lexer.
 	 */
 	const PsqlScanCallbacks *callbacks;
+
+	/*
+	 * \if branch state variables
+	 */
+	IfStackElem *branch_stack;
 } PsqlScanStateData;
 
 
@@ -141,4 +170,21 @@ extern void psqlscan_escape_variable(PsqlScanState state,
 						 const char *txt, int len,
 						 bool as_ident);
 
+/*
+ * branching commands
+ */
+extern bool psqlscan_branch_stack_empty(PsqlScanState state);
+
+extern bool psqlscan_branch_active(PsqlScanState state);
+
+extern ifState psqlscan_branch_get_state(PsqlScanState state);
+
+extern bool psqlscan_branch_push(PsqlScanState state,
+									ifState new_state);
+
+extern bool psqlscan_branch_set_state(PsqlScanState state,
+									ifState new_state);
+
+extern bool psqlscan_branch_pop(PsqlScanState state);
+
 #endif   /* PSQLSCAN_INT_H */
diff --git a/src/test/regress/expected/psql.out b/src/test/regress/expected/psql.out
index 026a4f0..d615eb8 100644
--- a/src/test/regress/expected/psql.out
+++ b/src/test/regress/expected/psql.out
@@ -2712,6 +2712,95 @@ deallocate q;
 \pset format aligned
 \pset expanded off
 \pset border 1
+-- test a large nested if using a variety of true-equivalents
+\if true
+	\if 1
+		\if yes
+			\if on
+				\echo 'all true'
+all true
+			\else
+				\echo 'should not print #1-1'
+			\endif
+		\else
+			\echo 'should not print #1-2'
+		\endif
+	\else
+		\echo 'should not print #1-3'
+	\endif
+\else
+	\echo 'should not print #1-4'
+\endif
+-- test a variety of false-equivalents in an if/elif/else structure
+\if false
+	\echo 'should not print #2-1'
+\elif 0
+	\echo 'should not print #2-2'
+\elif no
+	\echo 'should not print #2-3'
+\elif off
+	\echo 'should not print #2-4'
+\else
+	\echo 'all false'
+all false
+\endif
+-- test simple true-then-else
+\if true
+	\echo 'first thing true'
+first thing true
+\else
+	\echo 'should not print #3-1'
+\endif
+-- test simple false-true-else
+\if false
+	\echo 'should not print #4-1'
+\elif true
+	\echo 'second thing true'
+second thing true
+\else
+	\echo 'should not print #5-1'
+\endif
+-- test invalidation of whole if-endif when invalid boolean is given
+\if invalid_boolean_expression
+unrecognized value "invalid_boolean_expression" for "\if <expr>": boolean expected
+	\echo 'should not print #6-1'
+\else
+	\echo 'should not print because whole if-then is wrecked #6-2'
+\endif
+-- test non-evaluation of variables in false blocks
+\set var 'ab''cd'
+-- select :var;
+\if false
+  select :var ;
+\else
+  select 1;
+ ?column? 
+----------
+        1
+(1 row)
+
+\endif
+-- test un-matched endif
+\endif
+encountered un-matched \endif
+-- test un-matched else
+\else
+encountered un-matched \else
+-- test un-matched elif
+\elif
+encountered un-matched \elif
+-- test double-else error
+\if true
+\else
+\else
+encountered \else after \else
+\endif
+-- test elif out-of-order
+\if false
+\else
+\elif
+encountered \elif after \else
+\endif
 -- SHOW_CONTEXT
 \set SHOW_CONTEXT never
 do $$
diff --git a/src/test/regress/sql/psql.sql b/src/test/regress/sql/psql.sql
index d823d11..ba41d9e 100644
--- a/src/test/regress/sql/psql.sql
+++ b/src/test/regress/sql/psql.sql
@@ -375,6 +375,91 @@ deallocate q;
 \pset expanded off
 \pset border 1
 
+-- test a large nested if using a variety of true-equivalents
+\if true
+	\if 1
+		\if yes
+			\if on
+				\echo 'all true'
+			\else
+				\echo 'should not print #1-1'
+			\endif
+		\else
+			\echo 'should not print #1-2'
+		\endif
+	\else
+		\echo 'should not print #1-3'
+	\endif
+\else
+	\echo 'should not print #1-4'
+\endif
+
+-- test a variety of false-equivalents in an if/elif/else structure
+\if false
+	\echo 'should not print #2-1'
+\elif 0
+	\echo 'should not print #2-2'
+\elif no
+	\echo 'should not print #2-3'
+\elif off
+	\echo 'should not print #2-4'
+\else
+	\echo 'all false'
+\endif
+
+-- test simple true-then-else
+\if true
+	\echo 'first thing true'
+\else
+	\echo 'should not print #3-1'
+\endif
+
+-- test simple false-true-else
+\if false
+	\echo 'should not print #4-1'
+\elif true
+	\echo 'second thing true'
+\else
+	\echo 'should not print #5-1'
+\endif
+
+-- test invalidation of whole if-endif when invalid boolean is given
+\if invalid_boolean_expression
+	\echo 'should not print #6-1'
+\else
+	\echo 'should not print because whole if-then is wrecked #6-2'
+\endif
+
+-- test non-evaluation of variables in false blocks
+\set var 'ab''cd'
+-- select :var;
+\if false
+  select :var ;
+\else
+  select 1;
+\endif
+
+-- test un-matched endif
+\endif
+
+-- test un-matched else
+\else
+
+-- test un-matched elif
+\elif
+
+-- test double-else error
+\if true
+\else
+\else
+\endif
+
+-- test elif out-of-order
+\if false
+\else
+\elif
+\endif
+
 -- SHOW_CONTEXT
 
 \set SHOW_CONTEXT never


-- 
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers

Attachments:

  [text/plain] 0001.if_endif.v5.diff (25.7K, ../../CADkLM=e6u013=KqqGwWEaGHWO0hPKnmLd=UYJf5OKP45fDJp=g@mail.gmail.com/3-0001.if_endif.v5.diff)
  download | inline diff:
diff --git a/doc/src/sgml/ref/psql-ref.sgml b/doc/src/sgml/ref/psql-ref.sgml
index ae58708..c0ba4c4 100644
--- a/doc/src/sgml/ref/psql-ref.sgml
+++ b/doc/src/sgml/ref/psql-ref.sgml
@@ -2035,6 +2035,67 @@ hello 10
         </listitem>
       </varlistentry>
 
+      <varlistentry>
+        <term><literal>\if</literal> <replaceable class="parameter">expr</replaceable></term>
+        <term><literal>\elif</literal> <replaceable class="parameter">expr</replaceable></term>
+        <term><literal>\else</literal></term>
+        <term><literal>\endif</literal></term>
+        <listitem>
+        <para>
+        This group of commands implements nestable conditional blocks, like
+        this:
+        </para>
+<programlisting>
+SELECT
+    EXISTS(SELECT 1 FROM customer WHERE customer_id = 123) as is_customer,
+    EXISTS(SELECT 1 FROM employee WHERE employee_id = 456) as is_employee
+\gset
+\if :is_customer
+    SELECT * FROM customer WHERE customer_id = 123;
+\elif :is_employee
+    \echo 'is not a customer but is an employee'
+    SELECT * FROM employee WHERE employee_id = 456;
+\else
+    \if yes
+        \echo 'not a customer or employee'
+    \else
+        \echo 'this should never print'
+    \endif
+\endif
+</programlisting>
+        <para>
+        Conditional blocks must begin with a <command>\if</command> and end
+        with an <command>\endif</command>, and the pairs must be found in
+        the same source file. If an EOF is reached on the main file or an
+        <command>\include</command>-ed file before all local
+        <command>\if</command>-<command>\endif</command> are matched, then
+        psql will raise an error.
+        </para>
+        <para>
+        A conditional block can have any number of 
+        <command>\elif</command> clauses, which may optionally be followed by a
+        single <command>\else</command> clause.
+        </para>
+        <para>
+        The <command>\if</command> and <command>\elif</command> commands
+        read the rest of the line and evaluate it as a boolean expression.
+        Currently, expressions are limited to a single unquoted string
+        which are evaluated like other on/off options, so the valid values
+        are any unambiguous case insensitive matches for one of:
+        <literal>true</literal>, <literal>false</literal>, <literal>1</literal>,
+        <literal>0</literal>, <literal>on</literal>, <literal>off</literal>,
+        <literal>yes</literal>, <literal>no</literal>.  So 
+        <literal>t</literal>, <literal>T</literal>, and <literal>tR</literal>
+        will all match <literal>true</literal>.
+        </para>
+        <para>
+        Lines within false branches are not evaluated in any way: queries are
+        not sent to the server, non-conditional commands are not evaluated but
+        bluntly ignored, nested if-expressions in such branches are also not
+        evaluated but are tallied to check for proper nesting.
+        </para>
+        </listitem>
+      </varlistentry>
 
       <varlistentry>
         <term><literal>\ir</literal> or <literal>\include_relative</literal> <replaceable class="parameter">filename</replaceable></term>
diff --git a/src/bin/psql/Makefile b/src/bin/psql/Makefile
index c53733f..7a418c6 100644
--- a/src/bin/psql/Makefile
+++ b/src/bin/psql/Makefile
@@ -61,8 +61,16 @@ uninstall:
 
 clean distclean:
 	rm -f psql$(X) $(OBJS) lex.backup
+	rm -rf tmp_check
 
 # files removed here are supposed to be in the distribution tarball,
 # so do not clean them in the clean/distclean rules
 maintainer-clean: distclean
 	rm -f sql_help.h sql_help.c psqlscanslash.c
+
+
+check:
+	$(prove_check)
+
+installcheck:
+	$(prove_installcheck)
diff --git a/src/bin/psql/command.c b/src/bin/psql/command.c
index f17f610..dcf567e 100644
--- a/src/bin/psql/command.c
+++ b/src/bin/psql/command.c
@@ -49,6 +49,7 @@
 #include "psqlscanslash.h"
 #include "settings.h"
 #include "variables.h"
+#include "fe_utils/psqlscan_int.h"
 
 /*
  * Editable database object types.
@@ -132,7 +133,7 @@ HandleSlashCmds(PsqlScanState scan_state,
 		status = PSQL_CMD_ERROR;
 	}
 
-	if (status != PSQL_CMD_ERROR)
+	if (status != PSQL_CMD_ERROR && pset.active_branch)
 	{
 		/* eat any remaining arguments after a valid command */
 		/* note we suppress evaluation of backticks here */
@@ -194,6 +195,30 @@ read_connect_arg(PsqlScanState scan_state)
 	return result;
 }
 
+/*
+ * Read and interpret argument as a boolean expression.
+ * Return true if a boolean value was successfully parsed.
+ */
+static bool
+read_boolean_expression(PsqlScanState scan_state, char *action,
+						bool *result)
+{
+	char	*value = psql_scan_slash_option(scan_state,
+											OT_NORMAL, NULL, false);
+	bool	success = ParseVariableBool(value, action, result);
+	free(value);
+	return success;
+}
+
+/*
+ * Return true if the command given is a branching command.
+ */
+static bool
+is_branching_command(const char *cmd)
+{
+	return (strcmp(cmd, "if") == 0 || strcmp(cmd, "elif") == 0
+			|| strcmp(cmd, "else") == 0 || strcmp(cmd, "endif") == 0);
+}
 
 /*
  * Subroutine to actually try to execute a backslash command.
@@ -207,6 +232,17 @@ exec_command(const char *cmd,
 								 * failed */
 	backslashResult status = PSQL_CMD_SKIP_LINE;
 
+	if (!pset.active_branch && !is_branching_command(cmd) )
+	{
+		if (pset.cur_cmd_interactive)
+			psql_error("inside inactive branch, command ignored.\n");
+
+		/* Continue with an empty buffer as if the command were never read */
+		resetPQExpBuffer(query_buf);
+		psql_scan_reset(scan_state);
+		return status;
+	}
+
 	/*
 	 * \a -- toggle field alignment This makes little sense but we keep it
 	 * around.
@@ -1006,6 +1042,176 @@ exec_command(const char *cmd,
 		}
 	}
 
+	/*
+	 * \if <expr> is the beginning of an \if..\endif block.
+	 * <expr> must be a valid boolean expression, or the whole block will be
+	 * ignored.
+	 * If this \if is itself a part of a branch that is false/ignored, it too
+	 * will automatically be ignored.
+	 */
+	else if (strcmp(cmd, "if") == 0)
+	{
+		ifState new_if_state = IFSTATE_IGNORED;
+		/*
+		 * only evaluate the expression for truth if the underlying
+		 * branch is active
+		 */
+		if (pset.active_branch)
+		{
+			bool if_true = false;
+			success = read_boolean_expression(scan_state, "\\if <expr>", &if_true);
+			if (success)
+				new_if_state = (if_true) ? IFSTATE_TRUE : IFSTATE_FALSE;
+		}
+		psqlscan_branch_push(scan_state,new_if_state);
+		pset.active_branch = psqlscan_branch_active(scan_state);
+		psql_scan_reset(scan_state);
+		if (pset.cur_cmd_interactive && success)
+			psql_error("entered if: %s, %s commands\n",
+						(pset.active_branch) ? "active" : "inactive",
+						(pset.active_branch) ? "executing" : "ignoring");
+	}
+
+	/*
+	 * \elif <expr> is part of an \if..\endif block
+	 * <expr> will only be evalated for boolean truth if no previous
+	 * \if or \endif in the block has evaluated to true and the \if..\endif
+	 * block is not itself being ignored.
+	 * in the event that <expr> does not conform to a proper boolean expression,
+	 * all following statements in the block will be ignored until \endif is
+	 * encountered.
+	 *
+	 */
+	else if (strcmp(cmd, "elif") == 0)
+	{
+		if (psqlscan_branch_stack_empty(scan_state))
+		{
+			psql_error("encountered un-matched \\elif\n");
+			success = false;
+		}
+		else
+		{
+			bool elif_true = false;
+			switch (psqlscan_branch_get_state(scan_state))
+			{
+				case IFSTATE_IGNORED:
+					/*
+					 * inactive branch, do nothing:
+					 * either if-endif already had a true block,
+					 * or whole parent block is false.
+					 */
+					break;
+				case IFSTATE_TRUE:
+					/*
+					 * just finished true section of active branch
+					 * do not evaluate expression, just skip
+					 */
+					psqlscan_branch_set_state(scan_state, IFSTATE_IGNORED);
+					pset.active_branch = false;
+					break;
+				case IFSTATE_FALSE:
+					/*
+					 * have not yet found a true block in this if-endif,
+					 * determine if this section is true or not.
+					 * variable expansion must be temporarily turned back
+					 * on to read the boolean expression.
+					 */
+					pset.active_branch = true;
+					success = read_boolean_expression(scan_state, "\\elif <expr>",
+														&elif_true);
+					pset.active_branch = false;
+					if (!success)
+						psqlscan_branch_set_state(scan_state, IFSTATE_IGNORED);
+					else if (elif_true)
+						psqlscan_branch_set_state(scan_state, IFSTATE_TRUE);
+					pset.active_branch = psqlscan_branch_active(scan_state);
+					break;
+				case IFSTATE_ELSE_TRUE:
+				case IFSTATE_ELSE_FALSE:
+					psql_error("encountered \\elif after \\else\n");
+					success = false;
+					break;
+				default:
+					break;
+			}
+		}
+		psql_scan_reset(scan_state);
+		if (pset.cur_cmd_interactive && success)
+			psql_error("entered elif: %s, %s commands\n",
+						(pset.active_branch) ? "active" : "inactive",
+						(pset.active_branch) ? "executing" : "ignoring");
+	}
+
+	/*
+	 * \else is part of an \if..\endif block
+	 * the statements within an \else branch will only be executed if
+	 * all previous \if and \endif expressions evaluated to false
+	 * and the block was not itself being ignored.
+	 */
+	else if (strcmp(cmd, "else") == 0)
+	{
+		if (psqlscan_branch_stack_empty(scan_state))
+		{
+			psql_error("encountered un-matched \\else\n");
+			success = false;
+		}
+		else
+		{
+			switch (psqlscan_branch_get_state(scan_state))
+			{
+				case IFSTATE_TRUE:
+				case IFSTATE_IGNORED:
+					/*
+					 * either just finished true section of an active branch,
+					 * or whole branch was inactive. either way, be on the
+					 * lookout for any invalid \endif or \else commands
+					 */
+					psqlscan_branch_set_state(scan_state, IFSTATE_ELSE_FALSE);
+					break;
+				case IFSTATE_FALSE:
+					/* just finished false section of an active branch */
+					psqlscan_branch_set_state(scan_state, IFSTATE_ELSE_TRUE);
+					pset.active_branch = true;
+					break;
+				case IFSTATE_ELSE_TRUE:
+				case IFSTATE_ELSE_FALSE:
+					psql_error("encountered \\else after \\else\n");
+					success = false;
+					break;
+				default:
+					break;
+			}
+		}
+		pset.active_branch = psqlscan_branch_active(scan_state);
+		psql_scan_reset(scan_state);
+		if (pset.cur_cmd_interactive && success)
+			psql_error("entered else: %s, %s commands\n",
+						(pset.active_branch) ? "active" : "inactive",
+						(pset.active_branch) ? "executing" : "ignoring");
+	}
+
+	/*
+	 * \endif - closing statment of an \if...\endif block
+	 */
+	else if (strcmp(cmd, "endif") == 0)
+	{
+		if (psqlscan_branch_stack_empty(scan_state))
+		{
+			psql_error("encountered un-matched \\endif\n");
+			success = false;
+		}
+		else
+		{
+			psqlscan_branch_pop(scan_state);
+			pset.active_branch = psqlscan_branch_active(scan_state);
+		}
+		psql_scan_reset(scan_state);
+		if (pset.cur_cmd_interactive && success)
+			psql_error("exited if: %s, %s commands\n",
+						(pset.active_branch) ? "active" : "inactive",
+						(pset.active_branch) ? "executing" : "ignoring");
+	}
+
 	/* \l is list databases */
 	else if (strcmp(cmd, "l") == 0 || strcmp(cmd, "list") == 0 ||
 			 strcmp(cmd, "l+") == 0 || strcmp(cmd, "list+") == 0)
diff --git a/src/bin/psql/common.c b/src/bin/psql/common.c
index 6e3acdc..9f1a072 100644
--- a/src/bin/psql/common.c
+++ b/src/bin/psql/common.c
@@ -119,6 +119,11 @@ setQFout(const char *fname)
  * If "escape" is true, return the value suitably quoted and escaped,
  * as an identifier or string literal depending on "as_ident".
  * (Failure in escaping should lead to returning NULL.)
+ *
+ * Variables are not expanded if the current branch is inactive
+ * (part of an \if..\endif section which is false). \elif branches
+ * will need temporarily mark the branch active in order to
+ * properly evaluate conditionals.
  */
 char *
 psql_get_variable(const char *varname, bool escape, bool as_ident)
@@ -126,6 +131,10 @@ psql_get_variable(const char *varname, bool escape, bool as_ident)
 	char	   *result;
 	const char *value;
 
+	/* do not expand variables if the branch is inactive */
+	if (!pset.active_branch)
+		return NULL;
+
 	value = GetVariable(pset.vars, varname);
 	if (!value)
 		return NULL;
diff --git a/src/bin/psql/help.c b/src/bin/psql/help.c
index 3e3cab4..543b0d5 100644
--- a/src/bin/psql/help.c
+++ b/src/bin/psql/help.c
@@ -307,6 +307,21 @@ slashUsage(unsigned short int pager)
 					  "  \\lo_list\n"
 					  "  \\lo_unlink LOBOID      large object operations\n"));
 
+	fprintf(output, _("Conditionals\n"));
+	fprintf(output, _("  \\if <expr>             begin a conditional block, and execute subsequent\n"
+					  "                          commands/queires if <expr> is true, otherwise\n"
+					  "                          skip them without evaluation\n"));
+	fprintf(output, _("  \\elif <expr>           within a conditional block, exectue subsequennt\n"
+					  "                          commands/queires if <expr> is true and all\n"
+					  "                          previous \\if and \\elif expressions were false\n"));
+	fprintf(output, _("  \\elif <expr>           within a conditional block, exectue subsequennt\n"
+					  "                          commands/queires only if all previous \\if and\n"
+					  "                          \\elif expressions were false\n"));
+	fprintf(output, _("  \\endif                 end a conditional block, restoring\n"
+					  "                          executing/skipping state to what it was before\n"
+					  "                          the matching \\if command.\n"));
+	fprintf(output, "\n");
+
 	ClosePager(output);
 }
 
diff --git a/src/bin/psql/mainloop.c b/src/bin/psql/mainloop.c
index 6e358e2..ed0330d 100644
--- a/src/bin/psql/mainloop.c
+++ b/src/bin/psql/mainloop.c
@@ -15,7 +15,7 @@
 #include "settings.h"
 
 #include "mb/pg_wchar.h"
-
+#include "fe_utils/psqlscan_int.h"
 
 /* callback functions for our flex lexer */
 const PsqlScanCallbacks psqlscan_callbacks = {
@@ -23,6 +23,22 @@ const PsqlScanCallbacks psqlscan_callbacks = {
 	psql_error
 };
 
+/*
+ * execute query if branch is active.
+ * warn interactive users about ignored queries.
+ */
+static
+bool send_query(const char *query)
+{
+	/* execute query if branch is active */
+	if (pset.active_branch)
+		return SendQuery(query);
+
+	if (pset.cur_cmd_interactive)
+		psql_error("inside inactive branch, query ignored.\n");
+
+	return true;
+}
 
 /*
  * Main processing loop for reading lines of input
@@ -296,8 +312,8 @@ MainLoop(FILE *source)
 					line_saved_in_history = true;
 				}
 
-				/* execute query */
-				success = SendQuery(query_buf->data);
+				success = send_query(query_buf->data);
+
 				slashCmdStatus = success ? PSQL_CMD_SEND : PSQL_CMD_ERROR;
 				pset.stmt_lineno = 1;
 
@@ -358,7 +374,7 @@ MainLoop(FILE *source)
 
 				if (slashCmdStatus == PSQL_CMD_SEND)
 				{
-					success = SendQuery(query_buf->data);
+					success = send_query(query_buf->data);
 
 					/* transfer query to previous_buf by pointer-swapping */
 					{
@@ -367,6 +383,7 @@ MainLoop(FILE *source)
 						previous_buf = query_buf;
 						query_buf = swap_buf;
 					}
+
 					resetPQExpBuffer(query_buf);
 
 					/* flush any paren nesting info after forced send */
@@ -429,8 +446,7 @@ MainLoop(FILE *source)
 		if (pset.cur_cmd_interactive)
 			pg_send_history(history_buf);
 
-		/* execute query */
-		success = SendQuery(query_buf->data);
+		success = send_query(query_buf->data);
 
 		if (!success && die_on_error)
 			successResult = EXIT_USER;
@@ -451,6 +467,15 @@ MainLoop(FILE *source)
 	destroyPQExpBuffer(previous_buf);
 	destroyPQExpBuffer(history_buf);
 
+	/* check for unbalanced \if-\endifs unless user explicitly quit */
+	if (slashCmdStatus != PSQL_CMD_TERMINATE
+		&& !psqlscan_branch_stack_empty(scan_state))
+	{
+		psql_error("found EOF before closing \\endif(s)\n");
+		if (die_on_error)
+			successResult = EXIT_USER;
+	}
+
 	psql_scan_destroy(scan_state);
 
 	pset.cur_cmd_source = prev_cmd_source;
diff --git a/src/bin/psql/settings.h b/src/bin/psql/settings.h
index 195f5a1..c8aeab6 100644
--- a/src/bin/psql/settings.h
+++ b/src/bin/psql/settings.h
@@ -114,6 +114,9 @@ typedef struct _psqlSettings
 
 	VariableSpace vars;			/* "shell variable" repository */
 
+	bool		active_branch;	/* true if session is not in an \if branch
+								 * or the current branch is true */
+
 	/*
 	 * The remaining fields are set by assign hooks associated with entries in
 	 * "vars".  They should not be set directly except by those hook
diff --git a/src/bin/psql/startup.c b/src/bin/psql/startup.c
index 88d686a..5c8760a 100644
--- a/src/bin/psql/startup.c
+++ b/src/bin/psql/startup.c
@@ -128,6 +128,8 @@ main(int argc, char *argv[])
 	setvbuf(stderr, NULL, _IONBF, 0);
 #endif
 
+	pset.active_branch = true;
+
 	pset.progname = get_progname(argv[0]);
 
 	pset.db = NULL;
diff --git a/src/bin/psql/t/001_if.pl b/src/bin/psql/t/001_if.pl
new file mode 100644
index 0000000..2ed01c5
--- /dev/null
+++ b/src/bin/psql/t/001_if.pl
@@ -0,0 +1,32 @@
+use strict;
+use warnings;
+
+use Config;
+use PostgresNode;
+use TestLib;
+use Test::More tests => 3;
+
+#
+# test invalid \if respects ON_ERROR_STOP
+#
+my $stdout;
+my $stderr;
+my $node = get_new_node('master');
+$node->init;
+$node->start;
+
+my $script_1 = q(\if invalid_expression
+);
+
+my $stderr_1  = q(psql:<stdin>:1: unrecognized value "invalid_expression" for "\if <expr>": boolean expected
+psql:<stdin>:1: found EOF before closing \endif(s));
+
+my $retcode = $node->psql('postgres', $script_1,
+		stdout => \$stdout, stderr => \$stderr,
+		on_error_stop => 1);
+is($retcode,'3','Invalid \if respects ON_ERROR_STOP');
+is($stdout,'','STDOUT mismatch');
+is($stderr, $stderr_1, 'STDERR mismatch');
+
+
+$node->teardown_node;
diff --git a/src/fe_utils/psqlscan.l b/src/fe_utils/psqlscan.l
index 1b29341..998630a 100644
--- a/src/fe_utils/psqlscan.l
+++ b/src/fe_utils/psqlscan.l
@@ -904,6 +904,8 @@ psql_scan_create(const PsqlScanCallbacks *callbacks)
 
 	psql_scan_reset(state);
 
+	state->branch_stack = NULL;
+
 	return state;
 }
 
@@ -919,6 +921,13 @@ psql_scan_destroy(PsqlScanState state)
 
 	yylex_destroy(state->scanner);
 
+	while (state->branch_stack != NULL)
+	{
+		IfStackElem *p = state->branch_stack;
+		state->branch_stack = state->branch_stack->next;
+		free(p);
+	}
+
 	free(state);
 }
 
@@ -1426,3 +1435,86 @@ psqlscan_escape_variable(PsqlScanState state, const char *txt, int len,
 		psqlscan_emit(state, txt, len);
 	}
 }
+
+/*
+ * psqlscan_branch_stack_empty
+ *
+ * True if there are no active \if-structures
+ */
+bool
+psqlscan_branch_stack_empty(PsqlScanState state)
+{
+	return state->branch_stack == NULL;
+}
+
+/*
+ * Fetch the current state of the top of the stack
+ */
+ifState
+psqlscan_branch_get_state(PsqlScanState state)
+{
+	if (psqlscan_branch_stack_empty(state))
+		return IFSTATE_NONE;
+	return state->branch_stack->if_state;
+}
+
+/*
+ * psqlscan_branch_active
+ *
+ * True if the current \if-block (if any) is true and queries/commands
+ * should be executed.
+ */
+bool
+psqlscan_branch_active(PsqlScanState state)
+{
+	ifState s = psqlscan_branch_get_state(state);
+	return s == IFSTATE_NONE || s == IFSTATE_TRUE || s == IFSTATE_ELSE_TRUE;
+}
+
+
+/*
+ * psqlscan_branch_push
+ *
+ * Create a new \if branch.
+ */
+bool
+psqlscan_branch_push(PsqlScanState state, ifState new_state)
+{
+	IfStackElem *p = pg_malloc0(sizeof(IfStackElem));
+	p->if_state = new_state;
+	p->next = state->branch_stack;
+	state->branch_stack = p;
+	return true;
+}
+
+/*
+ * psqlscan_branch_set_state
+ *
+ * Change the state of the topmost branch.
+ * Returns false if there was branch state to set.
+ */
+bool
+psqlscan_branch_set_state(PsqlScanState state, ifState new_state)
+{
+	if (psqlscan_branch_stack_empty(state))
+		return false;
+	state->branch_stack->if_state = new_state;
+	return true;
+}
+
+/*
+ * psqlscan_branch_pop
+ *
+ * Destroy the topmost branch because and \endif was encountered.
+ * Returns false if there was no branch to end.
+ */
+bool
+psqlscan_branch_pop(PsqlScanState state)
+{
+	IfStackElem *p = state->branch_stack;
+	if (!p)
+		return false;
+	state->branch_stack = state->branch_stack->next;
+	free(p);
+	return true;
+}
diff --git a/src/include/fe_utils/psqlscan_int.h b/src/include/fe_utils/psqlscan_int.h
index 0fddc7a..321d455 100644
--- a/src/include/fe_utils/psqlscan_int.h
+++ b/src/include/fe_utils/psqlscan_int.h
@@ -75,6 +75,30 @@ typedef struct StackElem
 	struct StackElem *next;
 } StackElem;
 
+typedef enum _ifState
+{
+	IFSTATE_NONE = 0,	/* Not currently in an \if block */
+	IFSTATE_TRUE,		/* currently in an \if or \elif which is true
+						 * and all parent branches (if any) are true */
+	IFSTATE_FALSE,		/* currently in an \if or \elif which is false
+						 * but no true branch has yet been seen,
+						 * and all parent branches (if any) are true */
+	IFSTATE_IGNORED,	/* currently in an \elif which follows a true \if
+						 * or the whole \if is a child of a false parent */
+	IFSTATE_ELSE_TRUE,	/* currently in an \else which is true
+						 * and all parent branches (if any) are true */
+	IFSTATE_ELSE_FALSE	/* currently in an \else which is false or ignored */
+} ifState;
+
+/*
+ * The state of nested ifs is stored in a stack.
+ */
+typedef struct IfStackElem
+{
+	ifState		if_state;
+	struct IfStackElem *next;
+} IfStackElem;
+
 /*
  * All working state of the lexer must be stored in PsqlScanStateData
  * between calls.  This allows us to have multiple open lexer operations,
@@ -118,6 +142,11 @@ typedef struct PsqlScanStateData
 	 * Callback functions provided by the program making use of the lexer.
 	 */
 	const PsqlScanCallbacks *callbacks;
+
+	/*
+	 * \if branch state variables
+	 */
+	IfStackElem *branch_stack;
 } PsqlScanStateData;
 
 
@@ -141,4 +170,21 @@ extern void psqlscan_escape_variable(PsqlScanState state,
 						 const char *txt, int len,
 						 bool as_ident);
 
+/*
+ * branching commands
+ */
+extern bool psqlscan_branch_stack_empty(PsqlScanState state);
+
+extern bool psqlscan_branch_active(PsqlScanState state);
+
+extern ifState psqlscan_branch_get_state(PsqlScanState state);
+
+extern bool psqlscan_branch_push(PsqlScanState state,
+									ifState new_state);
+
+extern bool psqlscan_branch_set_state(PsqlScanState state,
+									ifState new_state);
+
+extern bool psqlscan_branch_pop(PsqlScanState state);
+
 #endif   /* PSQLSCAN_INT_H */
diff --git a/src/test/regress/expected/psql.out b/src/test/regress/expected/psql.out
index 026a4f0..d615eb8 100644
--- a/src/test/regress/expected/psql.out
+++ b/src/test/regress/expected/psql.out
@@ -2712,6 +2712,95 @@ deallocate q;
 \pset format aligned
 \pset expanded off
 \pset border 1
+-- test a large nested if using a variety of true-equivalents
+\if true
+	\if 1
+		\if yes
+			\if on
+				\echo 'all true'
+all true
+			\else
+				\echo 'should not print #1-1'
+			\endif
+		\else
+			\echo 'should not print #1-2'
+		\endif
+	\else
+		\echo 'should not print #1-3'
+	\endif
+\else
+	\echo 'should not print #1-4'
+\endif
+-- test a variety of false-equivalents in an if/elif/else structure
+\if false
+	\echo 'should not print #2-1'
+\elif 0
+	\echo 'should not print #2-2'
+\elif no
+	\echo 'should not print #2-3'
+\elif off
+	\echo 'should not print #2-4'
+\else
+	\echo 'all false'
+all false
+\endif
+-- test simple true-then-else
+\if true
+	\echo 'first thing true'
+first thing true
+\else
+	\echo 'should not print #3-1'
+\endif
+-- test simple false-true-else
+\if false
+	\echo 'should not print #4-1'
+\elif true
+	\echo 'second thing true'
+second thing true
+\else
+	\echo 'should not print #5-1'
+\endif
+-- test invalidation of whole if-endif when invalid boolean is given
+\if invalid_boolean_expression
+unrecognized value "invalid_boolean_expression" for "\if <expr>": boolean expected
+	\echo 'should not print #6-1'
+\else
+	\echo 'should not print because whole if-then is wrecked #6-2'
+\endif
+-- test non-evaluation of variables in false blocks
+\set var 'ab''cd'
+-- select :var;
+\if false
+  select :var ;
+\else
+  select 1;
+ ?column? 
+----------
+        1
+(1 row)
+
+\endif
+-- test un-matched endif
+\endif
+encountered un-matched \endif
+-- test un-matched else
+\else
+encountered un-matched \else
+-- test un-matched elif
+\elif
+encountered un-matched \elif
+-- test double-else error
+\if true
+\else
+\else
+encountered \else after \else
+\endif
+-- test elif out-of-order
+\if false
+\else
+\elif
+encountered \elif after \else
+\endif
 -- SHOW_CONTEXT
 \set SHOW_CONTEXT never
 do $$
diff --git a/src/test/regress/sql/psql.sql b/src/test/regress/sql/psql.sql
index d823d11..ba41d9e 100644
--- a/src/test/regress/sql/psql.sql
+++ b/src/test/regress/sql/psql.sql
@@ -375,6 +375,91 @@ deallocate q;
 \pset expanded off
 \pset border 1
 
+-- test a large nested if using a variety of true-equivalents
+\if true
+	\if 1
+		\if yes
+			\if on
+				\echo 'all true'
+			\else
+				\echo 'should not print #1-1'
+			\endif
+		\else
+			\echo 'should not print #1-2'
+		\endif
+	\else
+		\echo 'should not print #1-3'
+	\endif
+\else
+	\echo 'should not print #1-4'
+\endif
+
+-- test a variety of false-equivalents in an if/elif/else structure
+\if false
+	\echo 'should not print #2-1'
+\elif 0
+	\echo 'should not print #2-2'
+\elif no
+	\echo 'should not print #2-3'
+\elif off
+	\echo 'should not print #2-4'
+\else
+	\echo 'all false'
+\endif
+
+-- test simple true-then-else
+\if true
+	\echo 'first thing true'
+\else
+	\echo 'should not print #3-1'
+\endif
+
+-- test simple false-true-else
+\if false
+	\echo 'should not print #4-1'
+\elif true
+	\echo 'second thing true'
+\else
+	\echo 'should not print #5-1'
+\endif
+
+-- test invalidation of whole if-endif when invalid boolean is given
+\if invalid_boolean_expression
+	\echo 'should not print #6-1'
+\else
+	\echo 'should not print because whole if-then is wrecked #6-2'
+\endif
+
+-- test non-evaluation of variables in false blocks
+\set var 'ab''cd'
+-- select :var;
+\if false
+  select :var ;
+\else
+  select 1;
+\endif
+
+-- test un-matched endif
+\endif
+
+-- test un-matched else
+\else
+
+-- test un-matched elif
+\elif
+
+-- test double-else error
+\if true
+\else
+\else
+\endif
+
+-- test elif out-of-order
+\if false
+\else
+\elif
+\endif
+
 -- SHOW_CONTEXT
 
 \set SHOW_CONTEXT never


^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-02-03 11:00  Erik Rijkers <er@xs4all.nl>
  parent: Corey Huinker <corey.huinker@gmail.com>
  1 sibling, 1 reply; 232+ messages in thread

From: Erik Rijkers @ 2017-02-03 11:00 UTC (permalink / raw)
  To: Corey Huinker <corey.huinker@gmail.com>; +Cc: Fabien COELHO <coelho@cri.ensmp.fr>; Tom Lane <tgl@sss.pgh.pa.us>; Jim Nasby <Jim.Nasby@bluetreble.com>; Daniel Verite <daniel@manitou-mail.org>; pgsql-hackers; pgsql-hackers-owner@postgresql.org

On 2017-02-03 08:16, Corey Huinker wrote:

> 0001.if_endif.v5.diff

1. Well, with this amount of interactive output  it is impossible to get 
stuck without knowing :)
This is good. Still, it would be an improvement to be able to break out 
of an inactive \if-branch
with Ctrl-C.  (I noticed that inside an active branch it is already 
possible )
'\endif' is too long to type, /and/ you have to know it.

2. Inside an \if block  \q should be given precedence and cause a direct 
exit of psql (or at the
very least exit the if block(s)), as in regular SQL statements
(compare: 'select * from t  \q'  which will immediately exit psql -- 
this is good. )

3. I think the 'barking' is OK because interactive use is certainly not 
the first use-case.
But nonetheless it could be made a bit more terse without losing its 
function.
The interactive behavior is now:
# \if 1
entered if: active, executing commands
# \elif 0
entered elif: inactive, ignoring commands
# \else
entered else: inactive, ignoring commands
# \endif
exited if: active, executing commands

It really is a bit too wordy, IMHO; I would say, drop all 'entered', 
'active',  and 'inactive' words.
That leaves it plenty clear what's going on.
That would make those lines:
if: executing commands
elif: ignoring commands
else: ignoring commands
exited if
    (or alternatively, just  mention 'if: active' or 'elif: inactive', 
etc., which has the advantage of being shorter)

5. A real bug, I think:
#\if asdasd
unrecognized value "asdasd" for "\if <expr>": boolean expected
# \q;
inside inactive branch, command ignored.
#

That 'unrecognized value' message is fair enough but it is 
counterintuitive that after an erroneous opening \if-expression, the 
if-modus should be entered into. ( and now I have to type \endif 
again... )

6. About the help screen:
There should be an empty line above 'Conditionals' to visually divide it 
from other help items.

The indenting of the new block is incorrect: the lines that start with
      fprintf(output, _("  \\
are indented to the correct level; the other lines are indented 1 place 
too much.

The help text has a few typos (some multiple times):
queires -> queries
exectue -> execute
subsequennt -> subsequent

Thanks,

Erik Rijkers


-- 
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers



^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-02-03 12:24  Fabien COELHO <coelho@cri.ensmp.fr>
  parent: Erik Rijkers <er@xs4all.nl>
  0 siblings, 2 replies; 232+ messages in thread

From: Fabien COELHO @ 2017-02-03 12:24 UTC (permalink / raw)
  To: Erik Rijkers <er@xs4all.nl>; +Cc: Corey Huinker <corey.huinker@gmail.com>; Tom Lane <tgl@sss.pgh.pa.us>; Jim Nasby <Jim.Nasby@bluetreble.com>; Daniel Verite <daniel@manitou-mail.org>; pgsql-hackers; pgsql-hackers-owner@postgresql.org


Hello Erik,

> Still, it would be an improvement to be able to break out of an inactive 
> \if-branch with Ctrl-C.

Yes.

> '\endif' is too long to type, /and/ you have to know it.

Yep. \if is shorter but has been rejected. Ctrl-C should be the way out.

> 2. Inside an \if block \q should be given precedence and cause a direct 
> exit of psql (or at the very least exit the if block(s)), as in regular 
> SQL statements (compare: 'select * from t \q' which will immediately 
> exit psql -- this is good. )

One use case if to be able to write "\if ... \q \endif" in scripts. If \q 
is always executed, then the use case is blown. I cannot think of any 
language that would execute anything in a false branch. So Ctrl-C or 
Ctrl-D is the way out, and \if control must really have precedence over 
its contents.

> 3. I think the 'barking' is OK because interactive use is certainly not the 
> first use-case.
> But nonetheless it could be made a bit more terse without losing its 
> function.

> [...] It really is a bit too wordy, [...]

Maybe.

> (or alternatively, just  mention 'if: active' or 'elif: inactive', etc., 
> which has the advantage of being shorter)

This last version is too terse I think. The point is that the user 
understands whether their commands are going to be executed or ignored, 
and "active/inactive" is not very clear.

> 5. A real bug, I think:
> #\if asdasd
> unrecognized value "asdasd" for "\if <expr>": boolean expected
> # \q;
> inside inactive branch, command ignored.
> #
>
> That 'unrecognized value' message is fair enough but it is counterintuitive 
> that after an erroneous opening \if-expression, the if-modus should be 
> entered into. ( and now I have to type \endif again... )

Hmmm.

It should tell that it is in an unclosed if and that it is 
currently ignoring commands, so the "barking" is missing.

Otherwise that is really the currently desired behavior for scripting use:

   \if syntax-error...
     DROP USER foo;
   \elif ...
     DROP DATABASE foo;
   \else
     ...
   \endif

If the "\if" is simply ignored, then it is going to execute everything 
that appears after that, whereas the initial condition failed to be 
checked, and it will proceed to ignore all further \elif and \else in 
passing.

Also, I do not think that implementing a different behavior for 
interactive is a good idea, because then typing directly and reading a 
file would result in different behaviors, which would not help debugging.

So, as Tom suggested (I think), the feature is not designed for 
interactive use, so it does not need to be optimized for that purpose,
although it should be sane enough.

-- 
Fabien.


-- 
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers



^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-02-03 13:24  Fabien COELHO <coelho@cri.ensmp.fr>
  parent: Fabien COELHO <coelho@cri.ensmp.fr>
  1 sibling, 0 replies; 232+ messages in thread

From: Fabien COELHO @ 2017-02-03 13:24 UTC (permalink / raw)
  To: Erik Rijkers <er@xs4all.nl>; +Cc: Corey Huinker <corey.huinker@gmail.com>; Tom Lane <tgl@sss.pgh.pa.us>; Jim Nasby <Jim.Nasby@bluetreble.com>; Daniel Verite <daniel@manitou-mail.org>; pgsql-hackers; pgsql-hackers-owner@postgresql.org


>> 2. Inside an \if block \q should be given precedence and cause a direct 
>> exit of psql (or at the very least exit the if block(s)), as in regular SQL 
>> statements (compare: 'select * from t \q' which will immediately exit psql 
>> -- this is good. )
>
> One use case if to be able to write "\if ... \q \endif" in scripts. If \q is 
> always executed, then the use case is blown. I cannot think of any language 
> that would execute anything in a false branch. So Ctrl-C or Ctrl-D is the way 
> out, and \if control must really have precedence over its contents.

After giving it some more thoughts, a possible solution could be to have a 
"\exit [status]" which could be ignored (there has been some talk about 
that one), and have \q which is not, but I would find it weird and error 
prone for the user. As already said, \if use-case is not about interactive 
psql.

-- 
Fabien.


-- 
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers



^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-02-03 16:08  Corey Huinker <corey.huinker@gmail.com>
  parent: Fabien COELHO <coelho@cri.ensmp.fr>
  1 sibling, 2 replies; 232+ messages in thread

From: Corey Huinker @ 2017-02-03 16:08 UTC (permalink / raw)
  To: Fabien COELHO <coelho@cri.ensmp.fr>; +Cc: Erik Rijkers <er@xs4all.nl>; Tom Lane <tgl@sss.pgh.pa.us>; Jim Nasby <Jim.Nasby@bluetreble.com>; Daniel Verite <daniel@manitou-mail.org>; pgsql-hackers; pgsql-hackers-owner@postgresql.org

On Fri, Feb 3, 2017 at 7:24 AM, Fabien COELHO <coelho@cri.ensmp.fr> wrote:

>
> Hello Erik,
>
> Still, it would be an improvement to be able to break out of an inactive
>> \if-branch with Ctrl-C.
>>
>
> Yes.
>
> '\endif' is too long to type, /and/ you have to know it.
>>
>
> Yep. \if is shorter but has been rejected. Ctrl-C should be the way out.


I could bulk up the error message on if/elif like such:

if: true, executing commands.
if: false, ignoring commands until next \else, \elif, or \endif.
if: error, ignoring all commands until next \endif
else: true, executing commands
else: false, ignoring commands until next \endif
else: error, ignoring commands until next \endif
endif: now executing commands
endif: ignoring commands until next [\else, [\elif [, \endif]]


Basically, I'd tailor the message to as closely reflect what is possible
for the user at this moment.


Can anyone think of a reason why Ctrl-C would be a bad idea? If not I'll
start looking into it, as I'm not presently aware of what it is used for.


2. Inside an \if block \q should be given precedence and cause a direct
>> exit of psql (or at the very least exit the if block(s)), as in regular SQL
>> statements (compare: 'select * from t \q' which will immediately exit psql
>> -- this is good. )
>>
>
> One use case if to be able to write "\if ... \q \endif" in scripts. If \q
> is always executed, then the use case is blown. I cannot think of any
> language that would execute anything in a false branch. So Ctrl-C or Ctrl-D
> is the way out, and \if control must really have precedence over its
> contents.
>
> 3. I think the 'barking' is OK because interactive use is certainly not
>> the first use-case.
>> But nonetheless it could be made a bit more terse without losing its
>> function.
>>
>
> [...] It really is a bit too wordy, [...]
>>
>
> Maybe.
>
> (or alternatively, just  mention 'if: active' or 'elif: inactive', etc.,
>> which has the advantage of being shorter)
>>
>
> This last version is too terse I think. The point is that the user
> understands whether their commands are going to be executed or ignored, and
> "active/inactive" is not very clear.
>
> 5. A real bug, I think:
>> #\if asdasd
>> unrecognized value "asdasd" for "\if <expr>": boolean expected
>> # \q;
>> inside inactive branch, command ignored.
>> #
>>
>> That 'unrecognized value' message is fair enough but it is
>> counterintuitive that after an erroneous opening \if-expression, the
>> if-modus should be entered into. ( and now I have to type \endif again... )
>>
>
> Hmmm.
>
> It should tell that it is in an unclosed if and that it is currently
> ignoring commands, so the "barking" is missing.
>

It does need a bespoke bark.

Also, I do not think that implementing a different behavior for interactive
> is a good idea, because then typing directly and reading a file would
> result in different behaviors, which would not help debugging.
>

+1


>
> So, as Tom suggested (I think), the feature is not designed for
> interactive use, so it does not need to be optimized for that purpose,
> although it should be sane enough.


+1

^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-02-03 16:38  Fabien COELHO <coelho@cri.ensmp.fr>
  parent: Corey Huinker <corey.huinker@gmail.com>
  1 sibling, 2 replies; 232+ messages in thread

From: Fabien COELHO @ 2017-02-03 16:38 UTC (permalink / raw)
  To: Corey Huinker <corey.huinker@gmail.com>; +Cc: Erik Rijkers <er@xs4all.nl>; Tom Lane <tgl@sss.pgh.pa.us>; Jim Nasby <Jim.Nasby@bluetreble.com>; Daniel Verite <daniel@manitou-mail.org>; pgsql-hackers; pgsql-hackers-owner@postgresql.org


> I could bulk up the error message on if/elif like such: [...]

Looks ok to me.

> Can anyone think of a reason why Ctrl-C would be a bad idea? If not I'll
> start looking into it, as I'm not presently aware of what it is used for.

Not me.

Wikipedia, which holds all the knowledge in the universe, says: "In many 
command-line interface environments, control-C is used to abort the 
current task and regain user control."

I agree that it should do that.

-- 
Fabien.


-- 
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers



^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-02-03 16:49  Corey Huinker <corey.huinker@gmail.com>
  parent: Fabien COELHO <coelho@cri.ensmp.fr>
  1 sibling, 1 reply; 232+ messages in thread

From: Corey Huinker @ 2017-02-03 16:49 UTC (permalink / raw)
  To: Fabien COELHO <coelho@cri.ensmp.fr>; +Cc: Erik Rijkers <er@xs4all.nl>; Tom Lane <tgl@sss.pgh.pa.us>; Jim Nasby <Jim.Nasby@bluetreble.com>; Daniel Verite <daniel@manitou-mail.org>; pgsql-hackers; pgsql-hackers-owner@postgresql.org

>
> Can anyone think of a reason why Ctrl-C would be a bad idea? If not I'll
>> start looking into it, as I'm not presently aware of what it is used for.
>>
>
> Not me.
>
> Wikipedia, which holds all the knowledge in the universe, says: "In many
> command-line interface environments, control-C is used to abort the current
> task and regain user control."
>

Well played (again). That one ranks up there with "and don't call me
Shirley." I meant in the specific psql-context, does it do anything other
than (attempt to) terminate sent-but-not-received SQL queries?

^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-02-03 17:10  Tom Lane <tgl@sss.pgh.pa.us>
  parent: Fabien COELHO <coelho@cri.ensmp.fr>
  1 sibling, 0 replies; 232+ messages in thread

From: Tom Lane @ 2017-02-03 17:10 UTC (permalink / raw)
  To: Corey Huinker <corey.huinker@gmail.com>; +Cc: Fabien COELHO <coelho@cri.ensmp.fr>; Erik Rijkers <er@xs4all.nl>; Jim Nasby <Jim.Nasby@bluetreble.com>; Daniel Verite <daniel@manitou-mail.org>; pgsql-hackers; pgsql-hackers-owner@postgresql.org

Corey Huinker <corey.huinker@gmail.com> writes:
> Well played (again). That one ranks up there with "and don't call me
> Shirley." I meant in the specific psql-context, does it do anything other
> than (attempt to) terminate sent-but-not-received SQL queries?

It also flushes the input buffer.  I think it is probably reasonable to
let it cancel interactive \if state as well.  A useful thought-experiment
is to ask what behavior you'd want if we had metacommand loops ... and
I think the answer there is pretty obvious: you'd want control-C to kill
a loop.

I'm less sure about what it ought to do when control is somewhere in
a script file.  I *think* we have things set up to kill execution of
script files altogether, in which case we have the answer a fortiori.
If not, there's room for discussion.

			regards, tom lane


-- 
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers



^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-02-03 17:20  Daniel Verite <daniel@manitou-mail.org>
  parent: Corey Huinker <corey.huinker@gmail.com>
  0 siblings, 1 reply; 232+ messages in thread

From: Daniel Verite @ 2017-02-03 17:20 UTC (permalink / raw)
  To: Corey Huinker <corey.huinker@gmail.com>; +Cc: Fabien COELHO <coelho@cri.ensmp.fr>; Erik Rijkers <er@xs4all.nl>; Tom Lane <tgl@sss.pgh.pa.us>; Jim Nasby <Jim.Nasby@bluetreble.com>; pgsql-hackers; pgsql-hackers-owner@postgresql.org

	Corey Huinker wrote:

> I meant in the specific psql-context, does it do anything other
> than (attempt to) terminate sent-but-not-received SQL queries?

It cancels the current edit in the query buffer, including the
case when it spans multiple lines.
If we add the functionality that Ctrl+C also exits from branches,
we could do it like the shell does Ctrl+D for logout, that is it
logs out only if the input buffer is empty, otherwise it does
the other functionality bound to this key (normally Delete).
So if you're in the middle of an edit, the first Ctrl+C will
cancel the edit and a second one will go back from the /if

Best regards,
-- 
Daniel Vérité
PostgreSQL-powered mailer: http://www.manitou-mail.org
Twitter: @DanielVerite


-- 
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers



^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-02-03 20:03  Corey Huinker <corey.huinker@gmail.com>
  parent: Daniel Verite <daniel@manitou-mail.org>
  0 siblings, 1 reply; 232+ messages in thread

From: Corey Huinker @ 2017-02-03 20:03 UTC (permalink / raw)
  To: Daniel Verite <daniel@manitou-mail.org>; +Cc: Fabien COELHO <coelho@cri.ensmp.fr>; Erik Rijkers <er@xs4all.nl>; Tom Lane <tgl@sss.pgh.pa.us>; Jim Nasby <Jim.Nasby@bluetreble.com>; pgsql-hackers; pgsql-hackers-owner@postgresql.org

On Fri, Feb 3, 2017 at 12:20 PM, Daniel Verite <daniel@manitou-mail.org>
wrote:

> If we add the functionality that Ctrl+C also exits from branches,
> we could do it like the shell does Ctrl+D for logout, that is it
> logs out only if the input buffer is empty, otherwise it does
> the other functionality bound to this key (normally Delete).
> So if you're in the middle of an edit, the first Ctrl+C will
> cancel the edit and a second one will go back from the /if
>

That does seem to be the consensus desired behavior. I'm just not sure
where to handle that. The var "cancel_pressed" shows up in a lot of places.
Advice?

^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-02-03 20:49  Robert Haas <robertmhaas@gmail.com>
  parent: Corey Huinker <corey.huinker@gmail.com>
  1 sibling, 1 reply; 232+ messages in thread

From: Robert Haas @ 2017-02-03 20:49 UTC (permalink / raw)
  To: Corey Huinker <corey.huinker@gmail.com>; +Cc: Fabien COELHO <coelho@cri.ensmp.fr>; Erik Rijkers <er@xs4all.nl>; Tom Lane <tgl@sss.pgh.pa.us>; Jim Nasby <Jim.Nasby@bluetreble.com>; Daniel Verite <daniel@manitou-mail.org>; pgsql-hackers; pgsql-hackers-owner@postgresql.org

On Fri, Feb 3, 2017 at 11:08 AM, Corey Huinker <corey.huinker@gmail.com> wrote:
> I could bulk up the error message on if/elif like such:
>
> if: true, executing commands.
> if: false, ignoring commands until next \else, \elif, or \endif.
> if: error, ignoring all commands until next \endif
> else: true, executing commands
> else: false, ignoring commands until next \endif
> else: error, ignoring commands until next \endif
> endif: now executing commands
> endif: ignoring commands until next [\else, [\elif [, \endif]]
>
> Basically, I'd tailor the message to as closely reflect what is possible for
> the user at this moment.

I think that this is kinda hairy.  When I see "endif: now executing
commands", my reaction is "oh crap, which commands are you
executing?".  What you really mean is that future command are expected
to be executed unless things change (for example, due to another \if
in the meantime), but somebody might have a different interpretation
of these messages.

I think that the messages you are proposing for "if" and "else" are
reasonable, but for "endif" I would just say "endif: exiting if" or
something like that.  If the user doesn't know to what state they are
returning, c'est la vie.

-- 
Robert Haas
EnterpriseDB: http://www.enterprisedb.com
The Enterprise PostgreSQL Company


-- 
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers



^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-02-03 21:24  Corey Huinker <corey.huinker@gmail.com>
  parent: Robert Haas <robertmhaas@gmail.com>
  0 siblings, 1 reply; 232+ messages in thread

From: Corey Huinker @ 2017-02-03 21:24 UTC (permalink / raw)
  To: Robert Haas <robertmhaas@gmail.com>; +Cc: Fabien COELHO <coelho@cri.ensmp.fr>; Erik Rijkers <er@xs4all.nl>; Tom Lane <tgl@sss.pgh.pa.us>; Jim Nasby <Jim.Nasby@bluetreble.com>; Daniel Verite <daniel@manitou-mail.org>; pgsql-hackers; pgsql-hackers-owner@postgresql.org

On Fri, Feb 3, 2017 at 3:49 PM, Robert Haas <robertmhaas@gmail.com> wrote:

> On Fri, Feb 3, 2017 at 11:08 AM, Corey Huinker <corey.huinker@gmail.com>
> wrote:
> > I could bulk up the error message on if/elif like such:
> >
> > if: true, executing commands.
> > if: false, ignoring commands until next \else, \elif, or \endif.
> > if: error, ignoring all commands until next \endif
> > else: true, executing commands
> > else: false, ignoring commands until next \endif
> > else: error, ignoring commands until next \endif
> > endif: now executing commands
> > endif: ignoring commands until next [\else, [\elif [, \endif]]
> >
> > Basically, I'd tailor the message to as closely reflect what is possible
> for
> > the user at this moment.
>
> I think that this is kinda hairy.  When I see "endif: now executing
> commands", my reaction is "oh crap, which commands are you
> executing?".  What you really mean is that future command are expected
> to be executed unless things change (for example, due to another \if
> in the meantime), but somebody might have a different interpretation
> of these messages.
>
> I think that the messages you are proposing for "if" and "else" are
> reasonable, but for "endif" I would just say "endif: exiting if" or
> something like that.  If the user doesn't know to what state they are
> returning, c'est la vie.
>

That might be what we end up doing. I'm willing to see how unwieldy it gets
before rolling back to "endif: peace out".

The state logic has stuff to do anyway, so for the moment I've added
psql_error() messages at each endpoint. My current (unsubmitted) work has:

if you were in a true branch and leave it  (i.e yes->yes)

+                                       psql_error("exited \\if to true
parent branch, \n"
+                                                       "continuing
executing commands\n");

if you were in a false branch beneath a true branch and leave it  (no->yes)

+                                       psql_error("exited \\if to true
parent branch, \n"
+                                                       "resuming executing
commands\n");

And if you were in a branch that was a child of a false branch (no->no):

+                               psql_error("exited \\if to false parent
branch, \n"
+                                               "ignoring commands until
next \\endif\n");

And the (yes->no) is an impossibility, so no message there.

I'm not too concerned about what wording we finally go with, and as the
coder I realize I'm too close to know the wording that will be most helpful
to an outsider, so I'm very much trusting others to guide me.

^ permalink  raw  reply  [nested|flat] 232+ messages in thread

* Re: \if, \elseif, \else, \endif (was Re: PSQL commands: \quit_if, \quit_unless)
@ 2017-02-03 21:37  Robert Haas <robertmhaas@gmail.com>
  parent: Corey Huinker <corey.huinker@gmail.com>
  0 siblings, 0 replies; 232+ messages in thread

From: Robert Haas @ 2017-02-03 21:37 UTC (permalink / raw)
  To: Corey Huinker <corey.huinker@gmail.com>; +Cc: Fabien COELHO <coelho@cri.ensmp.fr>; Erik Rijkers <er@xs4all.nl>; Tom Lane <tgl@sss.pgh.pa.us>; Jim Nasby <Jim.Nasby@bluetreble.com>; Daniel Verite <daniel@manitou-mail.org>; pgsql-hackers; pgsql-hackers-owner@postgresql.org

On Fri, Feb 3, 2017 at 4:24 PM, Corey Huinker <corey.huinker@gmail.com> wrote:
> That might be what we end up doing. I'm willing to see how unwieldy it gets
> before rolling back to "endif: peace out".

All I'm saying is, give peace a chance.  :-)

> The state logic has stuff to do anyway, so for the moment I've added
> psql_error() messages at each endpoint. My current (unsubmitted) work has:
>
> if you were in a true branch and leave it  (i.e yes->yes)
>
> +                                       psql_error("exited \\if to true
> parent branch, \n"
> +                                                       "continuing
> executing commands\n");
>
> if you were in a false branch beneath a true branch and leave it  (no->yes)
>
> +                                       psql_error("exited \\if to true
> parent branch, \n"
> +                                                       "resuming executing
> commands\n");
>
> And if you were in a branch that was a child of a false branch (no->no):
>
> +                               psql_error("exited \\if to false parent
> branch, \n"
> +                                               "ignoring commands until
> next \\endif\n");
>
> And the (yes->no) is an impossibility, so no message there.
>
> I'm not too concerned about what wording we finally go with, and as the
> coder I realize I'm too close to know the wording that will be most helpful
> to an outsider, so I'm very much trusting others to guide me.

But by far the most likely case is that you are not under another \if
at all, and none of these messages are really apropos for that case.

-- 
Robert Haas
EnterpriseDB: http://www.enterprisedb.com
The Enterprise PostgreSQL Company


-- 
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers



^ permalink  raw  reply  [nested|flat] 232+ messages in thread