« back to all changes in this revision
Viewing changes to client/drizzledump_mysql.cc
- browse files at revision 1751.4.19
- compare with another revision
- compare with revision 2241.3.11
- download diff
- download tarball
- view history from revision 1751.4.19
- Committer: Andrew Hutchings
- Date: 2010-09-22 19:58:16 UTC
- mto: (1792.1.1 build)
- mto: This revision was merged to the branch mainline in revision 1793.
- Revision ID: andrew@linuxjedi.co.uk-20100922195816-uc3aud8va2sxponn
Put drizzle and mysql processes in seperate classes/files
added
removed
client/drizzledump_mysql.cc
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
*
4
* Copyright (C) 2010 Andrew Hutchings
5
*
6
* This program is free software; you can redistribute it and/or modify
7
* it under the terms of the GNU General Public License as published by
8
* the Free Software Foundation; version 2 of the License.
9
*
10
* This program is distributed in the hope that it will be useful,
11
* but WITHOUT ANY WARRANTY; without even the implied warranty of
12
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13
* GNU General Public License for more details.
14
*
15
* You should have received a copy of the GNU General Public License
16
* along with this program; if not, write to the Free Software
17
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18
*/
19
20
#include "drizzledump_data.h"
21
#include "drizzledump_mysql.h"
22
#include "client_priv.h"
23
#include <string>
24
#include <iostream>
25
#include <boost/regex.hpp>
26
#include <boost/date_time/posix_time/posix_time.hpp>
27
#include <drizzled/gettext.h>
28
29
extern drizzle_con_st dcon;
30
31
32
bool DrizzleDumpDatabaseMySQL::populateTables()
33
{
34
drizzle_result_st result;
35
drizzle_row_t row;
36
drizzle_return_t ret;
37
std::string query;
38
39
if (drizzle_select_db(&dcon, &result, databaseName.c_str(), &ret) ==
40
NULL || ret != DRIZZLE_RETURN_OK)
41
{
42
errmsg << _("Could not set db '") << databaseName << "'";
43
return false;
44
}
45
drizzle_result_free(&result);
46
47
query="SELECT TABLE_NAME, TABLE_COLLATION, ENGINE, AUTO_INCREMENT FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA='";
48
query.append(databaseName);
49
query.append("' ORDER BY TABLE_NAME");
50
51
if (drizzle_query_str(&dcon, &result, query.c_str(), &ret) == NULL ||
52
ret != DRIZZLE_RETURN_OK)
53
{
54
if (ret == DRIZZLE_RETURN_ERROR_CODE)
55
{
56
errmsg << _("Could not get tables list due to error: ") <<
57
drizzle_result_error(&result);
58
drizzle_result_free(&result);
59
}
60
else
61
{
62
errmsg << _("Could not get tables list due to error: ") <<
63
drizzle_con_error(&dcon);
64
}
65
return false;
66
}
67
68
if (drizzle_result_buffer(&result) != DRIZZLE_RETURN_OK)
69
{
70
errmsg << _("Could not get tables list due to error: ") <<
71
drizzle_con_error(&dcon);
72
return false;
73
}
74
75
while ((row= drizzle_row_next(&result)))
76
{
77
std::string tableName(row[0]);
78
DrizzleDumpTableMySQL *table = new DrizzleDumpTableMySQL(tableName);
79
table->setCollate(row[1]);
80
table->setEngine(row[2]);
81
if (row[3])
82
table->autoIncrement= boost::lexical_cast<uint64_t>(row[3]);
83
else
84
table->autoIncrement= 0;
85
86
table->database= this;
87
table->populateFields();
88
table->populateIndexes();
89
tables.push_back(table);
90
}
91
92
drizzle_result_free(&result);
93
94
return true;
95
}
96
97
bool DrizzleDumpTableMySQL::populateFields()
98
{
99
drizzle_result_st result;
100
drizzle_row_t row;
101
drizzle_return_t ret;
102
std::string query;
103
104
query="SELECT COLUMN_NAME, COLUMN_TYPE, COLUMN_DEFAULT, IS_NULLABLE, CHARACTER_MAXIMUM_LENGTH, NUMERIC_PRECISION, NUMERIC_SCALE, COLLATION_NAME, EXTRA FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA='";
105
query.append(database->databaseName);
106
query.append("' AND TABLE_NAME='");
107
query.append(tableName);
108
query.append("' ORDER BY ORDINAL_POSITION");
109
110
if (drizzle_query_str(&dcon, &result, query.c_str(), &ret) == NULL ||
111
ret != DRIZZLE_RETURN_OK)
112
{
113
if (ret == DRIZZLE_RETURN_ERROR_CODE)
114
{
115
errmsg << _("Could not get tables list due to error: ") <<
116
drizzle_result_error(&result);
117
drizzle_result_free(&result);
118
}
119
else
120
{
121
errmsg << _("Could not get tables list due to error: ") <<
122
drizzle_con_error(&dcon);
123
}
124
return false;
125
}
126
127
if (drizzle_result_buffer(&result) != DRIZZLE_RETURN_OK)
128
{
129
errmsg << _("Could not get tables list due to error: ") <<
130
drizzle_con_error(&dcon);
131
return false;
132
}
133
while ((row= drizzle_row_next(&result)))
134
{
135
std::string fieldName(row[0]);
136
DrizzleDumpFieldMySQL *field = new DrizzleDumpFieldMySQL(fieldName);
137
/* Stop valgrind warning */
138
field->convertDateTime= false;
139
/* Also sets collation */
140
field->setType(row[1], row[8]);
141
if (row[2])
142
{
143
if (field->convertDateTime)
144
{
145
field->dateTimeConvert(row[2]);
146
}
147
else
148
field->defaultValue= row[2];
149
}
150
else
151
field->defaultValue= "";
152
153
field->isNull= (strcmp(row[3], "YES") == 0) ? true : false;
154
field->isAutoIncrement= (strcmp(row[8], "auto_increment") == 0) ? true : false;
155
field->defaultIsNull= field->isNull;
156
field->length= (row[4]) ? boost::lexical_cast<uint32_t>(row[4]) : 0;
157
field->decimalPrecision= (row[5]) ? boost::lexical_cast<uint32_t>(row[5]) : 0;
158
field->decimalScale= (row[6]) ? boost::lexical_cast<uint32_t>(row[6]) : 0;
159
160
161
fields.push_back(field);
162
}
163
164
drizzle_result_free(&result);
165
return true;
166
}
167
168
169
void DrizzleDumpFieldMySQL::dateTimeConvert(const char* oldDefault)
170
{
171
boost::match_flag_type flags = boost::match_default;
172
173
if (strcmp(oldDefault, "CURRENT_TIMESTAMP") == 0)
174
{
175
defaultValue= oldDefault;
176
return;
177
}
178
179
if (type.compare("INT") == 0)
180
{
181
/* We were a TIME, now we are an INT */
182
std::string ts(oldDefault);
183
boost::posix_time::time_duration td(boost::posix_time::duration_from_string(ts));
184
defaultValue= boost::lexical_cast<std::string>(td.total_seconds());
185
return;
186
}
187
188
boost::regex date_regex("([0-9]{3}[1-9]-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01]))");
189
190
if (regex_search(oldDefault, date_regex, flags))
191
{
192
defaultValue= oldDefault;
193
}
194
else
195
{
196
defaultIsNull= true;
197
defaultValue="";
198
}
199
}
200
201
202
bool DrizzleDumpTableMySQL::populateIndexes()
203
{
204
drizzle_result_st result;
205
drizzle_row_t row;
206
drizzle_return_t ret;
207
std::string query;
208
std::string lastKey;
209
bool firstIndex= true;
210
DrizzleDumpIndex *index;
211
212
query="SHOW INDEXES FROM ";
213
query.append(tableName);
214
215
if (drizzle_query_str(&dcon, &result, query.c_str(), &ret) == NULL ||
216
ret != DRIZZLE_RETURN_OK)
217
{
218
if (ret == DRIZZLE_RETURN_ERROR_CODE)
219
{
220
errmsg << _("Could not get tables list due to error: ") <<
221
drizzle_result_error(&result);
222
drizzle_result_free(&result);
223
}
224
else
225
{
226
errmsg << _("Could not get tables list due to error: ") <<
227
drizzle_con_error(&dcon);
228
}
229
return false;
230
}
231
232
if (drizzle_result_buffer(&result) != DRIZZLE_RETURN_OK)
233
{
234
errmsg << _("Could not get tables list due to error: ") <<
235
drizzle_con_error(&dcon);
236
return false;
237
}
238
while ((row= drizzle_row_next(&result)))
239
{
240
std::string indexName(row[2]);
241
if (indexName.compare(lastKey) != 0)
242
{
243
if (strcmp(row[10], "FULLTEXT") == 0)
244
continue;
245
246
if (!firstIndex)
247
indexes.push_back(index);
248
index = new DrizzleDumpIndexMySQL(indexName);
249
index->isPrimary= (strcmp(row[2], "PRIMARY") == 0);
250
index->isUnique= (strcmp(row[1], "0") == 0);
251
index->isHash= (strcmp(row[10], "HASH") == 0);
252
lastKey= row[2];
253
firstIndex= false;
254
}
255
index->columns.push_back(row[4]);
256
}
257
if (!firstIndex)
258
indexes.push_back(index);
259
260
drizzle_result_free(&result);
261
return true;
262
}
263
264
void DrizzleDumpFieldMySQL::setType(const char* raw_type, const char* raw_collation)
265
{
266
std::string old_type(raw_type);
267
std::string extra;
268
size_t pos;
269
270
if ((pos= old_type.find("(")) != std::string::npos)
271
{
272
extra= old_type.substr(pos);
273
old_type.erase(pos, std::string::npos);
274
}
275
276
std::transform(old_type.begin(), old_type.end(), old_type.begin(), ::toupper);
277
if ((old_type.find("CHAR") != std::string::npos) or
278
(old_type.find("TEXT") != std::string::npos))
279
setCollate(raw_collation);
280
281
if ((old_type.compare("INT") == 0) and
282
((extra.find("unsigned") != std::string::npos)))
283
{
284
type= "BIGINT";
285
return;
286
}
287
288
if ((old_type.compare("TINYINT") == 0) or
289
(old_type.compare("SMALLINT") == 0) or
290
(old_type.compare("MEDIUMINT") == 0))
291
{
292
type= "INT";
293
return;
294
}
295
296
if ((old_type.compare("TINYBLOB") == 0) or
297
(old_type.compare("MEDIUMBLOB") == 0) or
298
(old_type.compare("LONGBLOB") == 0))
299
{
300
type= "BLOB";
301
return;
302
}
303
304
if ((old_type.compare("TINYTEXT") == 0) or
305
(old_type.compare("MEDIUMTEXT") == 0) or
306
(old_type.compare("LONGTEXT") == 0))
307
{
308
type= "TEXT";
309
return;
310
}
311
312
if (old_type.compare("CHAR") == 0)
313
{
314
type= "VARCHAR";
315
return;
316
}
317
318
if (old_type.compare("BINARY") == 0)
319
{
320
type= "VARBINARY";
321
return;
322
}
323
324
if (old_type.compare("ENUM") == 0)
325
{
326
type= old_type;
327
/* Strip out the braces, we add them again during output */
328
enumValues= extra.substr(1, extra.length()-2);
329
return;
330
}
331
332
if ((old_type.find("TIME") != std::string::npos) or
333
(old_type.find("DATE") != std::string::npos))
334
{
335
/* Intended to catch TIME/DATE/TIMESTAMP/DATETIME
336
We may have a default TIME/DATE which needs converting */
337
convertDateTime= true;
338
}
339
340
if (old_type.compare("TIME") == 0)
341
{
342
type= "INT";
343
return;
344
}
345
346
if (old_type.compare("FLOAT") == 0)
347
{
348
type= "DOUBLE";
349
return;
350
}
351
352
type= old_type;
353
return;
354
}
355
356
void DrizzleDumpTableMySQL::setEngine(const char* newEngine)
357
{
358
if (strcmp(newEngine, "MyISAM") == 0)
359
engineName= "InnoDB";
360
else
361
engineName= newEngine;
362
}
363
364
DrizzleDumpData* DrizzleDumpTableMySQL::getData(void)
365
{
366
return new DrizzleDumpDataMySQL(this);
367
}
368
369
void DrizzleDumpDatabaseMySQL::setCollate(const char* newCollate)
370
{
371
if (newCollate)
372
{
373
std::string tmpCollate(newCollate);
374
if (tmpCollate.find("utf8") != std::string::npos)
375
{
376
collate= tmpCollate;
377
return;
378
}
379
}
380
collate= "utf8_general_ci";
381
}
382
383
void DrizzleDumpTableMySQL::setCollate(const char* newCollate)
384
{
385
if (newCollate)
386
{
387
std::string tmpCollate(newCollate);
388
if (tmpCollate.find("utf8") != std::string::npos)
389
{
390
collate= tmpCollate;
391
return;
392
}
393
}
394
395
collate= "utf8_general_ci";
396
}
397
398
void DrizzleDumpFieldMySQL::setCollate(const char* newCollate)
399
{
400
if (newCollate)
401
{
402
std::string tmpCollate(newCollate);
403
if (tmpCollate.find("utf8") != std::string::npos)
404
{
405
collation= tmpCollate;
406
return;
407
}
408
}
409
collation= "utf8_general_ci";
410
}
411
412
DrizzleDumpDataMySQL::DrizzleDumpDataMySQL(DrizzleDumpTable *dataTable) :
413
DrizzleDumpData(dataTable)
414
{
415
drizzle_return_t ret;
416
std::string query;
417
query= "SELECT * FROM `";
418
query.append(table->tableName);
419
query.append("`");
420
result= new drizzle_result_st;
421
422
if (drizzle_query_str(&dcon, result, query.c_str(), &ret) == NULL ||
423
ret != DRIZZLE_RETURN_OK)
424
{
425
if (ret == DRIZZLE_RETURN_ERROR_CODE)
426
{
427
errmsg << _("Could not get tables list due to error: ") <<
428
drizzle_result_error(result);
429
drizzle_result_free(result);
430
}
431
else
432
{
433
errmsg << _("Could not get tables list due to error: ") <<
434
drizzle_con_error(&dcon);
435
}
436
return;
437
}
438
439
if (drizzle_result_buffer(result) != DRIZZLE_RETURN_OK)
440
{
441
errmsg << _("Could not get tables list due to error: ") <<
442
drizzle_con_error(&dcon);
443
return;
444
}
445
}
446
447
DrizzleDumpDataMySQL::~DrizzleDumpDataMySQL()
448
{
449
drizzle_result_free(result);
450
if (result) delete result;
451
}
452
453
long DrizzleDumpDataMySQL::convertTime(const char* oldTime) const
454
{
455
std::string ts(oldTime);
456
boost::posix_time::time_duration td(boost::posix_time::duration_from_string(ts));
457
long seconds= td.total_seconds();
458
return seconds;
459
}
460
461
std::string DrizzleDumpDataMySQL::convertDate(const char* oldDate) const
462
{
463
boost::match_flag_type flags = boost::match_default;
464
std::string output;
465
boost::regex date_regex("([0-9]{3}[1-9]-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01]))");
466
467
if (regex_search(oldDate, date_regex, flags))
468
{
469
output.push_back('\'');
470
output.append(oldDate);
471
output.push_back('\'');
472
}
473
else
474
output= "NULL";
475
476
return output;
477
}
478
479
std::ostream& DrizzleDumpDataMySQL::checkDateTime(std::ostream &os, const char* item, uint32_t field) const
480
{
481
if (table->fields[field]->convertDateTime)
482
{
483
if (table->fields[field]->type.compare("INT") == 0)
484
os << convertTime(item);
485
else
486
os << convertDate(item);
487
}
488
return os;
489
}
490
Loggerhead is a web-based interface for Breezy
Version: 2.0.1