/**
   * Create and execute a stored procedure as root.
   */
  async rootTransaction(body: string): Promise<void> {
    // Hash proc body to get a unique proc name.
    // This makes sure we have a unique name for each proc operation.
    const name = this.getProcedureName(body);
    const transactionQuery = `
      CREATE PROCEDURE \`${name}\`()
      BEGIN
          DECLARE CONTINUE HANDLER FOR SQLEXCEPTION
          BEGIN
            ROLLBACK;
            RESIGNAL;
          END;
          START TRANSACTION;
          ${body}
          COMMIT;
      END;`;

    // Ensure root.
    await this.ensureRootConnection();

    // Here we'll try to create the proc, but if the proc name
    // already exists we can be sure it's the same operation
    // so we will trap the error and call the pre-defined proc.
    try {
      await this.rootConn.query(transactionQuery);
    } catch (err) {
      // If proc already exists, we are good to go.
      if (err.code !== 'ER_SP_ALREADY_EXISTS') {
        throw err;
      }
    }

    // Attempting to call proc.
    await this.callProc(name);
  }

 /**
  * Close all connections to the database.
  */
 endConnection(): void {
   console.log(this.pool.end);
   if (this.pool) {
     this.pool.end().catch((e: any) => console.error(e));
     this.pool = null;
   }
   if (this.rootConn) {
     this.rootConn.destroy();
     this.rootConn = null;
   }
 }

 /**
  * Execute a regular query on the root connection.
  */
 async rootQuery(sql: string): Promise<any> {
   await this.ensureRootConnection();
   return this.rootConn.query(sql);
 }

 /**
  * Execute a prepared statement on the root connection.
  */
 async rootExec(sql: string, values?: any[]): Promise<any> {
   values = values || [];
   await this.ensureRootConnection();
   return this.rootConn.execute(sql, values);
 }

 /**
  * Call a stored procedure by procedure name generated in getProcedureName.
  */
 async callProc(name: string): Promise<any> {
   return this.rootConn.query(`CALL \`${name}\``);
 }