← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to client/drizzledump.cc

  • Committer: Andrew Hutchings
  • Date: 2010-09-17 13:41:39 UTC
  • mto: (1792.1.1 build)
  • mto: This revision was merged to the branch mainline in revision 1793.
  • Revision ID: andrew@linuxjedi.co.uk-20100917134139-gbarymj3woyxau7v
Rip out internal namespace dependancy and add boost::date_time

Show diffs side-by-side

added added

removed removed

Lines of Context:
client/drizzledump.cc
33
33
#include "client_priv.h"
34
34
#include <string>
35
35
#include <iostream>
36
 
#include "drizzled/internal/my_sys.h"
37
 
#include "drizzled/internal/m_string.h"
38
 
#include "drizzled/charset_info.h"
39
36
#include <stdarg.h>
40
37
#include <boost/unordered_set.hpp>
41
38
#include <algorithm>
815
812
    {
816
813
      if (opt_dump_date)
817
814
      {
818
 
        char time_str[20];
819
 
        internal::get_date(time_str, GETDATE_DATE_TIME, 0);
 
815
        boost::posix_time::ptime time(boost::posix_time::second_clock::local_time());
820
816
        fprintf(sql_file, "-- Dump completed on %s\n",
821
 
                time_str);
 
817
          boost::posix_time::to_simple_string(time).c_str());
822
818
      }
823
819
      else
824
820
        fprintf(sql_file, "-- Dump completed\n");
1009
1005
  if (md_result_file && md_result_file != stdout)
1010
1006
    fclose(md_result_file);
1011
1007
  opt_password.erase();
1012
 
  internal::my_end();
1013
1008
}
1014
1009
 
1015
1010
 
1079
1074
  drizzle_free(&drizzle);
1080
1075
} /* dbDisconnect */
1081
1076
 
1082
 
/*
1083
 
  Quote a table name so it can be used in "SHOW TABLES LIKE <tabname>"
1084
 
 
1085
 
  SYNOPSIS
1086
 
  quote_for_like()
1087
 
  name     name of the table
1088
 
  buff     quoted name of the table
1089
 
 
1090
 
  DESCRIPTION
1091
 
  Quote \, _, ' and % characters
1092
 
 
1093
 
Note: Because DRIZZLE uses the C escape syntax in strings
1094
 
(for example, '\n' to represent newline), you must double
1095
 
any '\' that you use in your LIKE  strings. For example, to
1096
 
search for '\n', specify it as '\\n'. To search for '\', specify
1097
 
it as '\\\\' (the backslashes are stripped once by the parser
1098
 
and another time when the pattern match is done, leaving a
1099
 
single backslash to be matched).
1100
 
 
1101
 
Example: "t\1" => "t\\\\1"
1102
 
 
1103
 
*/
1104
 
static char *quote_for_like(const char *name, char *buff)
1105
 
{
1106
 
  char *to= buff;
1107
 
  *to++= '\'';
1108
 
  while (*name)
1109
 
  {
1110
 
    if (*name == '\\')
1111
 
    {
1112
 
      *to++='\\';
1113
 
      *to++='\\';
1114
 
      *to++='\\';
1115
 
    }
1116
 
    else if (*name == '\'' || *name == '_'  || *name == '%')
1117
 
      *to++= '\\';
1118
 
    *to++= *name++;
1119
 
  }
1120
 
  to[0]= '\'';
1121
 
  to[1]= 0;
1122
 
  return buff;
1123
 
}
1124
 
 
1125
1077
static int dump_all_databases()
1126
1078
{
1127
1079
  drizzle_row_t row;
1210
1162
}
1211
1163
 
1212
1164
 
1213
 
/*
1214
 
  SYNOPSIS
1215
 
 
1216
 
  Check if we the table is one of the table types that should be ignored:
1217
 
  MRG_ISAM, MRG_MYISAM, if opt_delayed, if that table supports delayed inserts.
1218
 
  If the table should be altogether ignored, it returns a true, false if it
1219
 
  should not be ignored. If the user has selected to use INSERT DELAYED, it
1220
 
  sets the value of the bool pointer supports_delayed_inserts to 0 if not
1221
 
  supported, 1 if it is supported.
1222
 
 
1223
 
  ARGS
1224
 
 
1225
 
  check_if_ignore_table()
1226
 
  table_name                  Table name to check
1227
 
  table_type                  Type of table
1228
 
 
1229
 
  GLOBAL VARIABLES
1230
 
  drizzle                       Drizzle connection
1231
 
  verbose                     Write warning messages
1232
 
 
1233
 
  RETURN
1234
 
  char (bit value)            See IGNORE_ values at top
1235
 
*/
1236
 
 
1237
 
char check_if_ignore_table(const char *table_name, char *table_type)
1238
 
{
1239
 
  char result= IGNORE_NONE;
1240
 
  char buff[FN_REFLEN+80], show_name_buff[FN_REFLEN];
1241
 
  //const char *number_of_rows= NULL;
1242
 
  drizzle_result_st res;
1243
 
  drizzle_row_t row;
1244
 
 
1245
 
  /* Check memory for quote_for_like() */
1246
 
  assert(2*sizeof(table_name) < sizeof(show_name_buff));
1247
 
  snprintf(buff, sizeof(buff), "show table status like %s",
1248
 
           quote_for_like(table_name, show_name_buff));
1249
 
  if (drizzleclient_query_with_error_report(&dcon, &res, buff, false))
1250
 
  {
1251
 
    return result;
1252
 
  }
1253
 
  if (!(row= drizzle_row_next(&res)))
1254
 
  {
1255
 
    fprintf(stderr,
1256
 
            _("Error: Couldn't read status information for table %s\n"),
1257
 
            table_name);
1258
 
    drizzle_result_free(&res);
1259
 
    return(result);                         /* assume table is ok */
1260
 
  }
1261
 
  else
1262
 
  {
1263
 
//    if ((number_of_rows= fetch_named_row(&res, row, "Rows")) != NULL)
1264
 
//    {
1265
 
//      total_rows= strtoul(number_of_rows, NULL, 10);
1266
 
//    }
1267
 
  }
1268
 
  /*
1269
 
    If the table type matches any of these, we do support delayed inserts.
1270
 
    Note-> we do not want to skip dumping this table if if is not one of
1271
 
    these types, but we do want to use delayed inserts in the dump if
1272
 
    the table type is _NOT_ one of these types
1273
 
  */
1274
 
  {
1275
 
    strncpy(table_type, row[1], DRIZZLE_MAX_TABLE_SIZE-1);
1276
 
    if (opt_delayed)
1277
 
    {
1278
 
      if (strcmp(table_type,"MyISAM") &&
1279
 
          strcmp(table_type,"ARCHIVE") &&
1280
 
          strcmp(table_type,"HEAP") &&
1281
 
          strcmp(table_type,"MEMORY"))
1282
 
        result= IGNORE_INSERT_DELAYED;
1283
 
    }
1284
 
  }
1285
 
  drizzle_result_free(&res);
1286
 
  return(result);
1287
 
}
1288
 
 
1289
1165
int get_server_type()
1290
1166
{
1291
1167
  boost::match_flag_type flags = boost::match_default;