Sandbox::https://github.com/ashed/sqlcipher/blob/attach/src/pragma.c

Repository navigation

History

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

624

625

626

627

628

629

630

631

632

633

634

635

636

637

638

639

640

641

642

643

644

645

646

647

648

649

650

651

652

653

654

655

656

657

658

659

660

661

662

663

664

665

666

667

668

669

670

671

672

673

674

675

676

677

678

679

680

681

682

683

684

685

686

687

688

689

690

691

692

693

694

695

696

697

698

699

700

701

702

703

704

705

706

707

708

709

710

711

712

713

714

715

716

717

718

719

720

721

722

723

724

725

726

727

728

729

730

731

732

733

734

735

736

737

738

739

740

741

742

743

744

745

746

747

748

749

750

751

752

753

754

755

756

757

758

759

760

761

762

763

764

765

766

767

768

769

770

771

772

773

774

775

776

777

778

779

780

781

782

783

784

785

786

787

788

789

790

791

792

793

794

795

796

797

798

799

800

801

802

803

804

805

806

807

808

809

810

811

812

813

814

815

816

817

818

819

820

821

822

823

824

825

826

827

828

829

830

831

832

833

834

835

836

837

838

839

840

841

842

843

844

845

846

847

848

849

850

851

852

853

854

855

856

857

858

859

860

861

862

863

864

865

866

867

868

869

870

871

872

873

874

875

876

877

878

879

880

881

882

883

884

885

886

887

888

889

890

891

892

893

894

895

896

897

898

899

900

901

902

903

904

905

906

907

908

909

910

911

912

913

914

915

916

917

918

919

920

921

922

923

924

925

926

927

928

929

930

931

932

933

934

935

936

937

938

939

940

941

942

943

944

945

946

947

948

949

950

951

952

953

954

955

956

957

958

959

960

961

962

963

964

965

966

967

968

969

970

971

972

973

974

975

976

977

978

979

980

981

982

983

984

985

986

987

988

989

990

991

992

993

994

995

996

997

998

999

1000

** 2003 April 6

** The author disclaims copyright to this source code. In place of

** a legal notice, here is a blessing:

** May you do good and not evil.

** May you find forgiveness for yourself and forgive others.

** May you share freely, never taking more than you give.

*************************************************************************

** This file contains code used to implement the PRAGMA command.

#include "sqliteInt.h"

** Interpret the given string as a safety level. Return 0 for OFF,

** 1 for ON or NORMAL and 2 for FULL. Return 1 for an empty or

** unrecognized string argument. The FULL option is disallowed

** if the omitFull parameter it 1.

** Note that the values returned are one less that the values that

** should be passed into sqlite3BtreeSetSafetyLevel(). The is done

** to support legacy SQL code. The safety level used to be boolean

** and older scripts may have used numbers 0 for OFF and 1 for ON.

static u8 getSafetyLevel(const char *z, int omitFull, int dflt){

/* 123456789 123456789 */

static const char zText[] = "onoffalseyestruefull";

static const u8 iOffset[] = {0, 1, 2, 4, 9, 12, 16};

static const u8 iLength[] = {2, 2, 3, 5, 3, 4, 4};

static const u8 iValue[] = {1, 0, 0, 0, 1, 1, 2};

int i, n;

if( sqlite3Isdigit(*z) ){

return (u8)sqlite3Atoi(z);

}

n = sqlite3Strlen30(z);

for(i=0; i<ArraySize(iLength)-omitFull; i++){

if( iLength[i]==n && sqlite3StrNICmp(&zText[iOffset[i]],z,n)==0 ){

return iValue[i];

}

return dflt;

}

** Interpret the given string as a boolean value.

u8 sqlite3GetBoolean(const char *z, int dflt){

return getSafetyLevel(z,1,dflt)!=0;

}

/* The sqlite3GetBoolean() function is used by other modules but the

** remainder of this file is specific to PRAGMA processing. So omit

** the rest of the file if PRAGMAs are omitted from the build.

#if !defined(SQLITE_OMIT_PRAGMA)

** Interpret the given string as a locking mode value.

static int getLockingMode(const char *z){

if( z ){

if( 0==sqlite3StrICmp(z, "exclusive") ) return PAGER_LOCKINGMODE_EXCLUSIVE;

if( 0==sqlite3StrICmp(z, "normal") ) return PAGER_LOCKINGMODE_NORMAL;

}

return PAGER_LOCKINGMODE_QUERY;

}

#ifndef SQLITE_OMIT_AUTOVACUUM

** Interpret the given string as an auto-vacuum mode value.

** The following strings, "none", "full" and "incremental" are

** acceptable, as are their numeric equivalents: 0, 1 and 2 respectively.

static int getAutoVacuum(const char *z){

int i;

if( 0==sqlite3StrICmp(z, "none") ) return BTREE_AUTOVACUUM_NONE;

if( 0==sqlite3StrICmp(z, "full") ) return BTREE_AUTOVACUUM_FULL;

if( 0==sqlite3StrICmp(z, "incremental") ) return BTREE_AUTOVACUUM_INCR;

i = sqlite3Atoi(z);

return (u8)((i>=0&&i<=2)?i:0);

}

#endif /* ifndef SQLITE_OMIT_AUTOVACUUM */

#ifndef SQLITE_OMIT_PAGER_PRAGMAS

** Interpret the given string as a temp db location. Return 1 for file

** backed temporary databases, 2 for the Red-Black tree in memory database

** and 0 to use the compile-time default.

static int getTempStore(const char *z){

if( z[0]>='0' && z[0]<='2' ){

return z[0] - '0';

}else if( sqlite3StrICmp(z, "file")==0 ){

return 1;

}else if( sqlite3StrICmp(z, "memory")==0 ){

return 2;

}else{

return 0;

}

#endif /* SQLITE_PAGER_PRAGMAS */

#ifndef SQLITE_OMIT_PAGER_PRAGMAS

** Invalidate temp storage, either when the temp storage is changed

** from default, or when 'file' and the temp_store_directory has changed

static int invalidateTempStorage(Parse *pParse){

sqlite3 *db = pParse->db;

if( db->aDb[1].pBt!=0 ){

if( !db->autoCommit || sqlite3BtreeIsInReadTrans(db->aDb[1].pBt) ){

sqlite3ErrorMsg(pParse, "temporary storage cannot be changed "

"from within a transaction");

return SQLITE_ERROR;

}

sqlite3BtreeClose(db->aDb[1].pBt);

db->aDb[1].pBt = 0;

sqlite3ResetAllSchemasOfConnection(db);

}

return SQLITE_OK;

}

#endif /* SQLITE_PAGER_PRAGMAS */

#ifndef SQLITE_OMIT_PAGER_PRAGMAS

** If the TEMP database is open, close it and mark the database schema

** as needing reloading. This must be done when using the SQLITE_TEMP_STORE

** or DEFAULT_TEMP_STORE pragmas.

static int changeTempStorage(Parse *pParse, const char *zStorageType){

int ts = getTempStore(zStorageType);

sqlite3 *db = pParse->db;

if( db->temp_store==ts ) return SQLITE_OK;

if( invalidateTempStorage( pParse ) != SQLITE_OK ){

return SQLITE_ERROR;

}

db->temp_store = (u8)ts;

return SQLITE_OK;

}

#endif /* SQLITE_PAGER_PRAGMAS */

** Generate code to return a single integer value.

static void returnSingleInt(Parse *pParse, const char *zLabel, i64 value){

Vdbe *v = sqlite3GetVdbe(pParse);

int mem = ++pParse->nMem;

i64 *pI64 = sqlite3DbMallocRaw(pParse->db, sizeof(value));

if( pI64 ){

memcpy(pI64, &value, sizeof(value));

}

sqlite3VdbeAddOp4(v, OP_Int64, 0, mem, 0, (char*)pI64, P4_INT64);

sqlite3VdbeSetNumCols(v, 1);

sqlite3VdbeSetColName(v, 0, COLNAME_NAME, zLabel, SQLITE_STATIC);

sqlite3VdbeAddOp2(v, OP_ResultRow, mem, 1);

}

#ifndef SQLITE_OMIT_FLAG_PRAGMAS

** Check to see if zRight and zLeft refer to a pragma that queries

** or changes one of the flags in db->flags. Return 1 if so and 0 if not.

** Also, implement the pragma.

static int flagPragma(Parse *pParse, const char *zLeft, const char *zRight){

static const struct sPragmaType {

const char *zName; /* Name of the pragma */

int mask; /* Mask for the db->flags value */

} aPragma[] = {

{ "full_column_names", SQLITE_FullColNames },

{ "short_column_names", SQLITE_ShortColNames },

{ "count_changes", SQLITE_CountRows },

{ "empty_result_callbacks", SQLITE_NullCallback },

{ "legacy_file_format", SQLITE_LegacyFileFmt },

{ "fullfsync", SQLITE_FullFSync },

{ "checkpoint_fullfsync", SQLITE_CkptFullFSync },

{ "reverse_unordered_selects", SQLITE_ReverseOrder },

#ifndef SQLITE_OMIT_AUTOMATIC_INDEX

{ "automatic_index", SQLITE_AutoIndex },

#endif

#ifdef SQLITE_DEBUG

{ "sql_trace", SQLITE_SqlTrace },

{ "vdbe_listing", SQLITE_VdbeListing },

{ "vdbe_trace", SQLITE_VdbeTrace },

{ "vdbe_addoptrace", SQLITE_VdbeAddopTrace},

{ "vdbe_debug", SQLITE_SqlTrace | SQLITE_VdbeListing

| SQLITE_VdbeTrace },

#endif

#ifndef SQLITE_OMIT_CHECK

{ "ignore_check_constraints", SQLITE_IgnoreChecks },

#endif

/* The following is VERY experimental */

{ "writable_schema", SQLITE_WriteSchema|SQLITE_RecoveryMode },

/* TODO: Maybe it shouldn't be possible to change the ReadUncommitted

** flag if there are any active statements. */

{ "read_uncommitted", SQLITE_ReadUncommitted },

{ "recursive_triggers", SQLITE_RecTriggers },

/* This flag may only be set if both foreign-key and trigger support

** are present in the build. */

#if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)

{ "foreign_keys", SQLITE_ForeignKeys },

#endif

};

int i;

const struct sPragmaType *p;

for(i=0, p=aPragma; i<ArraySize(aPragma); i++, p++){

if( sqlite3StrICmp(zLeft, p->zName)==0 ){

sqlite3 *db = pParse->db;

Vdbe *v;

v = sqlite3GetVdbe(pParse);

assert( v!=0 ); /* Already allocated by sqlite3Pragma() */

if( ALWAYS(v) ){

if( zRight==0 ){

returnSingleInt(pParse, p->zName, (db->flags & p->mask)!=0 );

}else{

int mask = p->mask; /* Mask of bits to set or clear. */

if( db->autoCommit==0 ){

/* Foreign key support may not be enabled or disabled while not

** in auto-commit mode. */

mask &= ~(SQLITE_ForeignKeys);

}

if( sqlite3GetBoolean(zRight, 0) ){

db->flags |= mask;

}else{

db->flags &= ~mask;

}

/* Many of the flag-pragmas modify the code generated by the SQL

** compiler (eg. count_changes). So add an opcode to expire all

** compiled SQL statements after modifying a pragma value.

sqlite3VdbeAddOp2(v, OP_Expire, 0, 0);

}

return 1;

}

return 0;

}

#endif /* SQLITE_OMIT_FLAG_PRAGMAS */

** Return a human-readable name for a constraint resolution action.

#ifndef SQLITE_OMIT_FOREIGN_KEY

static const char *actionName(u8 action){

const char *zName;

switch( action ){

case OE_SetNull: zName = "SET NULL"; break;

case OE_SetDflt: zName = "SET DEFAULT"; break;

case OE_Cascade: zName = "CASCADE"; break;

case OE_Restrict: zName = "RESTRICT"; break;

default: zName = "NO ACTION";

assert( action==OE_None ); break;

}

return zName;

}

#endif

** Parameter eMode must be one of the PAGER_JOURNALMODE_XXX constants

** defined in pager.h. This function returns the associated lowercase

** journal-mode name.

const char *sqlite3JournalModename(int eMode){

static char * const azModeName[] = {

"delete", "persist", "off", "truncate", "memory"

#ifndef SQLITE_OMIT_WAL

, "wal"

#endif

};

assert( PAGER_JOURNALMODE_DELETE==0 );

assert( PAGER_JOURNALMODE_PERSIST==1 );

assert( PAGER_JOURNALMODE_OFF==2 );

assert( PAGER_JOURNALMODE_TRUNCATE==3 );

assert( PAGER_JOURNALMODE_MEMORY==4 );

assert( PAGER_JOURNALMODE_WAL==5 );

assert( eMode>=0 && eMode<=ArraySize(azModeName) );

if( eMode==ArraySize(azModeName) ) return 0;

return azModeName[eMode];

}

** Process a pragma statement.

** Pragmas are of this form:

** PRAGMA [database.]id [= value]

** The identifier might also be a string. The value is a string, and

** identifier, or a number. If minusFlag is true, then the value is

** a number that was preceded by a minus sign.

** If the left side is "database.id" then pId1 is the database name

** and pId2 is the id. If the left side is just "id" then pId1 is the

** id and pId2 is any empty string.

void sqlite3Pragma(

Parse *pParse,

Token *pId1, /* First part of [database.]id field */

Token *pId2, /* Second part of [database.]id field, or NULL */

Token *pValue, /* Token for <value>, or NULL */

int minusFlag /* True if a '-' sign preceded <value> */

){

char *zLeft = 0; /* Nul-terminated UTF-8 string <id> */

char *zRight = 0; /* Nul-terminated UTF-8 string <value>, or NULL */

const char *zDb = 0; /* The database name */

Token *pId; /* Pointer to <id> token */

int iDb; /* Database index for <database> */

char *aFcntl[4]; /* Argument to SQLITE_FCNTL_PRAGMA */

int rc; /* return value form SQLITE_FCNTL_PRAGMA */

sqlite3 *db = pParse->db; /* The database connection */

Db *pDb; /* The specific database being pragmaed */

Vdbe *v = sqlite3GetVdbe(pParse); /* Prepared statement */

/* BEGIN SQLCIPHER */

#ifdef SQLITE_HAS_CODEC

extern int codec_pragma(sqlite3*, int, Parse *, const char *, const char *);

#endif

/* END SQLCIPHER */

if( v==0 ) return;

sqlite3VdbeRunOnlyOnce(v);

pParse->nMem = 2;

/* Interpret the [database.] part of the pragma statement. iDb is the

** index of the database this pragma is being applied to in db.aDb[]. */

iDb = sqlite3TwoPartName(pParse, pId1, pId2, &pId);

if( iDb<0 ) return;

pDb = &db->aDb[iDb];

/* If the temp database has been explicitly named as part of the

** pragma, make sure it is open.

if( iDb==1 && sqlite3OpenTempDatabase(pParse) ){

return;

}

zLeft = sqlite3NameFromToken(db, pId);

if( !zLeft ) return;

if( minusFlag ){

zRight = sqlite3MPrintf(db, "-%T", pValue);

}else{

zRight = sqlite3NameFromToken(db, pValue);

}

assert( pId2 );

zDb = pId2->n>0 ? pDb->zName : 0;

if( sqlite3AuthCheck(pParse, SQLITE_PRAGMA, zLeft, zRight, zDb) ){

goto pragma_out;

}

/* Send an SQLITE_FCNTL_PRAGMA file-control to the underlying VFS

** connection. If it returns SQLITE_OK, then assume that the VFS

** handled the pragma and generate a no-op prepared statement.

aFcntl[0] = 0;

aFcntl[1] = zLeft;

aFcntl[2] = zRight;

aFcntl[3] = 0;

db->busyHandler.nBusy = 0;

rc = sqlite3_file_control(db, zDb, SQLITE_FCNTL_PRAGMA, (void*)aFcntl);

if( rc==SQLITE_OK ){

if( aFcntl[0] ){

int mem = ++pParse->nMem;

sqlite3VdbeAddOp4(v, OP_String8, 0, mem, 0, aFcntl[0], 0);

sqlite3VdbeSetNumCols(v, 1);

sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "result", SQLITE_STATIC);

sqlite3VdbeAddOp2(v, OP_ResultRow, mem, 1);

sqlite3_free(aFcntl[0]);

}

}else if( rc!=SQLITE_NOTFOUND ){

if( aFcntl[0] ){

sqlite3ErrorMsg(pParse, "%s", aFcntl[0]);

sqlite3_free(aFcntl[0]);

}

pParse->nErr++;

pParse->rc = rc;

}else

/* BEGIN SQLCIPHER */

#ifdef SQLITE_HAS_CODEC

if(codec_pragma(db, iDb, pParse, zLeft, zRight)) {

/* codec_pragma executes internal */

}else

#endif

/* END SQLCIPHER */

#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) && !defined(SQLITE_OMIT_DEPRECATED)

** PRAGMA [database.]default_cache_size

** PRAGMA [database.]default_cache_size=N

** The first form reports the current persistent setting for the

** page cache size. The value returned is the maximum number of

** pages in the page cache. The second form sets both the current

** page cache size value and the persistent page cache size value

** stored in the database file.

** Older versions of SQLite would set the default cache size to a

** negative number to indicate synchronous=OFF. These days, synchronous

** is always on by default regardless of the sign of the default cache

** size. But continue to take the absolute value of the default cache

** size of historical compatibility.

if( sqlite3StrICmp(zLeft,"default_cache_size")==0 ){

static const VdbeOpList getCacheSize[] = {

{ OP_Transaction, 0, 0, 0}, /* 0 */

{ OP_ReadCookie, 0, 1, BTREE_DEFAULT_CACHE_SIZE}, /* 1 */

{ OP_IfPos, 1, 8, 0},

{ OP_Integer, 0, 2, 0},

{ OP_Subtract, 1, 2, 1},

{ OP_IfPos, 1, 8, 0},

{ OP_Integer, 0, 1, 0}, /* 6 */

{ OP_Noop, 0, 0, 0},

{ OP_ResultRow, 1, 1, 0},

};

int addr;

if( sqlite3ReadSchema(pParse) ) goto pragma_out;

sqlite3VdbeUsesBtree(v, iDb);

if( !zRight ){

sqlite3VdbeSetNumCols(v, 1);

sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "cache_size", SQLITE_STATIC);

pParse->nMem += 2;

addr = sqlite3VdbeAddOpList(v, ArraySize(getCacheSize), getCacheSize);

sqlite3VdbeChangeP1(v, addr, iDb);

sqlite3VdbeChangeP1(v, addr+1, iDb);

sqlite3VdbeChangeP1(v, addr+6, SQLITE_DEFAULT_CACHE_SIZE);

}else{

int size = sqlite3AbsInt32(sqlite3Atoi(zRight));

sqlite3BeginWriteOperation(pParse, 0, iDb);

sqlite3VdbeAddOp2(v, OP_Integer, size, 1);

sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_DEFAULT_CACHE_SIZE, 1);

assert( sqlite3SchemaMutexHeld(db, iDb, 0) );

pDb->pSchema->cache_size = size;

sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);

}

}else

#endif /* !SQLITE_OMIT_PAGER_PRAGMAS && !SQLITE_OMIT_DEPRECATED */

#if !defined(SQLITE_OMIT_PAGER_PRAGMAS)

** PRAGMA [database.]page_size

** PRAGMA [database.]page_size=N

** The first form reports the current setting for the

** database page size in bytes. The second form sets the

** database page size value. The value can only be set if

** the database has not yet been created.

if( sqlite3StrICmp(zLeft,"page_size")==0 ){

Btree *pBt = pDb->pBt;

assert( pBt!=0 );

if( !zRight ){

int size = ALWAYS(pBt) ? sqlite3BtreeGetPageSize(pBt) : 0;

returnSingleInt(pParse, "page_size", size);

}else{

/* Malloc may fail when setting the page-size, as there is an internal

** buffer that the pager module resizes using sqlite3_realloc().

db->nextPagesize = sqlite3Atoi(zRight);

if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, db->nextPagesize,-1,0) ){

db->mallocFailed = 1;

}

}else

** PRAGMA [database.]secure_delete

** PRAGMA [database.]secure_delete=ON/OFF

** The first form reports the current setting for the

** secure_delete flag. The second form changes the secure_delete

** flag setting and reports thenew value.

if( sqlite3StrICmp(zLeft,"secure_delete")==0 ){

Btree *pBt = pDb->pBt;

int b = -1;

assert( pBt!=0 );

if( zRight ){

b = sqlite3GetBoolean(zRight, 0);

}

if( pId2->n==0 && b>=0 ){

int ii;

for(ii=0; ii<db->nDb; ii++){

sqlite3BtreeSecureDelete(db->aDb[ii].pBt, b);

}

b = sqlite3BtreeSecureDelete(pBt, b);

returnSingleInt(pParse, "secure_delete", b);

}else

** PRAGMA [database.]max_page_count

** PRAGMA [database.]max_page_count=N

** The first form reports the current setting for the

** maximum number of pages in the database file. The

** second form attempts to change this setting. Both

** forms return the current setting.

** The absolute value of N is used. This is undocumented and might

** change. The only purpose is to provide an easy way to test

** the sqlite3AbsInt32() function.

** PRAGMA [database.]page_count

** Return the number of pages in the specified database.

if( sqlite3StrICmp(zLeft,"page_count")==0

|| sqlite3StrICmp(zLeft,"max_page_count")==0

){

int iReg;

if( sqlite3ReadSchema(pParse) ) goto pragma_out;

sqlite3CodeVerifySchema(pParse, iDb);

iReg = ++pParse->nMem;

if( sqlite3Tolower(zLeft[0])=='p' ){

sqlite3VdbeAddOp2(v, OP_Pagecount, iDb, iReg);

}else{

sqlite3VdbeAddOp3(v, OP_MaxPgcnt, iDb, iReg,

sqlite3AbsInt32(sqlite3Atoi(zRight)));

}

sqlite3VdbeAddOp2(v, OP_ResultRow, iReg, 1);

sqlite3VdbeSetNumCols(v, 1);

sqlite3VdbeSetColName(v, 0, COLNAME_NAME, zLeft, SQLITE_TRANSIENT);

}else

** PRAGMA [database.]locking_mode

** PRAGMA [database.]locking_mode = (normal|exclusive)

if( sqlite3StrICmp(zLeft,"locking_mode")==0 ){

const char *zRet = "normal";

int eMode = getLockingMode(zRight);

if( pId2->n==0 && eMode==PAGER_LOCKINGMODE_QUERY ){

/* Simple "PRAGMA locking_mode;" statement. This is a query for

** the current default locking mode (which may be different to

** the locking-mode of the main database).

eMode = db->dfltLockMode;

}else{

Pager *pPager;

if( pId2->n==0 ){

/* This indicates that no database name was specified as part

** of the PRAGMA command. In this case the locking-mode must be

** set on all attached databases, as well as the main db file.

** Also, the sqlite3.dfltLockMode variable is set so that

** any subsequently attached databases also use the specified

** locking mode.

int ii;

assert(pDb==&db->aDb[0]);

for(ii=2; ii<db->nDb; ii++){

pPager = sqlite3BtreePager(db->aDb[ii].pBt);

sqlite3PagerLockingMode(pPager, eMode);

}

db->dfltLockMode = (u8)eMode;

}

pPager = sqlite3BtreePager(pDb->pBt);

eMode = sqlite3PagerLockingMode(pPager, eMode);

}

assert(eMode==PAGER_LOCKINGMODE_NORMAL||eMode==PAGER_LOCKINGMODE_EXCLUSIVE);

if( eMode==PAGER_LOCKINGMODE_EXCLUSIVE ){

zRet = "exclusive";

}

sqlite3VdbeSetNumCols(v, 1);

sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "locking_mode", SQLITE_STATIC);

sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, zRet, 0);

sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);

}else

** PRAGMA [database.]journal_mode

** PRAGMA [database.]journal_mode =

** (delete|persist|off|truncate|memory|wal|off)

if( sqlite3StrICmp(zLeft,"journal_mode")==0 ){

int eMode; /* One of the PAGER_JOURNALMODE_XXX symbols */

int ii; /* Loop counter */

/* Force the schema to be loaded on all databases. This causes all

** database files to be opened and the journal_modes set. This is

** necessary because subsequent processing must know if the databases

** are in WAL mode. */

if( sqlite3ReadSchema(pParse) ){

goto pragma_out;

}

sqlite3VdbeSetNumCols(v, 1);

sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "journal_mode", SQLITE_STATIC);

if( zRight==0 ){

/* If there is no "=MODE" part of the pragma, do a query for the

** current mode */

eMode = PAGER_JOURNALMODE_QUERY;

}else{

const char *zMode;

int n = sqlite3Strlen30(zRight);

for(eMode=0; (zMode = sqlite3JournalModename(eMode))!=0; eMode++){

if( sqlite3StrNICmp(zRight, zMode, n)==0 ) break;

}

if( !zMode ){

/* If the "=MODE" part does not match any known journal mode,

** then do a query */

eMode = PAGER_JOURNALMODE_QUERY;

}

if( eMode==PAGER_JOURNALMODE_QUERY && pId2->n==0 ){

/* Convert "PRAGMA journal_mode" into "PRAGMA main.journal_mode" */

iDb = 0;

pId2->n = 1;

}

for(ii=db->nDb-1; ii>=0; ii--){

if( db->aDb[ii].pBt && (ii==iDb || pId2->n==0) ){

sqlite3VdbeUsesBtree(v, ii);

sqlite3VdbeAddOp3(v, OP_JournalMode, ii, 1, eMode);

}

sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);

}else

** PRAGMA [database.]journal_size_limit

** PRAGMA [database.]journal_size_limit=N

** Get or set the size limit on rollback journal files.

if( sqlite3StrICmp(zLeft,"journal_size_limit")==0 ){

Pager *pPager = sqlite3BtreePager(pDb->pBt);

i64 iLimit = -2;

if( zRight ){

sqlite3Atoi64(zRight, &iLimit, 1000000, SQLITE_UTF8);

if( iLimit<-1 ) iLimit = -1;

}

iLimit = sqlite3PagerJournalSizeLimit(pPager, iLimit);

returnSingleInt(pParse, "journal_size_limit", iLimit);

}else

#endif /* SQLITE_OMIT_PAGER_PRAGMAS */

** PRAGMA [database.]auto_vacuum

** PRAGMA [database.]auto_vacuum=N

** Get or set the value of the database 'auto-vacuum' parameter.

** The value is one of: 0 NONE 1 FULL 2 INCREMENTAL

#ifndef SQLITE_OMIT_AUTOVACUUM

if( sqlite3StrICmp(zLeft,"auto_vacuum")==0 ){

Btree *pBt = pDb->pBt;

assert( pBt!=0 );

if( sqlite3ReadSchema(pParse) ){

goto pragma_out;

}

if( !zRight ){

int auto_vacuum;

if( ALWAYS(pBt) ){

auto_vacuum = sqlite3BtreeGetAutoVacuum(pBt);

}else{

auto_vacuum = SQLITE_DEFAULT_AUTOVACUUM;

}

returnSingleInt(pParse, "auto_vacuum", auto_vacuum);

}else{

int eAuto = getAutoVacuum(zRight);

assert( eAuto>=0 && eAuto<=2 );

db->nextAutovac = (u8)eAuto;

if( ALWAYS(eAuto>=0) ){

/* Call SetAutoVacuum() to set initialize the internal auto and

** incr-vacuum flags. This is required in case this connection

** creates the database file. It is important that it is created

** as an auto-vacuum capable db.

rc = sqlite3BtreeSetAutoVacuum(pBt, eAuto);

if( rc==SQLITE_OK && (eAuto==1 || eAuto==2) ){

/* When setting the auto_vacuum mode to either "full" or

** "incremental", write the value of meta[6] in the database

** file. Before writing to meta[6], check that meta[3] indicates

** that this really is an auto-vacuum capable database.

static const VdbeOpList setMeta6[] = {

{ OP_Transaction, 0, 1, 0}, /* 0 */

{ OP_ReadCookie, 0, 1, BTREE_LARGEST_ROOT_PAGE},

{ OP_If, 1, 0, 0}, /* 2 */

{ OP_Halt, SQLITE_OK, OE_Abort, 0}, /* 3 */

{ OP_Integer, 0, 1, 0}, /* 4 */

{ OP_SetCookie, 0, BTREE_INCR_VACUUM, 1}, /* 5 */

};

int iAddr;

iAddr = sqlite3VdbeAddOpList(v, ArraySize(setMeta6), setMeta6);

sqlite3VdbeChangeP1(v, iAddr, iDb);

sqlite3VdbeChangeP1(v, iAddr+1, iDb);

sqlite3VdbeChangeP2(v, iAddr+2, iAddr+4);

sqlite3VdbeChangeP1(v, iAddr+4, eAuto-1);

sqlite3VdbeChangeP1(v, iAddr+5, iDb);

sqlite3VdbeUsesBtree(v, iDb);

}

}else

#endif

** PRAGMA [database.]incremental_vacuum(N)

** Do N steps of incremental vacuuming on a database.

#ifndef SQLITE_OMIT_AUTOVACUUM

if( sqlite3StrICmp(zLeft,"incremental_vacuum")==0 ){

int iLimit, addr;

if( sqlite3ReadSchema(pParse) ){

goto pragma_out;

}

if( zRight==0 || !sqlite3GetInt32(zRight, &iLimit) || iLimit<=0 ){

iLimit = 0x7fffffff;

}

sqlite3BeginWriteOperation(pParse, 0, iDb);

sqlite3VdbeAddOp2(v, OP_Integer, iLimit, 1);

addr = sqlite3VdbeAddOp1(v, OP_IncrVacuum, iDb);

sqlite3VdbeAddOp1(v, OP_ResultRow, 1);

sqlite3VdbeAddOp2(v, OP_AddImm, 1, -1);

sqlite3VdbeAddOp2(v, OP_IfPos, 1, addr);

sqlite3VdbeJumpHere(v, addr);

}else

#endif

#ifndef SQLITE_OMIT_PAGER_PRAGMAS

** PRAGMA [database.]cache_size

** PRAGMA [database.]cache_size=N

** The first form reports the current local setting for the

** page cache size. The second form sets the local

** page cache size value. If N is positive then that is the

** number of pages in the cache. If N is negative, then the

** number of pages is adjusted so that the cache uses -N kibibytes

** of memory.

if( sqlite3StrICmp(zLeft,"cache_size")==0 ){

if( sqlite3ReadSchema(pParse) ) goto pragma_out;

assert( sqlite3SchemaMutexHeld(db, iDb, 0) );

if( !zRight ){

returnSingleInt(pParse, "cache_size", pDb->pSchema->cache_size);

}else{

int size = sqlite3Atoi(zRight);

pDb->pSchema->cache_size = size;

sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);

}

}else

** PRAGMA [database.]mmap_size(N)

** Used to set mapping size limit. The mapping size limit is

** used to limit the aggregate size of all memory mapped regions of the

** database file. If this parameter is set to zero, then memory mapping

** is not used at all. If N is negative, then the default memory map

** limit determined by sqlite3_config(SQLITE_CONFIG_MMAP_SIZE) is set.

** The parameter N is measured in bytes.

** This value is advisory. The underlying VFS is free to memory map

** as little or as much as it wants. Except, if N is set to 0 then the

** upper layers will never invoke the xFetch interfaces to the VFS.

if( sqlite3StrICmp(zLeft,"mmap_size")==0 ){

sqlite3_int64 sz;

assert( sqlite3SchemaMutexHeld(db, iDb, 0) );

if( zRight ){

int ii;

sqlite3Atoi64(zRight, &sz, 1000, SQLITE_UTF8);

if( sz<0 ) sz = sqlite3GlobalConfig.szMmap;

if( pId2->n==0 ) db->szMmap = sz;

for(ii=db->nDb-1; ii>=0; ii--){

if( db->aDb[ii].pBt && (ii==iDb || pId2->n==0) ){

sqlite3BtreeSetMmapLimit(db->aDb[ii].pBt, sz);

}

sz = -1;

if( sqlite3_file_control(db,zDb,SQLITE_FCNTL_MMAP_SIZE,&sz)==SQLITE_OK ){

#if SQLITE_MAX_MMAP_SIZE==0

sz = 0;

#endif

returnSingleInt(pParse, "mmap_size", sz);

}

}else

** PRAGMA temp_store

** PRAGMA temp_store = "default"|"memory"|"file"

** Return or set the local value of the temp_store flag. Changing

** the local value does not make changes to the disk file and the default

** value will be restored the next time the database is opened.

** Note that it is possible for the library compile-time options to

** override this setting

if( sqlite3StrICmp(zLeft, "temp_store")==0 ){

if( !zRight ){

returnSingleInt(pParse, "temp_store", db->temp_store);

}else{

changeTempStorage(pParse, zRight);

}

}else

** PRAGMA temp_store_directory

** PRAGMA temp_store_directory = ""|"directory_name"

** Return or set the local value of the temp_store_directory flag. Changing

** the value sets a specific directory to be used for temporary files.

** Setting to a null string reverts to the default temporary directory search.

** If temporary directory is changed, then invalidateTempStorage.

if( sqlite3StrICmp(zLeft, "temp_store_directory")==0 ){

if( !zRight ){

if( sqlite3_temp_directory ){

sqlite3VdbeSetNumCols(v, 1);

sqlite3VdbeSetColName(v, 0, COLNAME_NAME,

"temp_store_directory", SQLITE_STATIC);

sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, sqlite3_temp_directory, 0);

sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);

}

}else{

#ifndef SQLITE_OMIT_WSD

if( zRight[0] ){

int res;

rc = sqlite3OsAccess(db->pVfs, zRight, SQLITE_ACCESS_READWRITE, &res);

if( rc!=SQLITE_OK || res==0 ){

sqlite3ErrorMsg(pParse, "not a writable directory");

goto pragma_out;

}

if( SQLITE_TEMP_STORE==0

|| (SQLITE_TEMP_STORE==1 && db->temp_store<=1)

|| (SQLITE_TEMP_STORE==2 && db->temp_store==1)

){

invalidateTempStorage(pParse);

}

sqlite3_free(sqlite3_temp_directory);

if( zRight[0] ){

sqlite3_temp_directory = sqlite3_mprintf("%s", zRight);

}else{

sqlite3_temp_directory = 0;

}

#endif /* SQLITE_OMIT_WSD */

}

}else

#if SQLITE_OS_WIN

** PRAGMA data_store_directory

** PRAGMA data_store_directory = ""|"directory_name"

** Return or set the local value of the data_store_directory flag. Changing

** the value sets a specific directory to be used for database files that

** were specified with a relative pathname. Setting to a null string reverts

** to the default database directory, which for database files specified with

** a relative path will probably be based on the current directory for the

** process. Database file specified with an absolute path are not impacted

** by this setting, regardless of its value.

if( sqlite3StrICmp(zLeft, "data_store_directory")==0 ){

if( !zRight ){

if( sqlite3_data_directory ){

sqlite3VdbeSetNumCols(v, 1);

sqlite3VdbeSetColName(v, 0, COLNAME_NAME,

"data_store_directory", SQLITE_STATIC);

sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, sqlite3_data_directory, 0);

sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);

}

}else{

#ifndef SQLITE_OMIT_WSD

if( zRight[0] ){

int res;

rc = sqlite3OsAccess(db->pVfs, zRight, SQLITE_ACCESS_READWRITE, &res);

if( rc!=SQLITE_OK || res==0 ){

sqlite3ErrorMsg(pParse, "not a writable directory");

goto pragma_out;

}

sqlite3_free(sqlite3_data_directory);

if( zRight[0] ){

sqlite3_data_directory = sqlite3_mprintf("%s", zRight);

}else{

sqlite3_data_directory = 0;

}

#endif /* SQLITE_OMIT_WSD */

}

}else

#endif

#if !defined(SQLITE_ENABLE_LOCKING_STYLE)

# if defined(__APPLE__)

# define SQLITE_ENABLE_LOCKING_STYLE 1

# else

# define SQLITE_ENABLE_LOCKING_STYLE 0

# endif

#endif

#if SQLITE_ENABLE_LOCKING_STYLE

** PRAGMA [database.]lock_proxy_file

** PRAGMA [database.]lock_proxy_file = ":auto:"|"lock_file_path"

** Return or set the value of the lock_proxy_file flag. Changing

** the value sets a specific file to be used for database access locks.

if( sqlite3StrICmp(zLeft, "lock_proxy_file")==0 ){

if( !zRight ){

Pager *pPager = sqlite3BtreePager(pDb->pBt);

char *proxy_file_path = NULL;

sqlite3_file *pFile = sqlite3PagerFile(pPager);

sqlite3OsFileControlHint(pFile, SQLITE_GET_LOCKPROXYFILE,

&proxy_file_path);

if( proxy_file_path ){

sqlite3VdbeSetNumCols(v, 1);

sqlite3VdbeSetColName(v, 0, COLNAME_NAME,

"lock_proxy_file", SQLITE_STATIC);

sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, proxy_file_path, 0);

sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);

}

}else{

Pager *pPager = sqlite3BtreePager(pDb->pBt);

sqlite3_file *pFile = sqlite3PagerFile(pPager);

int res;

if( zRight[0] ){

res=sqlite3OsFileControl(pFile, SQLITE_SET_LOCKPROXYFILE,

zRight);

} else {

res=sqlite3OsFileControl(pFile, SQLITE_SET_LOCKPROXYFILE,

NULL);

}

if( res!=SQLITE_OK ){

sqlite3ErrorMsg(pParse, "failed to set lock proxy file");

goto pragma_out;

}

}else

#endif /* SQLITE_ENABLE_LOCKING_STYLE */

** PRAGMA [database.]synchronous

** PRAGMA [database.]synchronous=OFF|ON|NORMAL|FULL

** Return or set the local value of the synchronous flag. Changing

** the local value does not make changes to the disk file and the

** default value will be restored the next time the database is

** opened.

if( sqlite3StrICmp(zLeft,"synchronous")==0 ){

if( sqlite3ReadSchema(pParse) ) goto pragma_out;

if( !zRight ){

returnSingleInt(pParse, "synchronous", pDb->safety_level-1);

}else{

if( !db->autoCommit ){

sqlite3ErrorMsg(pParse,

"Safety level may not be changed inside a transaction");

}else{

pDb->safety_level = getSafetyLevel(zRight,0,1)+1;

}

}else

#endif /* SQLITE_OMIT_PAGER_PRAGMAS */

#ifndef SQLITE_OMIT_FLAG_PRAGMAS

if( flagPragma(pParse, zLeft, zRight) ){

/* The flagPragma() subroutine also generates any necessary code

** there is nothing more to do here */

}else

#endif /* SQLITE_OMIT_FLAG_PRAGMAS */

#ifndef SQLITE_OMIT_SCHEMA_PRAGMAS

** PRAGMA table_info(<table>)

** Return a single row for each column of the named table. The columns of

** the returned data set are:

** cid: Column id (numbered from left to right, starting at 0)

** name: Column name

** type: Column declaration type.

** notnull: True if 'NOT NULL' is part of column declaration

** dflt_value: The default value for the column, if any.

if( sqlite3StrICmp(zLeft, "table_info")==0 && zRight ){

View remainder of file in raw view

FilesExpand file tree

pragma.c

Latest commit

History

pragma.c

File metadata and controls