← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to client/drizzleslap.cc

Merge Monty

Show diffs side-by-side

added added

removed removed

Lines of Context:
client/drizzleslap.cc
97
97
#include <drizzled/gettext.h>
98
98
 
99
99
using namespace std;
 
100
using namespace drizzled;
100
101
 
101
102
#ifdef HAVE_SMEM
102
103
static char *shared_memory_base_name=0;
103
104
#endif
104
105
 
105
 
extern "C"
106
 
bool get_one_option(int optid, const struct my_option *, char *argument);
107
 
 
108
106
/* Global Thread counter */
109
107
uint32_t thread_counter;
110
108
pthread_mutex_t counter_mutex;
325
323
  option_string *eptr;
326
324
  unsigned int x;
327
325
 
328
 
  my_init();
 
326
  internal::my_init();
329
327
 
330
328
  MY_INIT(argv[0]);
331
329
 
332
 
  load_defaults("drizzle",load_default_groups,&argc,&argv);
 
330
  internal::load_defaults("drizzle",load_default_groups,&argc,&argv);
333
331
  defaults_argv=argv;
334
332
  if (get_options(&argc,&argv))
335
333
  {
336
 
    free_defaults(defaults_argv);
337
 
    my_end();
 
334
    internal::free_defaults(defaults_argv);
 
335
    internal::my_end();
338
336
    exit(1);
339
337
  }
340
338
 
351
349
 
352
350
  if (argc > 2)
353
351
  {
354
 
    fprintf(stderr,"%s: Too many arguments\n",my_progname);
355
 
    free_defaults(defaults_argv);
356
 
    my_end();
 
352
    fprintf(stderr,"%s: Too many arguments\n",internal::my_progname);
 
353
    internal::free_defaults(defaults_argv);
 
354
    internal::my_end();
357
355
    exit(1);
358
356
  }
359
357
 
428
426
  if (shared_memory_base_name)
429
427
    free(shared_memory_base_name);
430
428
#endif
431
 
  free_defaults(defaults_argv);
432
 
  my_end();
 
429
  internal::free_defaults(defaults_argv);
 
430
  internal::my_end();
433
431
 
434
432
  return 0;
435
433
}
711
709
 
712
710
static void print_version(void)
713
711
{
714
 
  printf("%s  Ver %s Distrib %s, for %s-%s (%s)\n",my_progname, SLAP_VERSION,
 
712
  printf("%s  Ver %s Distrib %s, for %s-%s (%s)\n",internal::my_progname, SLAP_VERSION,
715
713
         drizzle_version(),HOST_VENDOR,HOST_OS,HOST_CPU);
716
714
}
717
715
 
724
722
       \nand you are welcome to modify and redistribute it under the GPL \
725
723
       license\n");
726
724
  puts("Run a query multiple times against the server\n");
727
 
  printf("Usage: %s [OPTIONS]\n",my_progname);
728
 
  print_defaults("drizzle",load_default_groups);
 
725
  printf("Usage: %s [OPTIONS]\n",internal::my_progname);
 
726
  internal::print_defaults("drizzle",load_default_groups);
729
727
  my_print_help(my_long_options);
730
728
}
731
729
 
732
 
bool get_one_option(int optid, const struct my_option *, char *argument)
 
730
static bool get_one_option(int optid, const struct my_option *, char *argument)
733
731
{
734
732
  char *endchar= NULL;
735
733
  uint64_t temp_drizzle_port= 0;
1298
1296
  {
1299
1297
    fprintf(stderr,
1300
1298
            "%s: Can't use --auto-generate-sql when create and query strings are specified!\n",
1301
 
            my_progname);
 
1299
            internal::my_progname);
1302
1300
    exit(1);
1303
1301
  }
1304
1302
 
1307
1305
  {
1308
1306
    fprintf(stderr,
1309
1307
            "%s: Either auto-generate-sql-guid-primary or auto-generate-sql-add-autoincrement can be used!\n",
1310
 
            my_progname);
 
1308
            internal::my_progname);
1311
1309
    exit(1);
1312
1310
  }
1313
1311
 
1315
1313
  {
1316
1314
    fprintf(stderr,
1317
1315
            "%s: Either auto-generate-sql-execute-number or number-of-queries can be used!\n",
1318
 
            my_progname);
 
1316
            internal::my_progname);
1319
1317
    exit(1);
1320
1318
  }
1321
1319
 
1335
1333
                          S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) == -1)
1336
1334
      {
1337
1335
        fprintf(stderr,"%s: Could not open csv file: %sn\n",
1338
 
                my_progname, opt_csv_str);
 
1336
                internal::my_progname, opt_csv_str);
1339
1337
        exit(1);
1340
1338
      }
1341
1339
    }
1456
1454
        {
1457
1455
          fprintf(stderr,
1458
1456
                  "%s: Can't perform key test without a primary key!\n",
1459
 
                  my_progname);
 
1457
                  internal::my_progname);
1460
1458
          exit(1);
1461
1459
        }
1462
1460
 
1492
1490
        {
1493
1491
          fprintf(stderr,
1494
1492
                  "%s: Can't perform update test without a primary key!\n",
1495
 
                  my_progname);
 
1493
                  internal::my_progname);
1496
1494
          exit(1);
1497
1495
        }
1498
1496
 
1540
1538
      if (!S_ISREG(sbuf.st_mode))
1541
1539
      {
1542
1540
        fprintf(stderr,"%s: Create file was not a regular file\n",
1543
 
                my_progname);
 
1541
                internal::my_progname);
1544
1542
        exit(1);
1545
1543
      }
1546
1544
      if ((data_file= open(create_string, O_RDWR)) == -1)
1547
1545
      {
1548
 
        fprintf(stderr,"%s: Could not open create file\n", my_progname);
 
1546
        fprintf(stderr,"%s: Could not open create file\n", internal::my_progname);
1549
1547
        exit(1);
1550
1548
      }
1551
1549
      if ((uint64_t)(sbuf.st_size + 1) > SIZE_MAX)
1597
1595
      if (!S_ISREG(sbuf.st_mode))
1598
1596
      {
1599
1597
        fprintf(stderr,"%s: User query supplied file was not a regular file\n",
1600
 
                my_progname);
 
1598
                internal::my_progname);
1601
1599
        exit(1);
1602
1600
      }
1603
1601
      if ((data_file= open(user_supplied_query, O_RDWR)) == -1)
1604
1602
      {
1605
 
        fprintf(stderr,"%s: Could not open query supplied file\n", my_progname);
 
1603
        fprintf(stderr,"%s: Could not open query supplied file\n", internal::my_progname);
1606
1604
        exit(1);
1607
1605
      }
1608
1606
      if ((uint64_t)(sbuf.st_size + 1) > SIZE_MAX)
1644
1642
    if (!S_ISREG(sbuf.st_mode))
1645
1643
    {
1646
1644
      fprintf(stderr,"%s: User query supplied file was not a regular file\n",
1647
 
              my_progname);
 
1645
              internal::my_progname);
1648
1646
      exit(1);
1649
1647
    }
1650
1648
    if ((data_file= open(user_supplied_pre_statements, O_RDWR)) == -1)
1651
1649
    {
1652
 
      fprintf(stderr,"%s: Could not open query supplied file\n", my_progname);
 
1650
      fprintf(stderr,"%s: Could not open query supplied file\n", internal::my_progname);
1653
1651
      exit(1);
1654
1652
    }
1655
1653
    if ((uint64_t)(sbuf.st_size + 1) > SIZE_MAX)
1691
1689
    if (!S_ISREG(sbuf.st_mode))
1692
1690
    {
1693
1691
      fprintf(stderr,"%s: User query supplied file was not a regular file\n",
1694
 
              my_progname);
 
1692
              internal::my_progname);
1695
1693
      exit(1);
1696
1694
    }
1697
1695
    if ((data_file= open(user_supplied_post_statements, O_RDWR)) == -1)
1698
1696
    {
1699
 
      fprintf(stderr,"%s: Could not open query supplied file\n", my_progname);
 
1697
      fprintf(stderr,"%s: Could not open query supplied file\n", internal::my_progname);
1700
1698
      exit(1);
1701
1699
    }
1702
1700
 
1811
1809
  {
1812
1810
    if (run_query(con, &result, "SELECT id from t1", strlen("SELECT id from t1")))
1813
1811
    {
1814
 
      fprintf(stderr,"%s: Cannot select GUID primary keys. (%s)\n", my_progname,
 
1812
      fprintf(stderr,"%s: Cannot select GUID primary keys. (%s)\n", internal::my_progname,
1815
1813
              drizzle_con_error(con));
1816
1814
      exit(1);
1817
1815
    }
1894
1892
 
1895
1893
  if (run_query(con, NULL, query, len))
1896
1894
  {
1897
 
    fprintf(stderr,"%s: Cannot create schema %s : %s\n", my_progname, db,
 
1895
    fprintf(stderr,"%s: Cannot create schema %s : %s\n", internal::my_progname, db,
1898
1896
            drizzle_con_error(con));
1899
1897
    exit(1);
1900
1898
  }
1918
1916
    if (drizzle_select_db(con,  &result, db, &ret) == NULL ||
1919
1917
        ret != DRIZZLE_RETURN_OK)
1920
1918
    {
1921
 
      fprintf(stderr,"%s: Cannot select schema '%s': %s\n",my_progname, db,
 
1919
      fprintf(stderr,"%s: Cannot select schema '%s': %s\n",internal::my_progname, db,
1922
1920
              ret == DRIZZLE_RETURN_ERROR_CODE ?
1923
1921
              drizzle_result_error(&result) : drizzle_con_error(con));
1924
1922
      exit(1);
1933
1931
                  engine_stmt->string);
1934
1932
    if (run_query(con, NULL, query, len))
1935
1933
    {
1936
 
      fprintf(stderr,"%s: Cannot set default engine: %s\n", my_progname,
 
1934
      fprintf(stderr,"%s: Cannot set default engine: %s\n", internal::my_progname,
1937
1935
              drizzle_con_error(con));
1938
1936
      exit(1);
1939
1937
    }
1958
1956
      if (run_query(con, NULL, buffer, strlen(buffer)))
1959
1957
      {
1960
1958
        fprintf(stderr,"%s: Cannot run query %.*s ERROR : %s\n",
1961
 
                my_progname, (uint32_t)ptr->length, ptr->string, drizzle_con_error(con));
 
1959
                internal::my_progname, (uint32_t)ptr->length, ptr->string, drizzle_con_error(con));
1962
1960
        if (!opt_ignore_sql_errors)
1963
1961
          exit(1);
1964
1962
      }
1969
1967
      if (run_query(con, NULL, ptr->string, ptr->length))
1970
1968
      {
1971
1969
        fprintf(stderr,"%s: Cannot run query %.*s ERROR : %s\n",
1972
 
                my_progname, (uint32_t)ptr->length, ptr->string, drizzle_con_error(con));
 
1970
                internal::my_progname, (uint32_t)ptr->length, ptr->string, drizzle_con_error(con));
1973
1971
        if (!opt_ignore_sql_errors)
1974
1972
          exit(1);
1975
1973
      }
2002
2000
  if (run_query(con, NULL, query, len))
2003
2001
  {
2004
2002
    fprintf(stderr,"%s: Cannot drop database '%s' ERROR : %s\n",
2005
 
            my_progname, db, drizzle_con_error(con));
 
2003
            internal::my_progname, db, drizzle_con_error(con));
2006
2004
    exit(1);
2007
2005
  }
2008
2006
 
2021
2019
    if (run_query(con, NULL, ptr->string, ptr->length))
2022
2020
    {
2023
2021
      fprintf(stderr,"%s: Cannot run query %.*s ERROR : %s\n",
2024
 
              my_progname, (uint32_t)ptr->length, ptr->string, drizzle_con_error(con));
 
2022
              internal::my_progname, (uint32_t)ptr->length, ptr->string, drizzle_con_error(con));
2025
2023
      exit(1);
2026
2024
    }
2027
2025
  }
2085
2083
        if (pthread_create(&mainthread, &attr, run_task,
2086
2084
                           (void *)con) != 0)
2087
2085
        {
2088
 
          fprintf(stderr,"%s: Could not create thread\n", my_progname);
 
2086
          fprintf(stderr,"%s: Could not create thread\n", internal::my_progname);
2089
2087
          exit(1);
2090
2088
        }
2091
2089
        thread_counter++;
2105
2103
    if (pthread_create(&mainthread, &attr, timer_thread,
2106
2104
                       (void *)&opt_timer_length) != 0)
2107
2105
    {
2108
 
      fprintf(stderr,"%s: Could not create timer thread\n", my_progname);
 
2106
      fprintf(stderr,"%s: Could not create timer thread\n", internal::my_progname);
2109
2107
      exit(1);
2110
2108
    }
2111
2109
  }
2246
2244
        if (run_query(&con, &result, buffer, length))
2247
2245
        {
2248
2246
          fprintf(stderr,"%s: Cannot run query %.*s ERROR : %s\n",
2249
 
                  my_progname, (uint32_t)length, buffer, drizzle_con_error(&con));
 
2247
                  internal::my_progname, (uint32_t)length, buffer, drizzle_con_error(&con));
2250
2248
          exit(1);
2251
2249
        }
2252
2250
      }
2256
2254
      if (run_query(&con, &result, ptr->string, ptr->length))
2257
2255
      {
2258
2256
        fprintf(stderr,"%s: Cannot run query %.*s ERROR : %s\n",
2259
 
                my_progname, (uint32_t)ptr->length, ptr->string, drizzle_con_error(&con));
 
2257
                internal::my_progname, (uint32_t)ptr->length, ptr->string, drizzle_con_error(&con));
2260
2258
        exit(1);
2261
2259
      }
2262
2260
    }
2577
2575
           con->real_users, /* Children used max_timing */
2578
2576
           con->avg_rows  /* Queries run */
2579
2577
           );
2580
 
  my_write(csv_file, (unsigned char*) buffer, (uint32_t)strlen(buffer), MYF(0));
 
2578
  internal::my_write(csv_file, (unsigned char*) buffer, (uint32_t)strlen(buffer), MYF(0));
2581
2579
}
2582
2580
 
2583
2581
void
2700
2698
                          connect_to_schema ? create_schema_string : NULL,
2701
2699
                          opt_mysql ? DRIZZLE_CON_MYSQL : DRIZZLE_CON_NONE) == NULL)
2702
2700
  {
2703
 
    fprintf(stderr,"%s: Error creating drizzle object\n", my_progname);
 
2701
    fprintf(stderr,"%s: Error creating drizzle object\n", internal::my_progname);
2704
2702
    exit(1);
2705
2703
  }
2706
2704
 
2716
2714
  }
2717
2715
  if (connect_error)
2718
2716
  {
2719
 
    fprintf(stderr,"%s: Error when connecting to server: %d %s\n", my_progname,
 
2717
    fprintf(stderr,"%s: Error when connecting to server: %d %s\n", internal::my_progname,
2720
2718
            ret, drizzle_con_error(con));
2721
2719
    exit(1);
2722
2720
  }