~drizzle-trunk/drizzle/development

query="SELECT TABLE_NAME, TABLE_COLLATION, ENGINE, AUTO_INCREMENT, TABLE_COMMENT FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE != 'VIEW' AND TABLE_SCHEMA='";

query="SELECT TABLE_NAME, TABLE_COLLATION, ENGINE, AUTO_INCREMENT FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE != 'VIEW' AND TABLE_SCHEMA='";

query.append(databaseName);

query.append("' ORDER BY TABLE_NAME");

while ((row= drizzle_row_next(result)))

{

size_t* row_sizes= drizzle_row_field_sizes(result);

std::string tableName(row[0]);

std::string displayName(tableName);

cleanTableName(displayName);

else

table->autoIncrement= 0;

if ((row[4]) and (strstr(row[4], "InnoDB free") == NULL))

table->comment= DrizzleDumpData::escape(row[4], row_sizes[4]);

else

table->comment= "";

table->database= this;

if ((not table->populateFields()) or (not table->populateIndexes()) or

(not table->populateFkeys()))

if ((not table->populateFields()) or (not table->populateIndexes()))

{

delete table;

if (not ignore_errors)

167

160

if (verbose)

168

161

std::cerr << _("-- Retrieving fields for ") << tableName << "..." << std::endl;

169

162

170

query="SELECT COLUMN_NAME, COLUMN_TYPE, COLUMN_DEFAULT, IS_NULLABLE, CHARACTER_MAXIMUM_LENGTH, NUMERIC_PRECISION, NUMERIC_SCALE, COLLATION_NAME, EXTRA, COLUMN_COMMENT FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA='";

163

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='";

171

164

query.append(database->databaseName);

172

165

query.append("' AND TABLE_NAME='");

173

166

query.append(tableName);

184

177

DrizzleDumpFieldMySQL *field = new DrizzleDumpFieldMySQL(fieldName, dcon);

185

178

/* Stop valgrind warning */

186

179

field->convertDateTime= false;

187

field->isNull= (strcmp(row[3], "YES") == 0) ? true : false;

188

180

/* Also sets collation */

189

181

field->setType(row[1], row[8]);

190

if (field->type.compare("ENUM") == 0)

191

field->isNull= true;

192

193

if ((row[2]) and (field->type.compare("TEXT") != 0))

182

if (row[2])

194

183

{

195

field->defaultValue= row[2];

196

184

if (field->convertDateTime)

197

185

{

198

field->dateTimeConvert();

186

field->dateTimeConvert(row[2]);

199

187

}

188

else

189

field->defaultValue= row[2];

200

190

}

201

191

else

202

{

203

field->defaultValue= "";

204

}

192

field->defaultValue= "";

205

193

194

field->isNull= (strcmp(row[3], "YES") == 0) ? true : false;

206

195

field->isAutoIncrement= (strcmp(row[8], "auto_increment") == 0) ? true : false;

207

196

field->defaultIsNull= field->isNull;

208

209

/* Seriously MySQL, why is BIT length in NUMERIC_PRECISION? */

210

if ((strncmp(row[1], "bit", 3) == 0) and (row[5] != NULL))

211

field->length= ((boost::lexical_cast<uint32_t>(row[5]) - 1) / 8) + 1;

212

else

213

field->length= (row[4]) ? boost::lexical_cast<uint32_t>(row[4]) : 0;

214

215

/* Also, CHAR(0) is valid?? */

216

if (((field->type.compare("VARBINARY") == 0)

217

or (field->type.compare("VARCHAR") == 0))

218

and (field->length == 0))

219

{

220

field->length= 1;

221

}

222

197

field->length= (row[4]) ? boost::lexical_cast<uint32_t>(row[4]) : 0;

223

198

field->decimalPrecision= (row[5]) ? boost::lexical_cast<uint32_t>(row[5]) : 0;

224

199

field->decimalScale= (row[6]) ? boost::lexical_cast<uint32_t>(row[6]) : 0;

225

field->comment= (row[9]) ? row[9] : "";

200

201

226

202

fields.push_back(field);

227

203

}

228

204

231

207

}

232

208

233

209

234

void DrizzleDumpFieldMySQL::dateTimeConvert(void)

210

void DrizzleDumpFieldMySQL::dateTimeConvert(const char* oldDefault)

235

211

{

236

212

boost::match_flag_type flags = boost::match_default;

237

213

238

if (strcmp(defaultValue.c_str(), "CURRENT_TIMESTAMP") == 0)

214

if (strcmp(oldDefault, "CURRENT_TIMESTAMP") == 0)

215

{

216

defaultValue= oldDefault;

239

217

return;

218

}

240

219

241

220

if (type.compare("INT") == 0)

242

221

{

243

222

/* We were a TIME, now we are an INT */

244

std::string ts(defaultValue);

223

std::string ts(oldDefault);

245

224

boost::posix_time::time_duration td(boost::posix_time::duration_from_string(ts));

246

225

defaultValue= boost::lexical_cast<std::string>(td.total_seconds());

247

226

return;

248

227

}

249

228

250

boost::regex date_regex("(0000|-00)");

229

boost::regex date_regex("([0-9]{3}[1-9]-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01]))");

251

230

252

if (regex_search(defaultValue, date_regex, flags))

231

if (regex_search(oldDefault, date_regex, flags))

232

{

233

defaultValue= oldDefault;

234

}

235

else

253

236

{

254

237

defaultIsNull= true;

255

238

defaultValue="";

304

287

return true;

305

288

}

306

289

307

bool DrizzleDumpTableMySQL::populateFkeys()

308

{

309

drizzle_result_st *result;

310

drizzle_row_t row;

311

std::string query;

312

DrizzleDumpForeignKey *fkey;

313

314

if (verbose)

315

std::cerr << _("-- Retrieving foreign keys for ") << tableName << "..." << std::endl;

316

317

query= "SHOW CREATE TABLE `";

318

query.append(database->databaseName);

319

query.append("`.`");

320

query.append(tableName);

321

query.append("`");

322

result= dcon->query(query);

323

324

if (result == NULL)

325

return false;

326

327

if ((row= drizzle_row_next(result)))

328

{

329

boost::match_flag_type flags = boost::match_default;

330

331

332

boost::match_results<std::string::const_iterator> constraint_results;

333

334

std::string search_body(row[1]);

335

std::string::const_iterator start, end;

336

start= search_body.begin();

337

end= search_body.end();

338

while (regex_search(start, end, constraint_results, constraint_regex, flags))

339

{

340

fkey= new DrizzleDumpForeignKey(constraint_results[1], dcon);

341

fkey->parentColumns= constraint_results[2];

342

fkey->childTable= constraint_results[3];

343

fkey->childColumns= constraint_results[4];

344

345

if (constraint_results[5].compare("") != 0)

346

{

347

if (constraint_results[6].compare("UPDATE") == 0)

348

fkey->updateRule= constraint_results[7];

349

else if (constraint_results[6].compare("DELETE") == 0)

350

fkey->deleteRule= constraint_results[7];

351

}

352

if (constraint_results[8].compare("") != 0)

353

{

354

if (constraint_results[9].compare("UPDATE") == 0)

355

fkey->updateRule= constraint_results[10];

356

else if (constraint_results[9].compare("DELETE") == 0)

357

fkey->deleteRule= constraint_results[10];

358

}

359

fkey->matchOption= "";

360

361

fkeys.push_back(fkey);

362

363

start= constraint_results[0].second;

364

flags |= boost::match_prev_avail;

365

flags |= boost::match_not_bob;

366

}

367

}

368

dcon->freeResult(result);

369

return true;

370

}

371

372

290

void DrizzleDumpFieldMySQL::setType(const char* raw_type, const char* raw_collation)

373

291

{

374

292

std::string old_type(raw_type);

375

293

std::string extra;

376

294

size_t pos;

377

295

378

if (((pos= old_type.find("(")) != std::string::npos) or

379

((pos= old_type.find(" ")) != std::string::npos))

296

if ((pos= old_type.find("(")) != std::string::npos)

380

297

{

381

298

extra= old_type.substr(pos);

382

299

old_type.erase(pos, std::string::npos);

387

304

(old_type.find("TEXT") != std::string::npos))

388

305

setCollate(raw_collation);

389

306

390

if ((old_type.compare("BIGINT") == 0) and

391

((extra.find("unsigned") != std::string::npos)))

392

{

393

rangeCheck= true;

394

}

395

396

307

if ((old_type.compare("INT") == 0) and

397

308

((extra.find("unsigned") != std::string::npos)))

398

309

{

434

345

if (old_type.compare("BINARY") == 0)

435

346

{

436

347

type= "VARBINARY";

437

438

348

return;

439

349

}

440

350

452

362

/* Intended to catch TIME/DATE/TIMESTAMP/DATETIME

453

363

We may have a default TIME/DATE which needs converting */

454

364

convertDateTime= true;

455

isNull= true;

456

365

}

457

366

458

367

if ((old_type.compare("TIME") == 0) or (old_type.compare("YEAR") == 0))

467

376

return;

468

377

}

469

378

470

if (old_type.compare("BIT") == 0)

471

{

472

type= "VARBINARY";

473

return;

474

}

475

476

379

type= old_type;

477

380

return;

478

381

}

479

382

480

383

void DrizzleDumpTableMySQL::setEngine(const char* newEngine)

481

384

{

482

if ((strcmp(newEngine, "MyISAM") == 0) || (strcmp(newEngine, "MEMORY") == 0))

385

if (strcmp(newEngine, "MyISAM") == 0)

483

386

engineName= "InnoDB";

484

387

else

485

388

engineName= newEngine;

551

454

552

455

result= dcon->query(query);

553

456

if (result == NULL)

554

throw std::exception();

457

throw 1;

555

458

}

556

459

557

460

DrizzleDumpDataMySQL::~DrizzleDumpDataMySQL()

558

461

{

559

462

drizzle_result_free(result);

560

delete result;

463

if (result) delete result;

561

464

}

562

465

563

466

long DrizzleDumpDataMySQL::convertTime(const char* oldTime) const

572

475

{

573

476

boost::match_flag_type flags = boost::match_default;

574

477

std::string output;

575

boost::regex date_regex("(0000|-00)");

478

boost::regex date_regex("([0-9]{3}[1-9]-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01]))");

576

479

577

if (not regex_search(oldDate, date_regex, flags))

480

if (regex_search(oldDate, date_regex, flags))

578

481

{

579

482

output.push_back('\'');

580

483

output.append(oldDate);

586

489

return output;

587

490

}

588

491

589

std::string DrizzleDumpDataMySQL::checkDateTime(const char* item, uint32_t field) const

492

std::ostream& DrizzleDumpDataMySQL::checkDateTime(std::ostream &os, const char* item, uint32_t field) const

590

493

{

591

std::string ret;

592

593

494

if (table->fields[field]->convertDateTime)

594

495

{

595

496

if (table->fields[field]->type.compare("INT") == 0)

596

ret= boost::lexical_cast<std::string>(convertTime(item));

497

os << convertTime(item);

597

498

else

598

ret= convertDate(item);

499

os << convertDate(item);

599

500

}

600

return ret;

501

return os;

601

502

}

602

503

Older »