Add \shell and \setshell meta commands to pgbench.

\shell command runs an external shell command.
\setshell also does the same and sets the result to a variable.

original patch by Michael Paquier with some editorialization by Itagaki,
and reviewed by Greg Smith.

diff --git a/contrib/pgbench/pgbench.c b/contrib/pgbench/pgbench.c
index b5520754e4a479c6e91355dcd5cd84bdda9b34eb..470247d07872af54667bc361f220fe811ef894fe 100644 (file)
--- a/contrib/pgbench/pgbench.c
+++ b/contrib/pgbench/pgbench.c
@@ -4,7 +4,7 @@
  * A simple benchmark program for PostgreSQL
  * Originally written by Tatsuo Ishii and enhanced by many contributors.
  *
- * $PostgreSQL: pgsql/contrib/pgbench/pgbench.c,v 1.92 2009/12/11 21:50:06 tgl Exp $
+ * $PostgreSQL: pgsql/contrib/pgbench/pgbench.c,v 1.93 2009/12/15 07:17:57 itagaki Exp $
  * Copyright (c) 2000-2009, PostgreSQL Global Development Group
  * ALL RIGHTS RESERVED;
  *
@@ -159,6 +159,7 @@ typedef struct
 } Variable;
 
 #define MAX_FILES              128             /* max number of SQL script files allowed */
+#define SHELL_COMMAND_SIZE     256     /* maximum size allowed for shell command */
 
 /*
  * structures used in custom query mode
@@ -467,8 +468,8 @@ putVariable(CState *st, char *name, char *value)
                var->name = NULL;
                var->value = NULL;
 
-               if ((var->name = strdup(name)) == NULL
-                       || (var->value = strdup(value)) == NULL)
+               if ((var->name = strdup(name)) == NULL ||
+                       (var->value = strdup(value)) == NULL)
                {
                        free(var->name);
                        free(var->value);
@@ -590,6 +591,114 @@ getQueryParams(CState *st, const Command *command, const char **params)
                params[i] = getVariable(st, command->argv[i + 1]);
 }
 
+/*
+ * Run a shell command. The result is assigned to the variable if not NULL.
+ * Return true if succeeded, or false on error.
+ */
+static bool
+runShellCommand(CState *st, char *variable, char **argv, int argc)
+{
+       char    command[SHELL_COMMAND_SIZE];
+       int             i,
+                       len = 0;
+       FILE   *fp;
+       char    res[64];
+       char   *endptr;
+       int             retval;
+
+       /*
+        * Join arguments with whilespace separaters. Arguments starting with
+        * exactly one colon are treated as variables:
+        *      name - append a string "name"
+        *      :var - append a variable named 'var'.
+        *      ::name - append a string ":name"
+        */
+       for (i = 0; i < argc; i++)
+       {
+               char   *arg;
+               int             arglen;
+
+               if (argv[i][0] != ':')
+               {
+                       arg = argv[i];  /* a string literal */
+               }
+               else if (argv[i][1] == ':')
+               {
+                       arg = argv[i] + 1;      /* a string literal starting with colons */
+               }
+               else if ((arg = getVariable(st, argv[i] + 1)) == NULL)
+               {
+                       fprintf(stderr, "%s: undefined variable %s\n", argv[0], argv[i]);
+                       return false;
+               }
+
+               arglen = strlen(arg);
+               if (len + arglen + (i > 0 ? 1 : 0) >= SHELL_COMMAND_SIZE - 1)
+               {
+                       fprintf(stderr, "%s: too long shell command\n", argv[0]);
+                       return false;
+               }
+
+               if (i > 0)
+                       command[len++] = ' ';
+               memcpy(command + len, arg, arglen);
+               len += arglen;
+       }
+
+       command[len] = '\0';
+
+       /* Fast path for non-assignment case */
+       if (variable == NULL)
+       {
+               if (system(command))
+               {
+                       if (!timer_exceeded)
+                               fprintf(stderr, "%s: cannot launch shell command\n", argv[0]);
+                       return false;
+               }
+               return true;
+       }
+
+       /* Execute the command with pipe and read the standard output. */
+       if ((fp = popen(command, "r")) == NULL)
+       {
+               fprintf(stderr, "%s: cannot launch shell command\n", argv[0]);
+               return false;
+       }
+       if (fgets(res, sizeof(res), fp) == NULL)
+       {
+               if (!timer_exceeded)
+                       fprintf(stderr, "%s: cannot read the result\n", argv[0]);
+               return false;
+       }
+       if (pclose(fp) < 0)
+       {
+               fprintf(stderr, "%s: cannot close shell command\n", argv[0]);
+               return false;
+       }
+
+       /* Check whether the result is an integer and assign it to the variable */
+       retval = (int) strtol(res, &endptr, 10);
+       while (*endptr != '\0' && isspace((unsigned char) *endptr))
+               endptr++;
+       if (*res == '\0' || *endptr != '\0')
+       {
+               fprintf(stderr, "%s: must return an integer ('%s' returned)\n", argv[0], res);
+               return false;
+       }
+       snprintf(res, sizeof(res), "%d", retval);
+       if (!putVariable(st, variable, res))
+       {
+               fprintf(stderr, "%s: out of memory\n", argv[0]);
+               return false;
+       }
+
+#ifdef DEBUG
+       printf("shell parameter name: %s, value: %s\n", argv[1], res);
+#endif
+       return true;
+}
+
 #define MAX_PREPARE_NAME               32
 static void
 preparedStatementName(char *buffer, int file, int state)
@@ -992,7 +1101,34 @@ top:
 
                        st->listen = 1;
                }
+               else if (pg_strcasecmp(argv[0], "setshell") == 0)
+               {
+                       bool    ret = runShellCommand(st, argv[1], argv + 2, argc - 2);
 
+                       if (timer_exceeded)     /* timeout */
+                               return clientDone(st, true);
+                       else if (!ret)          /* on error */
+                       {
+                               st->ecnt++;
+                               return true;
+                       }
+                       else    /* succeeded */
+                               st->listen = 1;
+               }
+               else if (pg_strcasecmp(argv[0], "shell") == 0)
+               {
+                       bool    ret = runShellCommand(st, NULL, argv + 1, argc - 1);
+
+                       if (timer_exceeded)     /* timeout */
+                               return clientDone(st, true);
+                       else if (!ret)          /* on error */
+                       {
+                               st->ecnt++;
+                               return true;
+                       }
+                       else    /* succeeded */
+                               st->listen = 1;
+               }
                goto top;
        }
 
@@ -1081,8 +1217,8 @@ init(void)
 
        for (i = 0; i < ntellers * scale; i++)
        {
-               snprintf(sql, 256, "insert into pgbench_tellers(tid,bid,tbalance) values (%d,%d,0)"
-                                ,i + 1, i / ntellers + 1);
+               snprintf(sql, 256, "insert into pgbench_tellers(tid,bid,tbalance) values (%d,%d,0)",
+                                i + 1, i / ntellers + 1);
                executeStatement(con, sql);
        }
 
@@ -1313,6 +1449,22 @@ process_commands(char *buf)
                                fprintf(stderr, "%s: extra argument \"%s\" ignored\n",
                                                my_commands->argv[0], my_commands->argv[j]);
                }
+               else if (pg_strcasecmp(my_commands->argv[0], "setshell") == 0)
+               {
+                       if (my_commands->argc < 3)
+                       {
+                               fprintf(stderr, "%s: missing argument\n", my_commands->argv[0]);
+                               return NULL;
+                       }
+               }
+               else if (pg_strcasecmp(my_commands->argv[0], "shell") == 0)
+               {
+                       if (my_commands->argc < 1)
+                       {
+                               fprintf(stderr, "%s: missing command\n", my_commands->argv[0]);
+                               return NULL;
+                       }
+               }
                else
                {
                        fprintf(stderr, "Invalid command %s\n", my_commands->argv[0]);

diff --git a/doc/src/sgml/pgbench.sgml b/doc/src/sgml/pgbench.sgml
index 0e6ae3f057e0d0968e4930d9acc988777cd1f758..a9cbfe0087880cb611e486acb53a56e7f51638f5 100644 (file)
--- a/doc/src/sgml/pgbench.sgml
+++ b/doc/src/sgml/pgbench.sgml
@@ -1,4 +1,4 @@
-<!-- $PostgreSQL: pgsql/doc/src/sgml/pgbench.sgml,v 1.10 2009/08/03 18:30:55 tgl Exp $ -->
+<!-- $PostgreSQL: pgsql/doc/src/sgml/pgbench.sgml,v 1.11 2009/12/15 07:17:57 itagaki Exp $ -->
 
 <sect1 id="pgbench">
  <title>pgbench</title>
@@ -466,6 +466,56 @@ pgbench <optional> <replaceable>options</> </optional> <replaceable>dbname</>
    </varlistentry>
   </variablelist>
 
+   <varlistentry>
+    <term>
+     <literal>\setshell <replaceable>varname</> <replaceable>command</> [ <replaceable>argument</> ... ]</literal>
+    </term>
+
+    <listitem>
+     <para>
+      Sets variable <replaceable>varname</> to the result of the shell command
+      <replaceable>command</>. The command must return an integer value
+      through its standard output.
+     </para>
+
+     <para>
+      <replaceable>argument</> can be either a text constant or a
+      <literal>:</><replaceable>variablename</> reference to a variable of
+      any types. If you want to use <replaceable>argument</> starting with
+      colons, you need to add an additional colon at the beginning of
+      <replaceable>argument</>.
+     </para>
+
+     <para>
+      Example:
+      <programlisting>
+\setshell variable_to_be_assigned command literal_argument :variable ::literal_starting_with_colon
+      </programlisting>
+     </para>
+    </listitem>
+   </varlistentry>
+  </variablelist>
+
+   <varlistentry>
+    <term>
+     <literal>\shell <replaceable>command</> [ <replaceable>argument</> ... ]</literal>
+    </term>
+
+    <listitem>
+     <para>
+      Same as <literal>\setshell</literal>, but the result is ignored.
+     </para>
+
+     <para>
+      Example:
+      <programlisting>
+\shell command literal_argument :variable ::literal_starting_with_colon
+      </programlisting>
+     </para>
+    </listitem>
+   </varlistentry>
+  </variablelist>
+
   <para>
    As an example, the full definition of the built-in TPC-B-like
    transaction is: