← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to client/drizzletest.cc

  • Committer: Olaf van der Spek
  • Date: 2011-06-16 13:26:51 UTC
  • mto: (2318.6.3 refactor7)
  • mto: This revision was merged to the branch mainline in revision 2340.
  • Revision ID: olafvdspek@gmail.com-20110616132651-v3lub102rdtuxs5u
Refactor

Show diffs side-by-side

added added

removed removed

Lines of Context:
client/drizzletest.cc
232
232
 
233
233
struct st_connection
234
234
{
235
 
  drizzle_st* drizzle;
 
235
  drizzle_st drizzle;
236
236
  drizzle_con_st con;
237
 
  char* name;
238
237
};
239
 
st_connection g_connections[128];
240
 
st_connection* cur_con= NULL, *next_con;
 
238
 
 
239
typedef map<string, st_connection*> connections_t;
 
240
connections_t g_connections;
 
241
st_connection* cur_con= NULL;
241
242
 
242
243
/*
243
244
  List of commands in drizzletest
819
820
}
820
821
 
821
822
 
822
 
static void close_connections()
823
 
{
824
 
  for (--next_con; next_con >= g_connections; --next_con)
825
 
  {
826
 
    if (next_con->drizzle != NULL)
827
 
    {
828
 
      drizzle_free(next_con->drizzle);
829
 
      next_con->drizzle= NULL;
830
 
    }
831
 
    free(next_con->name);
832
 
  }
833
 
}
834
 
 
835
 
 
836
823
static void close_files()
837
824
{
838
825
  for (; cur_file >= file_stack.data(); cur_file--)
846
833
 
847
834
static void free_used_memory()
848
835
{
849
 
  close_connections();
850
836
  close_files();
851
837
  BOOST_FOREACH(var_hash_t::reference i, var_hash)
852
838
  {
2680
2666
}
2681
2667
 
2682
2668
 
2683
 
static st_connection * find_connection_by_name(const char *name)
 
2669
static st_connection* find_connection_by_name(const char* name)
2684
2670
{
2685
 
  for (st_connection* con= g_connections; con < next_con; con++)
2686
 
  {
2687
 
    if (not strcmp(con->name, name))
2688
 
      return con;
2689
 
  }
2690
 
  return NULL;
 
2671
  return find_ptr2(g_connections, name);
2691
2672
}
2692
2673
 
2693
2674
 
3413
3394
 
3414
3395
static void do_close_connection(st_command* command)
3415
3396
{
3416
 
  char *p= command->first_argument, *name;
3417
 
  st_connection *con;
3418
 
 
 
3397
  char* p= command->first_argument;
3419
3398
  if (!*p)
3420
3399
    die("Missing connection name in disconnect");
3421
 
  name= p;
 
3400
  char* name= p;
3422
3401
  while (*p && !my_isspace(charset_info,*p))
3423
3402
    p++;
3424
3403
 
3426
3405
    *p++= 0;
3427
3406
  command->last_argument= p;
3428
3407
 
3429
 
  if (!(con= find_connection_by_name(name)))
 
3408
  st_connection* con= find_connection_by_name(name);
 
3409
  if (!con)
3430
3410
    die("connection '%s' not found in connection pool", name);
3431
 
 
3432
 
  if (con->drizzle != NULL)
3433
 
  {
3434
 
    drizzle_free(con->drizzle);
3435
 
    con->drizzle= NULL;
3436
 
  }
3437
 
  free(con->name);
3438
 
 
3439
 
  /*
3440
 
    When the connection is closed set name to "-closed_connection-"
3441
 
    to make it possible to reuse the connection name.
3442
 
  */
3443
 
  con->name = strdup("-closed_connection-");
 
3411
  g_connections.erase(name);
 
3412
  drizzle_free(&con->drizzle);
 
3413
  delete con;
3444
3414
}
3445
3415
 
3446
3416
 
3475
3445
{
3476
3446
  uint32_t failed_attempts= 0;
3477
3447
  static uint32_t connection_retry_sleep= 100000; /* Microseconds */
3478
 
  drizzle_return_t ret;
3479
3448
 
3480
3449
  drizzle_con_set_tcp(con, host.c_str(), port);
3481
3450
  drizzle_con_set_auth(con, user.c_str(), pass);
3482
3451
  drizzle_con_set_db(con, db.c_str());
3483
 
  while ((ret= drizzle_con_connect(con)) != DRIZZLE_RETURN_OK)
 
3452
  while (drizzle_return_t ret= drizzle_con_connect(con))
3484
3453
  {
3485
3454
    /*
3486
3455
      Connect failed
3494
3463
         ret == DRIZZLE_RETURN_COULD_NOT_CONNECT) &&
3495
3464
        failed_attempts < opt_max_connect_retries)
3496
3465
    {
3497
 
      verbose_msg("Connect attempt %d/%d failed: %d: %s", failed_attempts,
3498
 
                  opt_max_connect_retries, ret, drizzle_con_error(con));
 
3466
      verbose_msg("Connect attempt %d/%d failed: %d: %s", failed_attempts, opt_max_connect_retries, ret, drizzle_con_error(con));
3499
3467
      usleep(connection_retry_sleep);
3500
3468
    }
3501
3469
    else
3502
3470
    {
3503
3471
      if (failed_attempts > 0)
3504
 
        die("Could not open connection '%s' after %d attempts: %d %s", name,
3505
 
            failed_attempts, ret, drizzle_con_error(con));
 
3472
        die("Could not open connection '%s' after %d attempts: %d %s", name, failed_attempts, ret, drizzle_con_error(con));
3506
3473
      else
3507
 
        die("Could not open connection '%s': %d %s", name, ret,
3508
 
            drizzle_con_error(con));
 
3474
        die("Could not open connection '%s': %d %s", name, ret, drizzle_con_error(con));
3509
3475
    }
3510
3476
    failed_attempts++;
3511
3477
  }
3512
 
  return;
3513
3478
}
3514
3479
 
3515
3480
 
3685
3650
  if (find_connection_by_name(ds_connection_name.c_str()))
3686
3651
    die("Connection %s already exists", ds_connection_name.c_str());
3687
3652
 
3688
 
  st_connection* con_slot;
3689
 
  if (next_con != g_connections + sizeof(g_connections) / sizeof(st_connection) - 1)
3690
 
  {
3691
 
    con_slot= next_con;
3692
 
  }
3693
 
  else if (!(con_slot= find_connection_by_name("-closed_connection-")))
3694
 
    die("Connection limit exhausted, you can have max %d connections", (int) (sizeof(g_connections)/sizeof(st_connection)));
 
3653
  st_connection* con_slot= new st_connection;
3695
3654
 
3696
 
  if ((con_slot->drizzle= drizzle_create(NULL)) == NULL)
 
3655
  if (not drizzle_create(&con_slot->drizzle))
3697
3656
    die("Failed on drizzle_create()");
3698
 
  if (!drizzle_con_create(con_slot->drizzle, &con_slot->con))
 
3657
  if (not drizzle_con_create(&con_slot->drizzle, &con_slot->con))
3699
3658
    die("Failed on drizzle_con_create()");
3700
3659
  drizzle_con_add_options(&con_slot->con, use_drizzle_protocol ? DRIZZLE_CON_EXPERIMENTAL : DRIZZLE_CON_MYSQL);
3701
3660
 
3710
3669
  if (connect_n_handle_errors(command, &con_slot->con, ds_host.c_str(), ds_user.c_str(), 
3711
3670
    ds_password.c_str(), ds_database.c_str(), con_port, ds_sock.c_str()))
3712
3671
  {
3713
 
    con_slot->name= strdup(ds_connection_name.c_str());
 
3672
    g_connections[ds_connection_name]= con_slot;
3714
3673
    cur_con= con_slot;
3715
 
 
3716
 
    if (con_slot == next_con)
3717
 
      next_con++; /* if we used the next_con slot, advance the pointer */
3718
3674
  }
3719
3675
 
3720
3676
  /* Update $drizzleclient_get_server_version to that of current connection */
5223
5179
  /* Init expected errors */
5224
5180
  memset(&saved_expected_errors, 0, sizeof(saved_expected_errors));
5225
5181
 
5226
 
  /* Init g_connections */
5227
 
  memset(g_connections, 0, sizeof(g_connections));
5228
 
  next_con= g_connections + 1;
5229
 
 
5230
5182
  /* Init file stack */
5231
5183
  memset(file_stack.data(), 0, sizeof(file_stack));
5232
5184
  cur_file= file_stack.data();
5375
5327
    cur_file->file_name= strdup("<stdin>");
5376
5328
    cur_file->lineno= 1;
5377
5329
  }
5378
 
  cur_con= g_connections;
5379
 
  if ((cur_con->drizzle= drizzle_create(NULL)) == NULL)
 
5330
  cur_con= new st_connection;
 
5331
  if (not drizzle_create(&cur_con->drizzle))
5380
5332
    die("Failed in drizzle_create()");
5381
 
  if (!( drizzle_con_create(cur_con->drizzle, &cur_con->con)))
 
5333
  if (not drizzle_con_create(&cur_con->drizzle, &cur_con->con))
5382
5334
    die("Failed in drizzle_con_create()");
5383
5335
  drizzle_con_add_options(&cur_con->con, use_drizzle_protocol ? DRIZZLE_CON_EXPERIMENTAL : DRIZZLE_CON_MYSQL);
5384
5336
 
5385
 
  cur_con->name = strdup("default");
5386
 
  safe_connect(&cur_con->con, cur_con->name, opt_host, opt_user, opt_pass,
5387
 
               opt_db, opt_port);
 
5337
  safe_connect(&cur_con->con, "default", opt_host, opt_user, opt_pass, opt_db, opt_port);
 
5338
  g_connections["default"] = cur_con;
5388
5339
 
5389
5340
  fill_global_error_names();
5390
5341