�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2F'>mariadb-11.7.2</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Ftests%2F'>tests</a>/</p><hr><h3>✏️ Editing: async_queries.c</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/*
  Copyright 2011 Kristian Nielsen and Monty Program Ab.

  This file is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this.  If not, see &lt;http://www.gnu.org/licenses/&gt;.
*/


/*
  Run a set of queries in parallel against a server using the non-blocking
  API, and compare to running same queries with the normal blocking API.
*/

#include &lt;my_global.h&gt;
#include &lt;my_sys.h&gt;
#include &lt;mysql.h&gt;
#include &lt;my_getopt.h&gt;

#include &lt;sys/time.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;stdio.h&gt;
#include &lt;string.h&gt;

#include &lt;event.h&gt;


#define SL(s) (s), sizeof(s)
static const char *my_groups[]= { &quot;client&quot;, NULL };

/* Maintaining a list of queries to run. */
struct query_entry {
  struct query_entry *next;
  char *query;
  int index;
};
static struct query_entry *query_list;
static struct query_entry **tail_ptr= &amp;query_list;
static int query_counter= 0;


/* State kept for each connection. */
struct state_data {
  int ST;                                    /* State machine current state */
  struct event ev_mysql;
  MYSQL mysql;
  MYSQL_RES *result;
  MYSQL *ret;
  int err;
  MYSQL_ROW row;
  struct query_entry *query_element;
  int index;
};


static const char *opt_db= NULL;
static const char *opt_user= NULL;
static const char *opt_password= NULL;
static int tty_password= 0;
static const char *opt_host= NULL;
static const char *opt_socket= NULL;
static unsigned int opt_port= 0;
static unsigned int opt_connections= 5;
static const char *opt_query_file= NULL;

static struct my_option options[] =
{
  {&quot;database&quot;, &#039;D&#039;, &quot;Database to use&quot;, &amp;opt_db, &amp;opt_db,
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {&quot;help&quot;, &#039;?&#039;, &quot;Display this help and exit&quot;, 0, 0, 0, GET_NO_ARG, NO_ARG, 0,
   0, 0, 0, 0, 0},
  {&quot;host&quot;, &#039;h&#039;, &quot;Connect to host&quot;, &amp;opt_host, &amp;opt_host,
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {&quot;password&quot;, &#039;p&#039;,
   &quot;Password to use when connecting to server. If password is not given it&#039;s asked from the tty.&quot;,
   0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
  {&quot;port&quot;, &#039;P&#039;, &quot;Port number to use for connection.&quot;,
   &amp;opt_port, &amp;opt_port, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {&quot;socket&quot;, &#039;S&#039;, &quot;Socket file to use for connection&quot;,
   &amp;opt_socket, &amp;opt_socket, 0, GET_STR,
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {&quot;user&quot;, &#039;u&#039;, &quot;User for login if not current user&quot;, &amp;opt_user,
   &amp;opt_user, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {&quot;connections&quot;, &#039;n&#039;, &quot;Number of simultaneous connections/queries.&quot;,
   &amp;opt_connections, &amp;opt_connections, 0, GET_UINT, REQUIRED_ARG,
   5, 0, 0, 0, 0, 0},
  {&quot;queryfile&quot;, &#039;q&#039;, &quot;Name of file containing extra queries to run&quot;,
   &amp;opt_query_file, &amp;opt_query_file, 0, GET_STR, REQUIRED_ARG,
   0, 0, 0, 0, 0, 0},
  { 0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
};

static void
fatal(struct state_data *sd, const char *msg)
{
  fprintf(stderr, &quot;%s: %s\n&quot;, msg, (sd ? mysql_error(&amp;sd-&gt;mysql) : &quot;&quot;));
  exit(1);
}


static void state_machine_handler(int fd, short event, void *arg);

static void
next_event(int new_st, int status, struct state_data *sd)
{
  short wait_event= 0;
  struct timeval tv, *ptv;
  int fd;

  if (status &amp; MYSQL_WAIT_READ)
    wait_event|= EV_READ;
  if (status &amp; MYSQL_WAIT_WRITE)
    wait_event|= EV_WRITE;
  if (wait_event)
    fd= mysql_get_socket(&amp;sd-&gt;mysql);
  else
    fd= -1;
  if (status &amp; MYSQL_WAIT_TIMEOUT)
  {
    tv.tv_sec= mysql_get_timeout_value(&amp;sd-&gt;mysql);
    tv.tv_usec= 0;
    ptv= &amp;tv;
  }
  else
    ptv= NULL;
  event_set(&amp;sd-&gt;ev_mysql, fd, wait_event, state_machine_handler, sd);
  event_add(&amp;sd-&gt;ev_mysql, ptv);
  sd-&gt;ST= new_st;
}

static int
mysql_status(short event)
{
  int status= 0;
  if (event &amp; EV_READ)
    status|= MYSQL_WAIT_READ;
  if (event &amp; EV_WRITE)
    status|= MYSQL_WAIT_WRITE;
  if (event &amp; EV_TIMEOUT)
    status|= MYSQL_WAIT_TIMEOUT;
  return status;
}


static int num_active_connections;

/* Shortcut for going to new state immediately without waiting. */
#define NEXT_IMMEDIATE(sd_, new_st) do { sd_-&gt;ST= new_st; goto again; } while (0)

static void
state_machine_handler(int fd __attribute__((unused)), short event, void *arg)
{
  struct state_data *sd= arg;
  int status;

again:
  switch(sd-&gt;ST)
  {
  case 0:
    /* Initial state, start making the connection. */
    status= mysql_real_connect_start(&amp;sd-&gt;ret, &amp;sd-&gt;mysql, opt_host, opt_user, opt_password, opt_db, opt_port, opt_socket, 0);
    if (status)
      /* Wait for connect to complete. */
      next_event(1, status, sd);
    else
      NEXT_IMMEDIATE(sd, 9);
    break;

  case 1:
    status= mysql_real_connect_cont(&amp;sd-&gt;ret, &amp;sd-&gt;mysql, mysql_status(event));
    if (status)
      next_event(1, status, sd);
    else
      NEXT_IMMEDIATE(sd, 9);
    break;

  case 9:
    if (!sd-&gt;ret)
      fatal(sd, &quot;Failed to mysql_real_connect()&quot;);
    NEXT_IMMEDIATE(sd, 10);
    break;

  case 10:
    /* Now run the next query. */
    sd-&gt;query_element= query_list;
    if (!sd-&gt;query_element)
    {
      /* No more queries, end the connection. */
      NEXT_IMMEDIATE(sd, 40);
    }
    query_list= query_list-&gt;next;

    sd-&gt;index= sd-&gt;query_element-&gt;index;
    printf(&quot;%d ! %s\n&quot;, sd-&gt;index, sd-&gt;query_element-&gt;query);
    status= mysql_real_query_start(&amp;sd-&gt;err, &amp;sd-&gt;mysql, sd-&gt;query_element-&gt;query,
                                   strlen(sd-&gt;query_element-&gt;query));
    if (status)
      next_event(11, status, sd);
    else
      NEXT_IMMEDIATE(sd, 20);
    break;

  case 11:
    status= mysql_real_query_cont(&amp;sd-&gt;err, &amp;sd-&gt;mysql, mysql_status(event));
    if (status)
      next_event(11, status, sd);
    else
      NEXT_IMMEDIATE(sd, 20);
    break;

  case 20:
    my_free(sd-&gt;query_element-&gt;query);
    my_free(sd-&gt;query_element);
    if (sd-&gt;err)
    {
      printf(&quot;%d | Error: %s\n&quot;, sd-&gt;index, mysql_error(&amp;sd-&gt;mysql));
      NEXT_IMMEDIATE(sd, 10);
    }
    else
    {
      sd-&gt;result= mysql_use_result(&amp;sd-&gt;mysql);
      if (!sd-&gt;result)
        fatal(sd, &quot;mysql_use_result() returns error&quot;);
      NEXT_IMMEDIATE(sd, 30);
    }
    break;

  case 30:
    status= mysql_fetch_row_start(&amp;sd-&gt;row, sd-&gt;result);
    if (status)
      next_event(31, status, sd);
    else
      NEXT_IMMEDIATE(sd, 39);
    break;

  case 31:
    status= mysql_fetch_row_cont(&amp;sd-&gt;row, sd-&gt;result, mysql_status(event));
    if (status)
      next_event(31, status, sd);
    else
      NEXT_IMMEDIATE(sd, 39);
    break;

  case 39:
    if (sd-&gt;row)
    {
      /* Got a row. */
      unsigned int i;
      printf(&quot;%d - &quot;, sd-&gt;index);
      for (i= 0; i &lt; mysql_num_fields(sd-&gt;result); i++)
        printf(&quot;%s%s&quot;, (i ? &quot;\t&quot; : &quot;&quot;), (sd-&gt;row[i] ? sd-&gt;row[i] : &quot;(null)&quot;));
      printf (&quot;\n&quot;);
      NEXT_IMMEDIATE(sd, 30);
    }
    else
    {
      if (mysql_errno(&amp;sd-&gt;mysql))
      {
        /* An error occurred. */
        printf(&quot;%d | Error: %s\n&quot;, sd-&gt;index, mysql_error(&amp;sd-&gt;mysql));
      }
      else
      {
        /* EOF. */
        printf(&quot;%d | EOF\n&quot;, sd-&gt;index);
      }
      mysql_free_result(sd-&gt;result);
      NEXT_IMMEDIATE(sd, 10);
    }
    break;

  case 40:
    status= mysql_close_start(&amp;sd-&gt;mysql);
    if (status)
      next_event(41, status, sd);
    else
      NEXT_IMMEDIATE(sd, 50);
    break;

  case 41:
    status= mysql_close_cont(&amp;sd-&gt;mysql, mysql_status(event));
    if (status)
      next_event(41, status, sd);
    else
      NEXT_IMMEDIATE(sd, 50);
    break;

  case 50:
    /* We are done! */
    num_active_connections--;
    if (num_active_connections == 0)
      event_loopbreak();
    break;

  default:
    abort();
  }
}


void
add_query(const char *q)
{
  struct query_entry *e;
  char *q2;
  size_t len;

  e= my_malloc(PSI_NOT_INSTRUMENTED, sizeof(*e), MYF(0));
  q2= my_strdup(PSI_NOT_INSTRUMENTED, q, MYF(0));
  if (!e || !q2)
    fatal(NULL, &quot;Out of memory&quot;);

  /* Remove any trailing newline. */
  len= strlen(q2);
  if (q2[len] == &#039;\n&#039;)
    q2[len--]= &#039;\0&#039;;
  if (q2[len] == &#039;\r&#039;)
    q2[len--]= &#039;\0&#039;;

  e-&gt;next= NULL;
  e-&gt;query= q2;
  e-&gt;index= query_counter++;
  *tail_ptr= e;
  tail_ptr= &amp;e-&gt;next;
}


static my_bool
handle_option(const struct my_option *opt, const char *arg,
              const char *filename __attribute__((unused)))
{
  switch (opt-&gt;id)
  {
  case &#039;?&#039;:
    printf(&quot;Usage: async_queries [OPTIONS] query ...\n&quot;);
    my_print_help(options);
    my_print_variables(options);
    exit(0);
    break;

  case &#039;p&#039;:
    if (arg)
      opt_password= arg;
    else
      tty_password= 1;
    break;
  }

  return 0;
}

PRAGMA_DISABLE_CHECK_STACK_FRAME

int
main(int argc, char *argv[])
{
  struct state_data *sds;
  unsigned int i;
  int err;
  struct event_base *libevent_base;

  err= handle_options(&amp;argc, &amp;argv, options, handle_option);
  if (err)
    exit(err);
  if (tty_password)
    opt_password= my_get_tty_password(NullS);

  if (opt_query_file)
  {
    FILE *f= fopen(opt_query_file, &quot;r&quot;);
    char buf[65536];
    if (!f)
      fatal(NULL, &quot;Cannot open query file&quot;);
    while (!feof(f))
    {
      if (!fgets(buf, sizeof(buf), f))
        break;
      add_query(buf);
    }
    fclose(f);
  }
  /* Add extra queries directly on command line. */
  while (argc &gt; 0)
  {
    --argc;
    add_query(*argv++);
  }

  sds= my_malloc(PSI_NOT_INSTRUMENTED, opt_connections * sizeof(*sds), MYF(0));
  if (!sds)
    fatal(NULL, &quot;Out of memory&quot;);

  libevent_base= event_init();

  err= mysql_library_init(argc, argv, (char **)my_groups);
  if (err)
  {
    fprintf(stderr, &quot;Fatal: mysql_library_init() returns error: %d\n&quot;, err);
    exit(1);
  }

  num_active_connections= 0;
  for (i= 0; i &lt; opt_connections; i++)
  {
    mysql_init(&amp;sds[i].mysql);
    mysql_options(&amp;sds[i].mysql, MYSQL_OPT_NONBLOCK, 0);
    mysql_options(&amp;sds[i].mysql, MYSQL_READ_DEFAULT_GROUP, &quot;async_queries&quot;);

    /*
      We put the initial connect call in the first state 0 of the state machine
      and run that manually, just to have everything in one place.
    */
    sds[i].ST= 0;
    num_active_connections++;
    state_machine_handler(-1, -1, &amp;sds[i]);
  }

  event_dispatch();

  my_free(sds);

  mysql_library_end();

  event_base_free(libevent_base);

  return 0;
}
PRAGMA_REENABLE_CHECK_STACK_FRAME
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Ftests'>🔙 Back</a></p>