docs: private static boolean executesAsSimpleDirective(String line) throws Exception {
  
          // SHOW or LIST <blah> statement
          String subcommand = SQLParser.parseShowStatementSubcommand(line);
          if (subcommand != null) {
              if (subcommand.equals("proc") || subcommand.equals("procedures")) {
                  execListProcedures();
              }
              else if (subcommand.equals("functions")) {
                  execListFunctions();
              }
              else if (subcommand.equals("tables")) {
                  execListTables();
              }
              else if (subcommand.equals("classes")) {
                  execListClasses();
              }
              else if (subcommand.equals("config") || subcommand.equals("configuration")) {
                  execListConfigurations();
              }
              else {
                  String errorCase = (subcommand.equals("") || subcommand.equals(";")) ?
                          ("Incomplete SHOW command.\n") :
                          ("Invalid SHOW command completion: '" + subcommand + "'.\n");
                  System.out.println(errorCase +
                          "The valid SHOW command completions are proc, procedures, tables, or classes.");
              }
              // Consider it handled here, whether or not it was a good SHOW statement.
              return true;
          }
  
          // HELP commands - ONLY in interactive mode, close batch and parse for execution
          // Parser returns null if it isn't a HELP command. If no arguments are specified
          // the returned string will be empty.
          String helpSubcommand = SQLParser.parseHelpStatement(line);
          if (helpSubcommand != null) {
              // Ignore the arguments for now.
              if (!helpSubcommand.isEmpty()) {
                  System.out.printf("Ignoring extra HELP argument(s): %s\n", helpSubcommand);
              }
              printHelp(System.out); // Print readme to the screen
              return true;
          }
  
          String echoArgs = SQLParser.parseEchoStatement(line);
          if (echoArgs != null) {
              System.out.println(echoArgs);
              return true;
          }
  
          String echoErrorArgs = SQLParser.parseEchoErrorStatement(line);
          if (echoErrorArgs != null) {
              System.err.println(echoErrorArgs);
              return true;
          }
  
          // DESCRIBE table
          String describeArgs = SQLParser.parseDescribeStatement(line);
          if (describeArgs != null) {
  
              // Check if table exists
              String tableName = "";
              String type = "";
              VoltTable tableData = m_client.callProcedure("@SystemCatalog", "TABLES").getResults()[0];
              while (tableData.advanceRow()) {
                  String t = tableData.getString(2);
                  if (t.equalsIgnoreCase(describeArgs)) {
                      tableName = t;
                      type = tableData.getString(3);
                      break;
                  }
              }
              if (tableName.equals("")) {
                  System.err.println("Table does not exist");
                  return true;
              }
  
              // Class to temporarily store and sort column attributes
              class Column implements Comparable {
                  String name;
                  String type;
                  long size;
                  String remarks;
                  long position;
                  String notNull;
  
                  @Override
                  public String toString() {return "";}
  
                  @Override
                  public int compareTo(Object obj) {
                      Column col = (Column) obj;
                      return (int)(this.position - col.position);
                  }
              }
  
              // sort the columns as they are inserted
              SortedSet set = new TreeSet();
  
              // Retrieve Column attributes
              VoltTable columnData = m_client.callProcedure("@SystemCatalog", "COLUMNS").getResults()[0];
              int maxNameWidth = 10;
              while (columnData.advanceRow()) {
                  if (tableName.equalsIgnoreCase(columnData.getString(2))) {
  
                      Column c = new Column();
                      c.name = columnData.getString(3);
                      if (c.name.length() > maxNameWidth) {
                          maxNameWidth = c.name.length();
                      }
  
                      c.type = columnData.getString(5);
  
                      c.size = columnData.getLong(6);
                      if (columnData.wasNull()) {
                          if (c.type.equals("GEOGRAPHY")) {
                              c.size = 32768;
                          }
                          if (c.type.equals("GEOGRAPHY_POINT")) {
                              c.size = 16;
                          }
                      } else if (c.type.equals("TINYINT")) {
                          c.size = 1;
                      } else if (c.type.equals("SMALLINT")) {
                          c.size = 2;
                      } else if (c.type.equals("INTEGER")) {
                          c.size = 4;
                      } else if (c.type.equals("BIGINT")) {
                          c.size = 8;
                      } else if (c.type.equals("FLOAT")) {
                          c.size = 8;
                      } else if (c.type.equals("DECIMAL")) {
                          c.size = 16;
                      } else if (c.type.equals("TIMESTAMP")) {
                          c.size = 8;
                      }
  
                      c.remarks = columnData.getString(11);
                      if (columnData.wasNull()) {
                          c.remarks = "";
                      }
  
                      c.position = columnData.getLong(16);
  
                      String nullableYesNo = columnData.getString(17);
                      c.notNull = "";
                      if (nullableYesNo.equals("NO")) {
                          c.notNull = "NOT NULL";
                      }
  
                      set.add(c);
                  }
              }
  
              // print output
              String headerFormat = "%-" + maxNameWidth + "s|%-16s|%-11s|%-9s|%-16s\n";
              String rowFormat = "%-" + maxNameWidth + "s|%-16s|%11d|%-9s|%-16s\n";
              System.out.printf(headerFormat,"COLUMN","DATATYPE","SIZE","NULLABLE","REMARKS");
              String DASHES = new String(new char[56+maxNameWidth]).replace("\0", "-");
              System.out.println(DASHES);
  
              Iterator it = set.iterator();
              while (it.hasNext()) {
                  Column c = (Column)it.next();
                  System.out.printf(rowFormat,c.name,c.type,c.size,c.notNull,c.remarks);
              }
              System.out.println(DASHES);
  
              // primary key
              String primaryKey = "";
              VoltTable keyData = m_client.callProcedure("@SystemCatalog", "PRIMARYKEYS").getResults()[0];
              while (keyData.advanceRow()) {
                  if (tableName.equalsIgnoreCase(keyData.getString(2))) {
                      String colName = keyData.getString(3);
                      if (!primaryKey.equals("")) {
                          primaryKey += ",";
                      }
                      primaryKey += colName;
                  }
              }
              if (!primaryKey.equals("")) {
                  System.out.println("Type: " + type + ", Primary Key (" + primaryKey + ")");
              } else {
                  System.out.println("Type: " + type);
              }
              return true;
          }
  
          // It wasn't a locally-interpreted directive.
          return false;
      }