← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to client/drizzledump_drizzle.cc

  • 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

Show diffs side-by-side

added added

removed removed

Lines of Context:
client/drizzledump_drizzle.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_drizzle.h"
 
22
#include "client_priv.h"
 
23
#include <string>
 
24
#include <iostream>
 
25
#include <drizzled/gettext.h>
 
26
#include <boost/lexical_cast.hpp>
 
27
 
 
28
extern drizzle_con_st dcon;
 
29
 
 
30
bool DrizzleDumpDatabaseDrizzle::populateTables()
 
31
{
 
32
  drizzle_result_st result;
 
33
  drizzle_row_t row;
 
34
  drizzle_return_t ret;
 
35
  std::string query;
 
36
 
 
37
  if (drizzle_select_db(&dcon, &result, databaseName.c_str(), &ret) == 
 
38
    NULL || ret != DRIZZLE_RETURN_OK)
 
39
  {
 
40
    errmsg << _("Could not set db '") << databaseName << "'";
 
41
    return false;
 
42
  }
 
43
  drizzle_result_free(&result);
 
44
 
 
45
  query="SELECT TABLE_NAME, TABLE_COLLATION, ENGINE FROM DATA_DICTIONARY.TABLES WHERE TABLE_SCHEMA='";
 
46
  query.append(databaseName);
 
47
  query.append("' ORDER BY TABLE_NAME");
 
48
 
 
49
  if (drizzle_query_str(&dcon, &result, query.c_str(), &ret) == NULL ||
 
50
      ret != DRIZZLE_RETURN_OK)
 
51
  {
 
52
    if (ret == DRIZZLE_RETURN_ERROR_CODE)
 
53
    {
 
54
      errmsg << _("Could not get tables list due to error: ") <<
 
55
        drizzle_result_error(&result);
 
56
      drizzle_result_free(&result);
 
57
    }
 
58
    else
 
59
    {
 
60
      errmsg << _("Could not get tables list due to error: ") <<
 
61
        drizzle_con_error(&dcon);
 
62
    }
 
63
    return false;
 
64
  }
 
65
 
 
66
  if (drizzle_result_buffer(&result) != DRIZZLE_RETURN_OK)
 
67
  {
 
68
    errmsg << _("Could not get tables list due to error: ") <<
 
69
        drizzle_con_error(&dcon);
 
70
    return false;
 
71
  }
 
72
 
 
73
  while ((row= drizzle_row_next(&result)))
 
74
  {
 
75
    std::string tableName(row[0]);
 
76
    DrizzleDumpTable *table = new DrizzleDumpTableDrizzle(tableName);
 
77
    table->collate= row[1];
 
78
    table->engineName= row[2];
 
79
    table->autoIncrement= 0;
 
80
    table->database= this;
 
81
    table->populateFields();
 
82
    table->populateIndexes();
 
83
    tables.push_back(table);
 
84
  }
 
85
 
 
86
  drizzle_result_free(&result);
 
87
 
 
88
  return true;
 
89
}
 
90
 
 
91
void DrizzleDumpDatabaseDrizzle::setCollate(const char* newCollate)
 
92
{
 
93
  if (newCollate)
 
94
    collate= newCollate;
 
95
  else
 
96
    collate= "utf8_general_ci";
 
97
}
 
98
 
 
99
bool DrizzleDumpTableDrizzle::populateFields()
 
100
{
 
101
  drizzle_result_st result;
 
102
  drizzle_row_t row;
 
103
  drizzle_return_t ret;
 
104
  std::string query;
 
105
 
 
106
  query= "SELECT COLUMN_NAME, DATA_TYPE, COLUMN_DEFAULT, COLUMN_DEFAULT_IS_NULL, IS_NULLABLE, CHARACTER_MAXIMUM_LENGTH, NUMERIC_PRECISION, NUMERIC_SCALE, COLLATION_NAME, IS_AUTO_INCREMENT, ENUM_VALUES FROM DATA_DICTIONARY.COLUMNS WHERE TABLE_SCHEMA='";
 
107
  query.append(database->databaseName);
 
108
  query.append("' AND TABLE_NAME='");
 
109
  query.append(tableName);
 
110
  query.append("' ORDER BY ORDINAL_POSITION");
 
111
 
 
112
  if (drizzle_query_str(&dcon, &result, query.c_str(), &ret) == NULL ||
 
113
      ret != DRIZZLE_RETURN_OK)
 
114
  {
 
115
    if (ret == DRIZZLE_RETURN_ERROR_CODE)
 
116
    {
 
117
      errmsg << _("Could not get tables list due to error: ") <<
 
118
        drizzle_result_error(&result);
 
119
      drizzle_result_free(&result);
 
120
    }
 
121
    else
 
122
    {
 
123
      errmsg << _("Could not get tables list due to error: ") <<
 
124
        drizzle_con_error(&dcon);
 
125
    }
 
126
    return false;
 
127
  }
 
128
 
 
129
  if (drizzle_result_buffer(&result) != DRIZZLE_RETURN_OK)
 
130
  {
 
131
    errmsg << _("Could not get tables list due to error: ") <<
 
132
        drizzle_con_error(&dcon);
 
133
    return false;
 
134
  }
 
135
  while ((row= drizzle_row_next(&result)))
 
136
  {
 
137
    std::string fieldName(row[0]);
 
138
    DrizzleDumpField *field = new DrizzleDumpFieldDrizzle(fieldName);
 
139
    /* Stop valgrind warning */
 
140
    field->convertDateTime= false;
 
141
    /* Also sets collation */
 
142
    field->setType(row[1], row[8]);
 
143
    if (row[2])
 
144
      field->defaultValue= row[2];
 
145
    else
 
146
      field->defaultValue= "";
 
147
 
 
148
    field->isNull= (strcmp(row[4], "YES") == 0) ? true : false;
 
149
    field->isAutoIncrement= (strcmp(row[9], "YES") == 0) ? true : false;
 
150
    field->defaultIsNull= (strcmp(row[3], "YES") == 0) ? true : false;
 
151
    field->enumValues= (row[10]) ? row[10] : "";
 
152
    field->length= (row[5]) ? boost::lexical_cast<uint32_t>(row[5]) : 0;
 
153
    field->decimalPrecision= (row[6]) ? boost::lexical_cast<uint32_t>(row[6]) : 0;
 
154
    field->decimalScale= (row[7]) ? boost::lexical_cast<uint32_t>(row[7]) : 0;
 
155
 
 
156
 
 
157
    fields.push_back(field);
 
158
  }
 
159
 
 
160
  drizzle_result_free(&result);
 
161
  return true;
 
162
}
 
163
 
 
164
 
 
165
bool DrizzleDumpTableDrizzle::populateIndexes()
 
166
{
 
167
  drizzle_result_st result;
 
168
  drizzle_row_t row;
 
169
  drizzle_return_t ret;
 
170
  std::string query;
 
171
  std::string lastKey;
 
172
  bool firstIndex= true;
 
173
  DrizzleDumpIndex *index;
 
174
 
 
175
  query= "SELECT INDEX_NAME, COLUMN_NAME, IS_USED_IN_PRIMARY, IS_UNIQUE FROM DATA_DICTIONARY.INDEX_PARTS WHERE TABLE_NAME='";
 
176
  query.append(tableName);
 
177
  query.append("'");
 
178
 
 
179
  if (drizzle_query_str(&dcon, &result, query.c_str(), &ret) == NULL ||
 
180
      ret != DRIZZLE_RETURN_OK)
 
181
  {
 
182
    if (ret == DRIZZLE_RETURN_ERROR_CODE)
 
183
    {
 
184
      errmsg << _("Could not get tables list due to error: ") <<
 
185
        drizzle_result_error(&result);
 
186
      drizzle_result_free(&result);
 
187
    }
 
188
    else
 
189
    {
 
190
      errmsg << _("Could not get tables list due to error: ") <<
 
191
        drizzle_con_error(&dcon);
 
192
    }
 
193
    return false;
 
194
  }
 
195
 
 
196
  if (drizzle_result_buffer(&result) != DRIZZLE_RETURN_OK)
 
197
  {
 
198
    errmsg << _("Could not get tables list due to error: ") <<
 
199
        drizzle_con_error(&dcon);
 
200
    return false;
 
201
  }
 
202
  while ((row= drizzle_row_next(&result)))
 
203
  {
 
204
    std::string indexName(row[0]);
 
205
    if (indexName.compare(lastKey) != 0)
 
206
    {
 
207
      if (!firstIndex)
 
208
        indexes.push_back(index);
 
209
      index = new DrizzleDumpIndexDrizzle(indexName);
 
210
      index->isPrimary= (strcmp(row[0], "PRIMARY") == 0);
 
211
      index->isUnique= (strcmp(row[3], "YES") == 0);
 
212
      index->isHash= 0;
 
213
      lastKey= row[0];
 
214
      firstIndex= false;
 
215
    }
 
216
    index->columns.push_back(row[1]);
 
217
  }
 
218
  if (!firstIndex)
 
219
    indexes.push_back(index);
 
220
 
 
221
  drizzle_result_free(&result);
 
222
  return true;
 
223
}
 
224
 
 
225
DrizzleDumpData* DrizzleDumpTableDrizzle::getData(void)
 
226
{
 
227
  return new DrizzleDumpDataDrizzle(this);
 
228
}
 
229
 
 
230
 
 
231
void DrizzleDumpFieldDrizzle::setType(const char* raw_type, const char* raw_collation)
 
232
{
 
233
  collation= raw_collation;
 
234
  if (strcmp(raw_type, "BLOB") == 0)
 
235
  {
 
236
    if (strcmp(raw_collation, "binary") != 0)
 
237
      type= "TEXT";
 
238
    else
 
239
      type= raw_type;
 
240
    return;
 
241
  }
 
242
 
 
243
  if (strcmp(raw_type, "VARCHAR") == 0)
 
244
  {
 
245
    if (strcmp(raw_collation, "binary") != 0)
 
246
      type= "VARCHAR";
 
247
    else
 
248
      type= "VARBINARY";
 
249
    return;
 
250
  }
 
251
 
 
252
  if (strcmp(raw_type, "INTEGER") == 0)
 
253
  {
 
254
    type= "INT";
 
255
    return;
 
256
  }
 
257
 
 
258
  type= raw_type;
 
259
}
 
260
 
 
261
DrizzleDumpDataDrizzle::DrizzleDumpDataDrizzle(DrizzleDumpTable *dataTable) :
 
262
 DrizzleDumpData(dataTable)
 
263
{
 
264
  drizzle_return_t ret;
 
265
  std::string query;
 
266
  query= "SELECT * FROM `";
 
267
  query.append(table->tableName);
 
268
  query.append("`");
 
269
  result= new drizzle_result_st;
 
270
 
 
271
  if (drizzle_query_str(&dcon, result, query.c_str(), &ret) == NULL ||
 
272
      ret != DRIZZLE_RETURN_OK)
 
273
  {
 
274
    if (ret == DRIZZLE_RETURN_ERROR_CODE)
 
275
    {
 
276
      errmsg << _("Could not get tables list due to error: ") <<
 
277
        drizzle_result_error(result);
 
278
      drizzle_result_free(result);
 
279
    }
 
280
    else
 
281
    {
 
282
      errmsg << _("Could not get tables list due to error: ") <<
 
283
        drizzle_con_error(&dcon);
 
284
    }
 
285
    return;
 
286
  }
 
287
 
 
288
  if (drizzle_result_buffer(result) != DRIZZLE_RETURN_OK)
 
289
  {
 
290
    errmsg << _("Could not get tables list due to error: ") <<
 
291
        drizzle_con_error(&dcon);
 
292
    return;
 
293
  }
 
294
}
 
295
 
 
296
DrizzleDumpDataDrizzle::~DrizzleDumpDataDrizzle()
 
297
{
 
298
  drizzle_result_free(result);
 
299
  if (result) delete result;
 
300
}