~drizzle-trunk/drizzle/development : revision 51.3.8

162

163

int archive_db_init(void *p)

164

{

165

DBUG_ENTER("archive_db_init");

166

165

handlerton *archive_hton;

167

166

168

167

archive_hton= (handlerton *)p;

184

183

}

185

184

else

186

185

{

187

DBUG_RETURN(false);

186

return(false);

188

187

}

189

188

error:

190

DBUG_RETURN(true);

189

return(true);

191

190

}

192

191

193

192

/*

228

227

uchar **frmblob,

229

228

size_t *frmlen)

230

229

{

231

DBUG_ENTER("archive_discover");

232

DBUG_PRINT("archive_discover", ("db: %s, name: %s", db, name));

233

230

azio_stream frm_stream;

234

231

char az_file[FN_REFLEN];

235

232

char *frm_ptr;

243

240

if (!(azopen(&frm_stream, az_file, O_RDONLY|O_BINARY, AZ_METHOD_BLOCK)))

244

241

{

245

242

if (errno == EROFS || errno == EACCES)

246

DBUG_RETURN(my_errno= errno);

247

DBUG_RETURN(HA_ERR_CRASHED_ON_USAGE);

243

return(my_errno= errno);

244

return(HA_ERR_CRASHED_ON_USAGE);

248

245

}

249

246

250

247

if (frm_stream.frm_length == 0)

257

254

*frmlen= frm_stream.frm_length;

258

255

*frmblob= (uchar*) frm_ptr;

259

256

260

DBUG_RETURN(0);

257

return(0);

261

258

err:

262

259

my_errno= 0;

263

DBUG_RETURN(1);

260

return(1);

264

261

}

265

262

266

263

/*

268

265

*/

269

266

int ha_archive::read_data_header(azio_stream *file_to_read)

270

267

{

271

DBUG_ENTER("ha_archive::read_data_header");

272

273

268

if (azread_init(file_to_read) == -1)

274

DBUG_RETURN(HA_ERR_CRASHED_ON_USAGE);

269

return(HA_ERR_CRASHED_ON_USAGE);

275

270

276

271

if (file_to_read->version >= 3)

277

DBUG_RETURN(0);

272

return(0);

278

273

279

DBUG_RETURN(1);

274

return(1);

280

275

}

281

276

282

277

290

285

ARCHIVE_SHARE *ha_archive::get_share(const char *table_name, int *rc)

291

286

{

292

287

uint length;

293

DBUG_ENTER("ha_archive::get_share");

294

288

295

289

pthread_mutex_lock(&archive_mutex);

296

290

length=(uint) strlen(table_name);

309

303

{

310

304

pthread_mutex_unlock(&archive_mutex);

311

305

*rc= HA_ERR_OUT_OF_MEM;

312

DBUG_RETURN(NULL);

306

return(NULL);

313

307

}

314

308

315

309

share->use_count= 0;

320

314

fn_format(share->data_file_name, table_name, "",

321

315

ARZ, MY_REPLACE_EXT | MY_UNPACK_FILENAME);

322

316

strmov(share->table_name, table_name);

323

DBUG_PRINT("ha_archive", ("Data File %s",

324

share->data_file_name));

325

317

/*

326

318

We will use this lock for rows.

327

319

*/

340

332

free(share);

341

333

pthread_mutex_unlock(&archive_mutex);

342

334

*rc= HA_ERR_CRASHED_ON_REPAIR;

343

DBUG_RETURN(NULL);

335

return(NULL);

344

336

}

345

337

stats.auto_increment_value= archive_tmp.auto_increment + 1;

346

338

share->rows_recorded= (ha_rows)archive_tmp.rows;

356

348

thr_lock_init(&share->lock);

357

349

}

358

350

share->use_count++;

359

DBUG_PRINT("ha_archive", ("archive table %.*s has %d open handles now",

360

share->table_name_length, share->table_name,

361

share->use_count));

362

351

if (share->crashed)

363

352

*rc= HA_ERR_CRASHED_ON_USAGE;

364

353

pthread_mutex_unlock(&archive_mutex);

365

354

366

DBUG_RETURN(share);

355

return(share);

367

356

}

368

357

369

358

374

363

int ha_archive::free_share()

375

364

{

376

365

int rc= 0;

377

DBUG_ENTER("ha_archive::free_share");

378

DBUG_PRINT("ha_archive",

379

("archive table %.*s has %d open handles on entrance",

380

share->table_name_length, share->table_name,

381

share->use_count));

382

366

383

367

pthread_mutex_lock(&archive_mutex);

384

368

if (!--share->use_count)

402

386

}

403

387

pthread_mutex_unlock(&archive_mutex);

404

388

405

DBUG_RETURN(rc);

389

return(rc);

406

390

}

407

391

408

392

int ha_archive::init_archive_writer()

409

393

{

410

DBUG_ENTER("ha_archive::init_archive_writer");

411

394

/*

412

395

It is expensive to open and close the data files and since you can't have

413

396

a gzip file that can be both read and written we keep a writer open

416

399

if (!(azopen(&(share->archive_write), share->data_file_name,

417

400

O_RDWR|O_BINARY, AZ_METHOD_BLOCK)))

418

401

{

419

DBUG_PRINT("ha_archive", ("Could not open archive write file"));

420

402

share->crashed= true;

421

DBUG_RETURN(1);

403

return(1);

422

404

}

423

405

share->archive_write_open= true;

424

406

425

DBUG_RETURN(0);

407

return(0);

426

408

}

427

409

428

410

431

413

*/

432

414

int ha_archive::init_archive_reader()

433

415

{

434

DBUG_ENTER("ha_archive::init_archive_reader");

435

416

/*

436

417

It is expensive to open and close the data files and since you can't have

437

418

a gzip file that can be both read and written we keep a writer open

455

436

if (!(azopen(&archive, share->data_file_name, O_RDONLY|O_BINARY,

456

437

method)))

457

438

{

458

DBUG_PRINT("ha_archive", ("Could not open archive read file"));

459

439

share->crashed= true;

460

DBUG_RETURN(1);

440

return(1);

461

441

}

462

442

archive_reader_open= true;

463

443

}

464

444

465

DBUG_RETURN(0);

445

return(0);

466

446

}

467

447

468

448

491

471

uint open_options)

492

472

{

493

473

int rc= 0;

494

DBUG_ENTER("ha_archive::open");

495

496

DBUG_PRINT("ha_archive", ("archive table was opened for crash: %s",

497

(open_options & HA_OPEN_FOR_REPAIR) ? "yes" : "no"));

498

474

share= get_share(name, &rc);

499

475

500

476

if (rc == HA_ERR_CRASHED_ON_USAGE && !(open_options & HA_OPEN_FOR_REPAIR))

501

477

{

502

478

/* purecov: begin inspected */

503

479

free_share();

504

DBUG_RETURN(rc);

480

return(rc);

505

481

/* purecov: end */

506

482

}

507

483

else if (rc == HA_ERR_OUT_OF_MEM)

508

484

{

509

DBUG_RETURN(rc);

485

return(rc);

510

486

}

511

487

512

DBUG_ASSERT(share);

488

assert(share);

513

489

514

490

record_buffer= create_record_buffer(table->s->reclength +

515

491

ARCHIVE_ROW_HEADER_SIZE);

517

493

if (!record_buffer)

518

494

{

519

495

free_share();

520

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

496

return(HA_ERR_OUT_OF_MEM);

521

497

}

522

498

523

499

thr_lock_data_init(&share->lock, &lock, NULL);

524

500

525

DBUG_PRINT("ha_archive", ("archive table was crashed %s",

526

rc == HA_ERR_CRASHED_ON_USAGE ? "yes" : "no"));

527

501

if (rc == HA_ERR_CRASHED_ON_USAGE && open_options & HA_OPEN_FOR_REPAIR)

528

502

{

529

DBUG_RETURN(0);

503

return(0);

530

504

}

531

505

else

532

DBUG_RETURN(rc);

506

return(rc);

533

507

}

534

508

535

509

553

527

int ha_archive::close(void)

554

528

{

555

529

int rc= 0;

556

DBUG_ENTER("ha_archive::close");

557

530

558

531

destroy_record_buffer(record_buffer);

559

532

566

539

/* then also close share */

567

540

rc|= free_share();

568

541

569

DBUG_RETURN(rc);

542

return(rc);

570

543

}

571

544

572

545

590

563

struct stat file_stat;

591

564

uchar *frm_ptr;

592

565

593

DBUG_ENTER("ha_archive::create");

594

595

566

stats.auto_increment_value= create_info->auto_increment_value;

596

567

597

568

for (uint key= 0; key < table_arg->s->keys; key++)

607

578

if (!(field->flags & AUTO_INCREMENT_FLAG))

608

579

{

609

580

error= -1;

610

DBUG_PRINT("ha_archive", ("Index error in creating archive table"));

611

581

goto error;

612

582

}

613

583

}

618

588

*/

619

589

if (create_info->data_file_name && create_info->data_file_name[0] != '#')

620

590

{

621

DBUG_PRINT("ha_archive", ("archive will create stream file %s",

622

create_info->data_file_name));

623

624

591

fn_format(name_buff, create_info->data_file_name, "", ARZ,

625

592

MY_REPLACE_EXT | MY_UNPACK_FILENAME);

626

593

fn_format(linkname, name, "", ARZ,

689

656

else

690

657

my_errno= 0;

691

658

692

DBUG_PRINT("ha_archive", ("Creating File %s", name_buff));

693

DBUG_PRINT("ha_archive", ("Creating Link %s", linkname));

694

695

696

DBUG_RETURN(0);

659

return(0);

697

660

698

661

error2:

699

662

delete_table(name);

700

663

error:

701

664

/* Return error number, if we got one */

702

DBUG_RETURN(error ? error : -1);

665

return(error ? error : -1);

703

666

}

704

667

705

668

/*

709

672

{

710

673

my_off_t written;

711

674

unsigned int r_pack_length;

712

DBUG_ENTER("ha_archive::real_write_row");

713

675

714

676

/* We pack the row for writing */

715

677

r_pack_length= pack_row(buf);

717

679

written= azwrite_row(writer, record_buffer->buffer, r_pack_length);

718

680

if (written != r_pack_length)

719

681

{

720

DBUG_PRINT("ha_archive", ("Wrote %d bytes expected %d",

721

(uint32) written,

722

(uint32)r_pack_length));

723

DBUG_RETURN(-1);

682

return(-1);

724

683

}

725

684

726

685

if (!delayed_insert || !bulk_insert)

727

686

share->dirty= true;

728

687

729

DBUG_RETURN(0);

688

return(0);

730

689

}

731

690

732

691

756

715

{

757

716

uchar *ptr;

758

717

759

DBUG_ENTER("ha_archive::pack_row");

760

761

762

718

if (fix_rec_buff(max_row_length(record)))

763

DBUG_RETURN(HA_ERR_OUT_OF_MEM); /* purecov: inspected */

719

return(HA_ERR_OUT_OF_MEM); /* purecov: inspected */

764

720

765

721

/* Copy null bits */

766

722

memcpy(record_buffer->buffer, record, table->s->null_bytes);

772

728

ptr= (*field)->pack(ptr, record + (*field)->offset(record));

773

729

}

774

730

775

DBUG_PRINT("ha_archive",("Pack row length %u", (unsigned int)

776

(ptr - record_buffer->buffer -

777

ARCHIVE_ROW_HEADER_SIZE)));

778

779

DBUG_RETURN((unsigned int) (ptr - record_buffer->buffer));

731

return((unsigned int) (ptr - record_buffer->buffer));

780

732

}

781

733

782

734

795

747

uchar *read_buf= NULL;

796

748

uint64_t temp_auto;

797

749

uchar *record= table->record[0];

798

DBUG_ENTER("ha_archive::write_row");

799

750

800

751

if (share->crashed)

801

DBUG_RETURN(HA_ERR_CRASHED_ON_USAGE);

752

return(HA_ERR_CRASHED_ON_USAGE);

802

753

803

754

ha_statistic_increment(&SSV::ha_write_count);

804

755

if (table->timestamp_field_type & TIMESTAMP_AUTO_SET_ON_INSERT)

807

758

808

759

if (share->archive_write_open == false)

809

760

if (init_archive_writer())

810

DBUG_RETURN(HA_ERR_CRASHED_ON_USAGE);

761

return(HA_ERR_CRASHED_ON_USAGE);

811

762

812

763

813

764

if (table->next_number_field && record == table->record[0])

890

841

if (read_buf)

891

842

my_free((uchar*) read_buf, MYF(0));

892

843

893

DBUG_RETURN(rc);

844

return(rc);

894

845

}

895

846

896

847

907

858

/* Initialized at each key walk (called multiple times unlike rnd_init()) */

908

859

int ha_archive::index_init(uint keynr, bool sorted __attribute__((__unused__)))

909

860

{

910

DBUG_ENTER("ha_archive::index_init");

911

861

active_index= keynr;

912

DBUG_RETURN(0);

862

return(0);

913

863

}

914

864

915

865

921

871

uint key_len, enum ha_rkey_function find_flag)

922

872

{

923

873

int rc;

924

DBUG_ENTER("ha_archive::index_read");

925

874

rc= index_read_idx(buf, active_index, key, key_len, find_flag);

926

DBUG_RETURN(rc);

875

return(rc);

927

876

}

928

877

929

878

938

887

current_key= key;

939

888

current_key_len= key_len;

940

889

941

942

DBUG_ENTER("ha_archive::index_read_idx");

943

944

890

rc= rnd_init(true);

945

891

946

892

if (rc)

956

902

}

957

903

958

904

if (found)

959

DBUG_RETURN(0);

905

return(0);

960

906

961

907

error:

962

DBUG_RETURN(rc ? rc : HA_ERR_END_OF_FILE);

908

return(rc ? rc : HA_ERR_END_OF_FILE);

963

909

}

964

910

965

911

967

913

{

968

914

bool found= 0;

969

915

970

DBUG_ENTER("ha_archive::index_next");

971

972

916

while (!(get_row(&archive, buf)))

973

917

{

974

918

if (!memcmp(current_key, buf+current_k_offset, current_key_len))

978

922

}

979

923

}

980

924

981

DBUG_RETURN(found ? 0 : HA_ERR_END_OF_FILE);

925

return(found ? 0 : HA_ERR_END_OF_FILE);

982

926

}

983

927

984

928

/*

989

933

990

934

int ha_archive::rnd_init(bool scan)

991

935

{

992

DBUG_ENTER("ha_archive::rnd_init");

993

994

936

if (share->crashed)

995

DBUG_RETURN(HA_ERR_CRASHED_ON_USAGE);

937

return(HA_ERR_CRASHED_ON_USAGE);

996

938

997

939

init_archive_reader();

998

940

999

941

/* We rewind the file so that we can read from the beginning if scan */

1000

942

if (scan)

1001

943

{

1002

DBUG_PRINT("info", ("archive will retrieve %llu rows",

1003

(uint64_t) scan_rows));

1004

1005

944

if (read_data_header(&archive))

1006

DBUG_RETURN(HA_ERR_CRASHED_ON_USAGE);

945

return(HA_ERR_CRASHED_ON_USAGE);

1007

946

}

1008

947

1009

DBUG_RETURN(0);

948

return(0);

1010

949

}

1011

950

1012

951

1017

956

int ha_archive::get_row(azio_stream *file_to_read, uchar *buf)

1018

957

{

1019

958

int rc;

1020

DBUG_ENTER("ha_archive::get_row");

1021

DBUG_PRINT("ha_archive", ("Picking version for get_row() %d -> %d",

1022

(uchar)file_to_read->version,

1023

ARCHIVE_VERSION));

959

1024

960

if (file_to_read->version == ARCHIVE_VERSION)

1025

961

rc= get_row_version3(file_to_read, buf);

1026

962

else

1027

963

rc= -1;

1028

964

1029

DBUG_PRINT("ha_archive", ("Return %d\n", rc));

1030

1031

DBUG_RETURN(rc);

965

return(rc);

1032

966

}

1033

967

1034

968

/* Reallocate buffer if needed */

1035

969

bool ha_archive::fix_rec_buff(unsigned int length)

1036

970

{

1037

DBUG_ENTER("ha_archive::fix_rec_buff");

1038

DBUG_PRINT("ha_archive", ("Fixing %u for %u",

1039

length, record_buffer->length));

1040

DBUG_ASSERT(record_buffer->buffer);

971

assert(record_buffer->buffer);

1041

972

1042

973

if (length > record_buffer->length)

1043

974

{

1045

976

if (!(newptr=(uchar*) my_realloc((uchar*) record_buffer->buffer,

1046

977

length,

1047

978

MYF(MY_ALLOW_ZERO_PTR))))

1048

DBUG_RETURN(1);

979

return(1);

1049

980

record_buffer->buffer= newptr;

1050

981

record_buffer->length= length;

1051

982

}

1052

983

1053

DBUG_ASSERT(length <= record_buffer->length);

984

assert(length <= record_buffer->length);

1054

985

1055

DBUG_RETURN(0);

986

return(0);

1056

987

}

1057

988

1058

989

int ha_archive::unpack_row(azio_stream *file_to_read, uchar *record)

1059

990

{

1060

DBUG_ENTER("ha_archive::unpack_row");

1061

1062

991

unsigned int read;

1063

992

int error;

1064

993

const uchar *ptr;

1068

997

1069

998

if (error || read == 0)

1070

999

{

1071

DBUG_RETURN(-1);

1000

return(-1);

1072

1001

}

1073

1002

1074

1003

/* Copy null bits */

1081

1010

ptr= (*field)->unpack(record + (*field)->offset(table->record[0]), ptr);

1082

1011

}

1083

1012

}

1084

DBUG_RETURN(0);

1013

return(0);

1085

1014

}

1086

1015

1087

1016

1088

1017

int ha_archive::get_row_version3(azio_stream *file_to_read, uchar *buf)

1089

1018

{

1090

DBUG_ENTER("ha_archive::get_row_version3");

1091

1092

1019

int returnable= unpack_row(file_to_read, buf);

1093

1020

1094

DBUG_RETURN(returnable);

1021

return(returnable);

1095

1022

}

1096

1023

1097

1024

1103

1030

int ha_archive::rnd_next(uchar *buf)

1104

1031

{

1105

1032

int rc;

1106

DBUG_ENTER("ha_archive::rnd_next");

1107

1033

1108

1034

if (share->crashed)

1109

DBUG_RETURN(HA_ERR_CRASHED_ON_USAGE);

1035

return(HA_ERR_CRASHED_ON_USAGE);

1110

1036

1111

1037

if (!scan_rows)

1112

DBUG_RETURN(HA_ERR_END_OF_FILE);

1038

return(HA_ERR_END_OF_FILE);

1113

1039

scan_rows--;

1114

1040

1115

1041

ha_statistic_increment(&SSV::ha_read_rnd_next_count);

1118

1044

1119

1045

table->status=rc ? STATUS_NOT_FOUND: 0;

1120

1046

1121

DBUG_RETURN(rc);

1047

return(rc);

1122

1048

}

1123

1049

1124

1050

1130

1056

1131

1057

void ha_archive::position(const uchar *record __attribute__((__unused__)))

1132

1058

{

1133

DBUG_ENTER("ha_archive::position");

1134

1059

my_store_ptr(ref, ref_length, current_position);

1135

DBUG_VOID_RETURN;

1060

return;

1136

1061

}

1137

1062

1138

1063

1145

1070

1146

1071

int ha_archive::rnd_pos(uchar * buf, uchar *pos)

1147

1072

{

1148

DBUG_ENTER("ha_archive::rnd_pos");

1149

1073

ha_statistic_increment(&SSV::ha_read_rnd_next_count);

1150

1074

current_position= (my_off_t)my_get_ptr(pos, ref_length);

1151

1075

if (azseek(&archive, (size_t)current_position, SEEK_SET) == (size_t)(-1L))

1152

DBUG_RETURN(HA_ERR_CRASHED_ON_USAGE);

1153

DBUG_RETURN(get_row(&archive, buf));

1076

return(HA_ERR_CRASHED_ON_USAGE);

1077

return(get_row(&archive, buf));

1154

1078

}

1155

1079

1156

1080

/*

1160

1084

*/

1161

1085

int ha_archive::repair(THD* thd, HA_CHECK_OPT* check_opt)

1162

1086

{

1163

DBUG_ENTER("ha_archive::repair");

1164

1087

check_opt->flags= T_EXTEND;

1165

1088

int rc= optimize(thd, check_opt);

1166

1089

1167

1090

if (rc)

1168

DBUG_RETURN(HA_ERR_CRASHED_ON_REPAIR);

1091

return(HA_ERR_CRASHED_ON_REPAIR);

1169

1092

1170

1093

share->crashed= false;

1171

DBUG_RETURN(0);

1094

return(0);

1172

1095

}

1173

1096

1174

1097

/*

1178

1101

int ha_archive::optimize(THD* thd __attribute__((__unused__)),

1179

1102

HA_CHECK_OPT* check_opt __attribute__((__unused__)))

1180

1103

{

1181

DBUG_ENTER("ha_archive::optimize");

1182

1104

int rc= 0;

1183

1105

azio_stream writer;

1184

1106

char writer_filename[FN_REFLEN];

1197

1119

MY_REPLACE_EXT | MY_UNPACK_FILENAME);

1198

1120

1199

1121

if (!(azopen(&writer, writer_filename, O_CREAT|O_RDWR|O_BINARY, AZ_METHOD_BLOCK)))

1200

DBUG_RETURN(HA_ERR_CRASHED_ON_USAGE);

1122

return(HA_ERR_CRASHED_ON_USAGE);

1201

1123

1202

1124

/*

1203

1125

An extended rebuild is a lot more effort. We open up each row and re-record it.

1208

1130

*/

1209

1131

if (1)

1210

1132

{

1211

DBUG_PRINT("ha_archive", ("archive extended rebuild"));

1212

1213

1133

/*

1214

1134

Now we will rewind the archive file so that we are positioned at the

1215

1135

start of the file.

1259

1179

share->rows_recorded= (ha_rows)writer.rows;

1260

1180

}

1261

1181

1262

DBUG_PRINT("info", ("recovered %llu archive rows",

1263

(uint64_t)share->rows_recorded));

1264

1265

DBUG_PRINT("ha_archive", ("recovered %llu archive rows",

1266

(uint64_t)share->rows_recorded));

1267

1268

1182

if (rc && rc != HA_ERR_END_OF_FILE)

1269

1183

{

1270

1184

goto error;

1280

1194

rc = my_rename(writer_filename,share->data_file_name,MYF(0));

1281

1195

1282

1196

1283

DBUG_RETURN(rc);

1197

return(rc);

1284

1198

error:

1285

DBUG_PRINT("ha_archive", ("Failed to recover, error was %d", rc));

1286

1199

azclose(&writer);

1287

1200

1288

DBUG_RETURN(rc);

1201

return(rc);

1289

1202

}

1290

1203

1291

1204

/*

1335

1248

1336

1249

void ha_archive::update_create_info(HA_CREATE_INFO *create_info)

1337

1250

{

1338

DBUG_ENTER("ha_archive::update_create_info");

1339

1340

1251

ha_archive::info(HA_STATUS_AUTO);

1341

1252

if (!(create_info->used_fields & HA_CREATE_USED_AUTO))

1342

1253

{

1346

1257

if (!(my_readlink(share->real_path, share->data_file_name, MYF(0))))

1347

1258

create_info->data_file_name= share->real_path;

1348

1259

1349

DBUG_VOID_RETURN;

1260

return;

1350

1261

}

1351

1262

1352

1263

1355

1266

*/

1356

1267

int ha_archive::info(uint flag)

1357

1268

{

1358

DBUG_ENTER("ha_archive::info");

1359

1360

1269

/*

1361

1270

If dirty, we lock, and then reset/flush the data.

1362

1271

I found that just calling azflush() doesn't always work.

1364

1273

pthread_mutex_lock(&share->mutex);

1365

1274

if (share->dirty == true)

1366

1275

{

1367

DBUG_PRINT("ha_archive", ("archive flushing out rows for scan"));

1368

1276

azflush(&(share->archive_write), Z_SYNC_FLUSH);

1369

1277

share->rows_recorded= share->archive_write.rows;

1370

1278

share->dirty= false;

1386

1294

scan_rows= stats.records;

1387

1295

stats.deleted= 0;

1388

1296

1389

DBUG_PRINT("ha_archive", ("Stats rows is %d\n", (int)stats.records));

1390

1297

/* Costs quite a bit more to get all information */

1391

1298

if (flag & HA_STATUS_TIME)

1392

1299

{

1412

1319

stats.auto_increment_value= archive.auto_increment + 1;

1413

1320

}

1414

1321

1415

DBUG_RETURN(0);

1322

return(0);

1416

1323

}

1417

1324

1418

1325

1424

1331

*/

1425

1332

void ha_archive::start_bulk_insert(ha_rows rows)

1426

1333

{

1427

DBUG_ENTER("ha_archive::start_bulk_insert");

1428

1334

if (!rows || rows >= ARCHIVE_MIN_ROWS_TO_USE_BULK_INSERT)

1429

1335

bulk_insert= true;

1430

DBUG_VOID_RETURN;

1336

return;

1431

1337

}

1432

1338

1433

1339

1437

1343

*/

1438

1344

int ha_archive::end_bulk_insert()

1439

1345

{

1440

DBUG_ENTER("ha_archive::end_bulk_insert");

1441

1346

bulk_insert= false;

1442

1347

share->dirty= true;

1443

DBUG_RETURN(0);

1348

return(0);

1444

1349

}

1445

1350

1446

1351

/*

1450

1355

*/

1451

1356

int ha_archive::delete_all_rows()

1452

1357

{

1453

DBUG_ENTER("ha_archive::delete_all_rows");

1454

DBUG_RETURN(HA_ERR_WRONG_COMMAND);

1358

return(HA_ERR_WRONG_COMMAND);

1455

1359

}

1456

1360

1457

1361

/*

1459

1363

*/

1460

1364

bool ha_archive::is_crashed() const

1461

1365

{

1462

DBUG_ENTER("ha_archive::is_crashed");

1463

DBUG_RETURN(share->crashed);

1366

return(share->crashed);

1464

1367

}

1465

1368

1466

1369

/*

1473

1376

int rc= 0;

1474

1377

const char *old_proc_info;

1475

1378

uint64_t x;

1476

DBUG_ENTER("ha_archive::check");

1477

1379

1478

1380

old_proc_info= thd_proc_info(thd, "Checking table");

1479

1381

/* Flush any waiting data */

1501

1403

if ((rc && rc != HA_ERR_END_OF_FILE))

1502

1404

{

1503

1405

share->crashed= false;

1504

DBUG_RETURN(HA_ADMIN_CORRUPT);

1406

return(HA_ADMIN_CORRUPT);

1505

1407

}

1506

1408

else

1507

1409

{

1508

DBUG_RETURN(HA_ADMIN_OK);

1410

return(HA_ADMIN_OK);

1509

1411

}

1510

1412

}

1511

1413

1515

1417

bool ha_archive::check_and_repair(THD *thd)

1516

1418

{

1517

1419

HA_CHECK_OPT check_opt;

1518

DBUG_ENTER("ha_archive::check_and_repair");

1519

1420

1520

1421

check_opt.init();

1521

1422

1522

DBUG_RETURN(repair(thd, &check_opt));

1423

return(repair(thd, &check_opt));

1523

1424

}

1524

1425

1525

1426

archive_record_buffer *ha_archive::create_record_buffer(unsigned int length)

1526

1427

{

1527

DBUG_ENTER("ha_archive::create_record_buffer");

1528

1428

archive_record_buffer *r;

1529

1429

if (!(r=

1530

1430

(archive_record_buffer*) my_malloc(sizeof(archive_record_buffer),

1531

1431

MYF(MY_WME))))

1532

1432

{

1533

DBUG_RETURN(NULL); /* purecov: inspected */

1433

return(NULL); /* purecov: inspected */

1534

1434

}

1535

1435

r->length= (int)length;

1536

1436

1538

1438

MYF(MY_WME))))

1539

1439

{

1540

1440

my_free((char*) r, MYF(MY_ALLOW_ZERO_PTR));

1541

DBUG_RETURN(NULL); /* purecov: inspected */

1441

return(NULL); /* purecov: inspected */

1542

1442

}

1543

1443

1544

DBUG_RETURN(r);

1444

return(r);

1545

1445

}

1546

1446

1547

1447

void ha_archive::destroy_record_buffer(archive_record_buffer *r)

1548

1448

{

1549

DBUG_ENTER("ha_archive::destroy_record_buffer");

1550

1449

my_free((char*) r->buffer, MYF(MY_ALLOW_ZERO_PTR));

1551

1450

my_free((char*) r, MYF(MY_ALLOW_ZERO_PTR));

1552

DBUG_VOID_RETURN;

1451

return;

1553

1452

}

1554

1453

1555

1454

static MYSQL_SYSVAR_BOOL(aio, archive_use_aio,