minetest/src/sqlite/sqlite3.h at master · basicinside/minetest · GitHub

History

6731 lines (6543 loc) · 313 KB

Raw

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

** 2001 September 15

** 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 header file defines the interface that the SQLite library

** presents to client programs. If a C-function, structure, datatype,

** or constant definition does not appear in this file, then it is

** not a published API of SQLite, is subject to change without

** notice, and should not be referenced by programs that use SQLite.

** Some of the definitions that are in this file are marked as

** "experimental". Experimental interfaces are normally new

** features recently added to SQLite. We do not anticipate changes

** to experimental interfaces but reserve the right to make minor changes

** if experience from use "in the wild" suggest such changes are prudent.

** The official C-language API documentation for SQLite is derived

** from comments in this file. This file is the authoritative source

** on how SQLite interfaces are suppose to operate.

** The name of this file under configuration management is "sqlite.h.in".

** The makefile makes some minor changes to this file (such as inserting

** the version number) and changes its name to "sqlite3.h" as

** part of the build process.

#ifndef _SQLITE3_H_

#define _SQLITE3_H_

#include <stdarg.h> /* Needed for the definition of va_list */

** Make sure we can call this stuff from C++.

#ifdef __cplusplus

extern "C" {

#endif

** Add the ability to override 'extern'

#ifndef SQLITE_EXTERN

# define SQLITE_EXTERN extern

#endif

#ifndef SQLITE_API

# define SQLITE_API

#endif

** These no-op macros are used in front of interfaces to mark those

** interfaces as either deprecated or experimental. New applications

** should not use deprecated interfaces - they are support for backwards

** compatibility only. Application writers should be aware that

** experimental interfaces are subject to change in point releases.

** These macros used to resolve to various kinds of compiler magic that

** would generate warning messages when they were used. But that

** compiler magic ended up generating such a flurry of bug reports

** that we have taken it all out and gone back to using simple

** noop macros.

#define SQLITE_DEPRECATED

#define SQLITE_EXPERIMENTAL

** Ensure these symbols were not defined by some previous header file.

#ifdef SQLITE_VERSION

# undef SQLITE_VERSION

#endif

#ifdef SQLITE_VERSION_NUMBER

# undef SQLITE_VERSION_NUMBER

#endif

** CAPI3REF: Compile-Time Library Version Numbers

** ^(The [SQLITE_VERSION] C preprocessor macro in the sqlite3.h header

** evaluates to a string literal that is the SQLite version in the

** format "X.Y.Z" where X is the major version number (always 3 for

** SQLite3) and Y is the minor version number and Z is the release number.)^

** ^(The [SQLITE_VERSION_NUMBER] C preprocessor macro resolves to an integer

** with the value (X*1000000 + Y*1000 + Z) where X, Y, and Z are the same

** numbers used in [SQLITE_VERSION].)^

** The SQLITE_VERSION_NUMBER for any given release of SQLite will also

** be larger than the release from which it is derived. Either Y will

** be held constant and Z will be incremented or else Y will be incremented

** and Z will be reset to zero.

** Since version 3.6.18, SQLite source code has been stored in the

** <a href="http://www.fossil-scm.org/">Fossil configuration management

** system</a>. ^The SQLITE_SOURCE_ID macro evaluates to

** a string which identifies a particular check-in of SQLite

** within its configuration management system. ^The SQLITE_SOURCE_ID

** string contains the date and time of the check-in (UTC) and an SHA1

** hash of the entire source tree.

** See also: [sqlite3_libversion()],

** [sqlite3_libversion_number()], [sqlite3_sourceid()],

** [sqlite_version()] and [sqlite_source_id()].

#define SQLITE_VERSION "3.7.7.1"

#define SQLITE_VERSION_NUMBER 3007007

#define SQLITE_SOURCE_ID "2011-06-28 17:39:05 af0d91adf497f5f36ec3813f04235a6e195a605f"

** CAPI3REF: Run-Time Library Version Numbers

** KEYWORDS: sqlite3_version, sqlite3_sourceid

** These interfaces provide the same information as the [SQLITE_VERSION],

** [SQLITE_VERSION_NUMBER], and [SQLITE_SOURCE_ID] C preprocessor macros

** but are associated with the library instead of the header file. ^(Cautious

** programmers might include assert() statements in their application to

** verify that values returned by these interfaces match the macros in

** the header, and thus insure that the application is

** compiled with matching library and header files.

** <blockquote><pre>

** assert( sqlite3_libversion_number()==SQLITE_VERSION_NUMBER );

** assert( strcmp(sqlite3_sourceid(),SQLITE_SOURCE_ID)==0 );

** assert( strcmp(sqlite3_libversion(),SQLITE_VERSION)==0 );

** </pre></blockquote>)^

** ^The sqlite3_version[] string constant contains the text of [SQLITE_VERSION]

** macro. ^The sqlite3_libversion() function returns a pointer to the

** to the sqlite3_version[] string constant. The sqlite3_libversion()

** function is provided for use in DLLs since DLL users usually do not have

** direct access to string constants within the DLL. ^The

** sqlite3_libversion_number() function returns an integer equal to

** [SQLITE_VERSION_NUMBER]. ^The sqlite3_sourceid() function returns

** a pointer to a string constant whose value is the same as the

** [SQLITE_SOURCE_ID] C preprocessor macro.

** See also: [sqlite_version()] and [sqlite_source_id()].

SQLITE_API SQLITE_EXTERN const char sqlite3_version[];

SQLITE_API const char *sqlite3_libversion(void);

SQLITE_API const char *sqlite3_sourceid(void);

SQLITE_API int sqlite3_libversion_number(void);

** CAPI3REF: Run-Time Library Compilation Options Diagnostics

** ^The sqlite3_compileoption_used() function returns 0 or 1

** indicating whether the specified option was defined at

** compile time. ^The SQLITE_ prefix may be omitted from the

** option name passed to sqlite3_compileoption_used().

** ^The sqlite3_compileoption_get() function allows iterating

** over the list of options that were defined at compile time by

** returning the N-th compile time option string. ^If N is out of range,

** sqlite3_compileoption_get() returns a NULL pointer. ^The SQLITE_

** prefix is omitted from any strings returned by

** sqlite3_compileoption_get().

** ^Support for the diagnostic functions sqlite3_compileoption_used()

** and sqlite3_compileoption_get() may be omitted by specifying the

** [SQLITE_OMIT_COMPILEOPTION_DIAGS] option at compile time.

** See also: SQL functions [sqlite_compileoption_used()] and

** [sqlite_compileoption_get()] and the [compile_options pragma].

#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS

SQLITE_API int sqlite3_compileoption_used(const char *zOptName);

SQLITE_API const char *sqlite3_compileoption_get(int N);

#endif

** CAPI3REF: Test To See If The Library Is Threadsafe

** ^The sqlite3_threadsafe() function returns zero if and only if

** SQLite was compiled mutexing code omitted due to the

** [SQLITE_THREADSAFE] compile-time option being set to 0.

** SQLite can be compiled with or without mutexes. When

** the [SQLITE_THREADSAFE] C preprocessor macro is 1 or 2, mutexes

** are enabled and SQLite is threadsafe. When the

** [SQLITE_THREADSAFE] macro is 0,

** the mutexes are omitted. Without the mutexes, it is not safe

** to use SQLite concurrently from more than one thread.

** Enabling mutexes incurs a measurable performance penalty.

** So if speed is of utmost importance, it makes sense to disable

** the mutexes. But for maximum safety, mutexes should be enabled.

** ^The default behavior is for mutexes to be enabled.

** This interface can be used by an application to make sure that the

** version of SQLite that it is linking against was compiled with

** the desired setting of the [SQLITE_THREADSAFE] macro.

** This interface only reports on the compile-time mutex setting

** of the [SQLITE_THREADSAFE] flag. If SQLite is compiled with

** SQLITE_THREADSAFE=1 or =2 then mutexes are enabled by default but

** can be fully or partially disabled using a call to [sqlite3_config()]

** with the verbs [SQLITE_CONFIG_SINGLETHREAD], [SQLITE_CONFIG_MULTITHREAD],

** or [SQLITE_CONFIG_MUTEX]. ^(The return value of the

** sqlite3_threadsafe() function shows only the compile-time setting of

** thread safety, not any run-time changes to that setting made by

** sqlite3_config(). In other words, the return value from sqlite3_threadsafe()

** is unchanged by calls to sqlite3_config().)^

** See the [threading mode] documentation for additional information.

SQLITE_API int sqlite3_threadsafe(void);

** CAPI3REF: Database Connection Handle

** KEYWORDS: {database connection} {database connections}

** Each open SQLite database is represented by a pointer to an instance of

** the opaque structure named "sqlite3". It is useful to think of an sqlite3

** pointer as an object. The [sqlite3_open()], [sqlite3_open16()], and

** [sqlite3_open_v2()] interfaces are its constructors, and [sqlite3_close()]

** is its destructor. There are many other interfaces (such as

** [sqlite3_prepare_v2()], [sqlite3_create_function()], and

** [sqlite3_busy_timeout()] to name but three) that are methods on an

** sqlite3 object.

typedef struct sqlite3 sqlite3;

** CAPI3REF: 64-Bit Integer Types

** KEYWORDS: sqlite_int64 sqlite_uint64

** Because there is no cross-platform way to specify 64-bit integer types

** SQLite includes typedefs for 64-bit signed and unsigned integers.

** The sqlite3_int64 and sqlite3_uint64 are the preferred type definitions.

** The sqlite_int64 and sqlite_uint64 types are supported for backwards

** compatibility only.

** ^The sqlite3_int64 and sqlite_int64 types can store integer values

** between -9223372036854775808 and +9223372036854775807 inclusive. ^The

** sqlite3_uint64 and sqlite_uint64 types can store integer values

** between 0 and +18446744073709551615 inclusive.

#ifdef SQLITE_INT64_TYPE

typedef SQLITE_INT64_TYPE sqlite_int64;

typedef unsigned SQLITE_INT64_TYPE sqlite_uint64;

#elif defined(_MSC_VER) || defined(__BORLANDC__)

typedef __int64 sqlite_int64;

typedef unsigned __int64 sqlite_uint64;

#else

typedef long long int sqlite_int64;

typedef unsigned long long int sqlite_uint64;

#endif

typedef sqlite_int64 sqlite3_int64;

typedef sqlite_uint64 sqlite3_uint64;

** If compiling for a processor that lacks floating point support,

** substitute integer for floating-point.

#ifdef SQLITE_OMIT_FLOATING_POINT

# define double sqlite3_int64

#endif

** CAPI3REF: Closing A Database Connection

** ^The sqlite3_close() routine is the destructor for the [sqlite3] object.

** ^Calls to sqlite3_close() return SQLITE_OK if the [sqlite3] object is

** successfully destroyed and all associated resources are deallocated.

** Applications must [sqlite3_finalize | finalize] all [prepared statements]

** and [sqlite3_blob_close | close] all [BLOB handles] associated with

** the [sqlite3] object prior to attempting to close the object. ^If

** sqlite3_close() is called on a [database connection] that still has

** outstanding [prepared statements] or [BLOB handles], then it returns

** SQLITE_BUSY.

** ^If [sqlite3_close()] is invoked while a transaction is open,

** the transaction is automatically rolled back.

** The C parameter to [sqlite3_close(C)] must be either a NULL

** pointer or an [sqlite3] object pointer obtained

** from [sqlite3_open()], [sqlite3_open16()], or

** [sqlite3_open_v2()], and not previously closed.

** ^Calling sqlite3_close() with a NULL pointer argument is a

** harmless no-op.

SQLITE_API int sqlite3_close(sqlite3 *);

** The type for a callback function.

** This is legacy and deprecated. It is included for historical

** compatibility and is not documented.

typedef int (*sqlite3_callback)(void*,int,char**, char**);

** CAPI3REF: One-Step Query Execution Interface

** The sqlite3_exec() interface is a convenience wrapper around

** [sqlite3_prepare_v2()], [sqlite3_step()], and [sqlite3_finalize()],

** that allows an application to run multiple statements of SQL

** without having to use a lot of C code.

** ^The sqlite3_exec() interface runs zero or more UTF-8 encoded,

** semicolon-separate SQL statements passed into its 2nd argument,

** in the context of the [database connection] passed in as its 1st

** argument. ^If the callback function of the 3rd argument to

** sqlite3_exec() is not NULL, then it is invoked for each result row

** coming out of the evaluated SQL statements. ^The 4th argument to

** sqlite3_exec() is relayed through to the 1st argument of each

** callback invocation. ^If the callback pointer to sqlite3_exec()

** is NULL, then no callback is ever invoked and result rows are

** ignored.

** ^If an error occurs while evaluating the SQL statements passed into

** sqlite3_exec(), then execution of the current statement stops and

** subsequent statements are skipped. ^If the 5th parameter to sqlite3_exec()

** is not NULL then any error message is written into memory obtained

** from [sqlite3_malloc()] and passed back through the 5th parameter.

** To avoid memory leaks, the application should invoke [sqlite3_free()]

** on error message strings returned through the 5th parameter of

** of sqlite3_exec() after the error message string is no longer needed.

** ^If the 5th parameter to sqlite3_exec() is not NULL and no errors

** occur, then sqlite3_exec() sets the pointer in its 5th parameter to

** NULL before returning.

** ^If an sqlite3_exec() callback returns non-zero, the sqlite3_exec()

** routine returns SQLITE_ABORT without invoking the callback again and

** without running any subsequent SQL statements.

** ^The 2nd argument to the sqlite3_exec() callback function is the

** number of columns in the result. ^The 3rd argument to the sqlite3_exec()

** callback is an array of pointers to strings obtained as if from

** [sqlite3_column_text()], one for each column. ^If an element of a

** result row is NULL then the corresponding string pointer for the

** sqlite3_exec() callback is a NULL pointer. ^The 4th argument to the

** sqlite3_exec() callback is an array of pointers to strings where each

** entry represents the name of corresponding result column as obtained

** from [sqlite3_column_name()].

** ^If the 2nd parameter to sqlite3_exec() is a NULL pointer, a pointer

** to an empty string, or a pointer that contains only whitespace and/or

** SQL comments, then no SQL statements are evaluated and the database

** is not changed.

** Restrictions:

** <ul>

** <li> The application must insure that the 1st parameter to sqlite3_exec()

** is a valid and open [database connection].

** <li> The application must not close [database connection] specified by

** the 1st parameter to sqlite3_exec() while sqlite3_exec() is running.

** <li> The application must not modify the SQL statement text passed into

** the 2nd parameter of sqlite3_exec() while sqlite3_exec() is running.

** </ul>

SQLITE_API int sqlite3_exec(

sqlite3*, /* An open database */

const char *sql, /* SQL to be evaluated */

int (*callback)(void*,int,char**,char**), /* Callback function */

void *, /* 1st argument to callback */

char **errmsg /* Error msg written here */

);

** CAPI3REF: Result Codes

** KEYWORDS: SQLITE_OK {error code} {error codes}

** KEYWORDS: {result code} {result codes}

** Many SQLite functions return an integer result code from the set shown

** here in order to indicates success or failure.

** New error codes may be added in future versions of SQLite.

** See also: [SQLITE_IOERR_READ | extended result codes],

** [sqlite3_vtab_on_conflict()] [SQLITE_ROLLBACK | result codes].

#define SQLITE_OK 0 /* Successful result */

/* beginning-of-error-codes */

#define SQLITE_ERROR 1 /* SQL error or missing database */

#define SQLITE_INTERNAL 2 /* Internal logic error in SQLite */

#define SQLITE_PERM 3 /* Access permission denied */

#define SQLITE_ABORT 4 /* Callback routine requested an abort */

#define SQLITE_BUSY 5 /* The database file is locked */

#define SQLITE_LOCKED 6 /* A table in the database is locked */

#define SQLITE_NOMEM 7 /* A malloc() failed */

#define SQLITE_READONLY 8 /* Attempt to write a readonly database */

#define SQLITE_INTERRUPT 9 /* Operation terminated by sqlite3_interrupt()*/

#define SQLITE_IOERR 10 /* Some kind of disk I/O error occurred */

#define SQLITE_CORRUPT 11 /* The database disk image is malformed */

#define SQLITE_NOTFOUND 12 /* Unknown opcode in sqlite3_file_control() */

#define SQLITE_FULL 13 /* Insertion failed because database is full */

#define SQLITE_CANTOPEN 14 /* Unable to open the database file */

#define SQLITE_PROTOCOL 15 /* Database lock protocol error */

#define SQLITE_EMPTY 16 /* Database is empty */

#define SQLITE_SCHEMA 17 /* The database schema changed */

#define SQLITE_TOOBIG 18 /* String or BLOB exceeds size limit */

#define SQLITE_CONSTRAINT 19 /* Abort due to constraint violation */

#define SQLITE_MISMATCH 20 /* Data type mismatch */

#define SQLITE_MISUSE 21 /* Library used incorrectly */

#define SQLITE_NOLFS 22 /* Uses OS features not supported on host */

#define SQLITE_AUTH 23 /* Authorization denied */

#define SQLITE_FORMAT 24 /* Auxiliary database format error */

#define SQLITE_RANGE 25 /* 2nd parameter to sqlite3_bind out of range */

#define SQLITE_NOTADB 26 /* File opened that is not a database file */

#define SQLITE_ROW 100 /* sqlite3_step() has another row ready */

#define SQLITE_DONE 101 /* sqlite3_step() has finished executing */

/* end-of-error-codes */

** CAPI3REF: Extended Result Codes

** KEYWORDS: {extended error code} {extended error codes}

** KEYWORDS: {extended result code} {extended result codes}

** In its default configuration, SQLite API routines return one of 26 integer

** [SQLITE_OK | result codes]. However, experience has shown that many of

** these result codes are too coarse-grained. They do not provide as

** much information about problems as programmers might like. In an effort to

** address this, newer versions of SQLite (version 3.3.8 and later) include

** support for additional result codes that provide more detailed information

** about errors. The extended result codes are enabled or disabled

** on a per database connection basis using the

** [sqlite3_extended_result_codes()] API.

** Some of the available extended result codes are listed here.

** One may expect the number of extended result codes will be expand

** over time. Software that uses extended result codes should expect

** to see new result codes in future releases of SQLite.

** The SQLITE_OK result code will never be extended. It will always

** be exactly zero.

#define SQLITE_IOERR_READ (SQLITE_IOERR | (1<<8))

#define SQLITE_IOERR_SHORT_READ (SQLITE_IOERR | (2<<8))

#define SQLITE_IOERR_WRITE (SQLITE_IOERR | (3<<8))

#define SQLITE_IOERR_FSYNC (SQLITE_IOERR | (4<<8))

#define SQLITE_IOERR_DIR_FSYNC (SQLITE_IOERR | (5<<8))

#define SQLITE_IOERR_TRUNCATE (SQLITE_IOERR | (6<<8))

#define SQLITE_IOERR_FSTAT (SQLITE_IOERR | (7<<8))

#define SQLITE_IOERR_UNLOCK (SQLITE_IOERR | (8<<8))

#define SQLITE_IOERR_RDLOCK (SQLITE_IOERR | (9<<8))

#define SQLITE_IOERR_DELETE (SQLITE_IOERR | (10<<8))

#define SQLITE_IOERR_BLOCKED (SQLITE_IOERR | (11<<8))

#define SQLITE_IOERR_NOMEM (SQLITE_IOERR | (12<<8))

#define SQLITE_IOERR_ACCESS (SQLITE_IOERR | (13<<8))

#define SQLITE_IOERR_CHECKRESERVEDLOCK (SQLITE_IOERR | (14<<8))

#define SQLITE_IOERR_LOCK (SQLITE_IOERR | (15<<8))

#define SQLITE_IOERR_CLOSE (SQLITE_IOERR | (16<<8))

#define SQLITE_IOERR_DIR_CLOSE (SQLITE_IOERR | (17<<8))

#define SQLITE_IOERR_SHMOPEN (SQLITE_IOERR | (18<<8))

#define SQLITE_IOERR_SHMSIZE (SQLITE_IOERR | (19<<8))

#define SQLITE_IOERR_SHMLOCK (SQLITE_IOERR | (20<<8))

#define SQLITE_IOERR_SHMMAP (SQLITE_IOERR | (21<<8))

#define SQLITE_IOERR_SEEK (SQLITE_IOERR | (22<<8))

#define SQLITE_LOCKED_SHAREDCACHE (SQLITE_LOCKED | (1<<8))

#define SQLITE_BUSY_RECOVERY (SQLITE_BUSY | (1<<8))

#define SQLITE_CANTOPEN_NOTEMPDIR (SQLITE_CANTOPEN | (1<<8))

#define SQLITE_CORRUPT_VTAB (SQLITE_CORRUPT | (1<<8))

#define SQLITE_READONLY_RECOVERY (SQLITE_READONLY | (1<<8))

#define SQLITE_READONLY_CANTLOCK (SQLITE_READONLY | (2<<8))

** CAPI3REF: Flags For File Open Operations

** These bit values are intended for use in the

** 3rd parameter to the [sqlite3_open_v2()] interface and

** in the 4th parameter to the [sqlite3_vfs.xOpen] method.

#define SQLITE_OPEN_READONLY 0x00000001 /* Ok for sqlite3_open_v2() */

#define SQLITE_OPEN_READWRITE 0x00000002 /* Ok for sqlite3_open_v2() */

#define SQLITE_OPEN_CREATE 0x00000004 /* Ok for sqlite3_open_v2() */

#define SQLITE_OPEN_DELETEONCLOSE 0x00000008 /* VFS only */

#define SQLITE_OPEN_EXCLUSIVE 0x00000010 /* VFS only */

#define SQLITE_OPEN_AUTOPROXY 0x00000020 /* VFS only */

#define SQLITE_OPEN_URI 0x00000040 /* Ok for sqlite3_open_v2() */

#define SQLITE_OPEN_MAIN_DB 0x00000100 /* VFS only */

#define SQLITE_OPEN_TEMP_DB 0x00000200 /* VFS only */

#define SQLITE_OPEN_TRANSIENT_DB 0x00000400 /* VFS only */

#define SQLITE_OPEN_MAIN_JOURNAL 0x00000800 /* VFS only */

#define SQLITE_OPEN_TEMP_JOURNAL 0x00001000 /* VFS only */

#define SQLITE_OPEN_SUBJOURNAL 0x00002000 /* VFS only */

#define SQLITE_OPEN_MASTER_JOURNAL 0x00004000 /* VFS only */

#define SQLITE_OPEN_NOMUTEX 0x00008000 /* Ok for sqlite3_open_v2() */

#define SQLITE_OPEN_FULLMUTEX 0x00010000 /* Ok for sqlite3_open_v2() */

#define SQLITE_OPEN_SHAREDCACHE 0x00020000 /* Ok for sqlite3_open_v2() */

#define SQLITE_OPEN_PRIVATECACHE 0x00040000 /* Ok for sqlite3_open_v2() */

#define SQLITE_OPEN_WAL 0x00080000 /* VFS only */

/* Reserved: 0x00F00000 */

** CAPI3REF: Device Characteristics

** The xDeviceCharacteristics method of the [sqlite3_io_methods]

** object returns an integer which is a vector of the these

** bit values expressing I/O characteristics of the mass storage

** device that holds the file that the [sqlite3_io_methods]

** refers to.

** The SQLITE_IOCAP_ATOMIC property means that all writes of

** any size are atomic. The SQLITE_IOCAP_ATOMICnnn values

** mean that writes of blocks that are nnn bytes in size and

** are aligned to an address which is an integer multiple of

** nnn are atomic. The SQLITE_IOCAP_SAFE_APPEND value means

** that when data is appended to a file, the data is appended

** first then the size of the file is extended, never the other

** way around. The SQLITE_IOCAP_SEQUENTIAL property means that

** information is written to disk in the same order as calls

** to xWrite().

#define SQLITE_IOCAP_ATOMIC 0x00000001

#define SQLITE_IOCAP_ATOMIC512 0x00000002

#define SQLITE_IOCAP_ATOMIC1K 0x00000004

#define SQLITE_IOCAP_ATOMIC2K 0x00000008

#define SQLITE_IOCAP_ATOMIC4K 0x00000010

#define SQLITE_IOCAP_ATOMIC8K 0x00000020

#define SQLITE_IOCAP_ATOMIC16K 0x00000040

#define SQLITE_IOCAP_ATOMIC32K 0x00000080

#define SQLITE_IOCAP_ATOMIC64K 0x00000100

#define SQLITE_IOCAP_SAFE_APPEND 0x00000200

#define SQLITE_IOCAP_SEQUENTIAL 0x00000400

#define SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN 0x00000800

** CAPI3REF: File Locking Levels

** SQLite uses one of these integer values as the second

** argument to calls it makes to the xLock() and xUnlock() methods

** of an [sqlite3_io_methods] object.

#define SQLITE_LOCK_NONE 0

#define SQLITE_LOCK_SHARED 1

#define SQLITE_LOCK_RESERVED 2

#define SQLITE_LOCK_PENDING 3

#define SQLITE_LOCK_EXCLUSIVE 4

** CAPI3REF: Synchronization Type Flags

** When SQLite invokes the xSync() method of an

** [sqlite3_io_methods] object it uses a combination of

** these integer values as the second argument.

** When the SQLITE_SYNC_DATAONLY flag is used, it means that the

** sync operation only needs to flush data to mass storage. Inode

** information need not be flushed. If the lower four bits of the flag

** equal SQLITE_SYNC_NORMAL, that means to use normal fsync() semantics.

** If the lower four bits equal SQLITE_SYNC_FULL, that means

** to use Mac OS X style fullsync instead of fsync().

** Do not confuse the SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL flags

** with the [PRAGMA synchronous]=NORMAL and [PRAGMA synchronous]=FULL

** settings. The [synchronous pragma] determines when calls to the

** xSync VFS method occur and applies uniformly across all platforms.

** The SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL flags determine how

** energetic or rigorous or forceful the sync operations are and

** only make a difference on Mac OSX for the default SQLite code.

** (Third-party VFS implementations might also make the distinction

** between SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL, but among the

** operating systems natively supported by SQLite, only Mac OSX

** cares about the difference.)

#define SQLITE_SYNC_NORMAL 0x00002

#define SQLITE_SYNC_FULL 0x00003

#define SQLITE_SYNC_DATAONLY 0x00010

** CAPI3REF: OS Interface Open File Handle

** An [sqlite3_file] object represents an open file in the

** [sqlite3_vfs | OS interface layer]. Individual OS interface

** implementations will

** want to subclass this object by appending additional fields

** for their own use. The pMethods entry is a pointer to an

** [sqlite3_io_methods] object that defines methods for performing

** I/O operations on the open file.

typedef struct sqlite3_file sqlite3_file;

struct sqlite3_file {

const struct sqlite3_io_methods *pMethods; /* Methods for an open file */

};

** CAPI3REF: OS Interface File Virtual Methods Object

** Every file opened by the [sqlite3_vfs.xOpen] method populates an

** [sqlite3_file] object (or, more commonly, a subclass of the

** [sqlite3_file] object) with a pointer to an instance of this object.

** This object defines the methods used to perform various operations

** against the open file represented by the [sqlite3_file] object.

** If the [sqlite3_vfs.xOpen] method sets the sqlite3_file.pMethods element

** to a non-NULL pointer, then the sqlite3_io_methods.xClose method

** may be invoked even if the [sqlite3_vfs.xOpen] reported that it failed. The

** only way to prevent a call to xClose following a failed [sqlite3_vfs.xOpen]

** is for the [sqlite3_vfs.xOpen] to set the sqlite3_file.pMethods element

** to NULL.

** The flags argument to xSync may be one of [SQLITE_SYNC_NORMAL] or

** [SQLITE_SYNC_FULL]. The first choice is the normal fsync().

** The second choice is a Mac OS X style fullsync. The [SQLITE_SYNC_DATAONLY]

** flag may be ORed in to indicate that only the data of the file

** and not its inode needs to be synced.

** The integer values to xLock() and xUnlock() are one of

** <ul>

** <li> [SQLITE_LOCK_NONE],

** <li> [SQLITE_LOCK_SHARED],

** <li> [SQLITE_LOCK_RESERVED],

** <li> [SQLITE_LOCK_PENDING], or

** <li> [SQLITE_LOCK_EXCLUSIVE].

** </ul>

** xLock() increases the lock. xUnlock() decreases the lock.

** The xCheckReservedLock() method checks whether any database connection,

** either in this process or in some other process, is holding a RESERVED,

** PENDING, or EXCLUSIVE lock on the file. It returns true

** if such a lock exists and false otherwise.

** The xFileControl() method is a generic interface that allows custom

** VFS implementations to directly control an open file using the

** [sqlite3_file_control()] interface. The second "op" argument is an

** integer opcode. The third argument is a generic pointer intended to

** point to a structure that may contain arguments or space in which to

** write return values. Potential uses for xFileControl() might be

** functions to enable blocking locks with timeouts, to change the

** locking strategy (for example to use dot-file locks), to inquire

** about the status of a lock, or to break stale locks. The SQLite

** core reserves all opcodes less than 100 for its own use.

** A [SQLITE_FCNTL_LOCKSTATE | list of opcodes] less than 100 is available.

** Applications that define a custom xFileControl method should use opcodes

** greater than 100 to avoid conflicts. VFS implementations should

** return [SQLITE_NOTFOUND] for file control opcodes that they do not

** recognize.

** The xSectorSize() method returns the sector size of the

** device that underlies the file. The sector size is the

** minimum write that can be performed without disturbing

** other bytes in the file. The xDeviceCharacteristics()

** method returns a bit vector describing behaviors of the

** underlying device:

** <ul>

** <li> [SQLITE_IOCAP_ATOMIC]

** <li> [SQLITE_IOCAP_ATOMIC512]

** <li> [SQLITE_IOCAP_ATOMIC1K]

** <li> [SQLITE_IOCAP_ATOMIC2K]

** <li> [SQLITE_IOCAP_ATOMIC4K]

** <li> [SQLITE_IOCAP_ATOMIC8K]

** <li> [SQLITE_IOCAP_ATOMIC16K]

** <li> [SQLITE_IOCAP_ATOMIC32K]

** <li> [SQLITE_IOCAP_ATOMIC64K]

** <li> [SQLITE_IOCAP_SAFE_APPEND]

** <li> [SQLITE_IOCAP_SEQUENTIAL]

** </ul>

** The SQLITE_IOCAP_ATOMIC property means that all writes of

** any size are atomic. The SQLITE_IOCAP_ATOMICnnn values

** mean that writes of blocks that are nnn bytes in size and

** are aligned to an address which is an integer multiple of

** nnn are atomic. The SQLITE_IOCAP_SAFE_APPEND value means

** that when data is appended to a file, the data is appended

** first then the size of the file is extended, never the other

** way around. The SQLITE_IOCAP_SEQUENTIAL property means that

** information is written to disk in the same order as calls

** to xWrite().

** If xRead() returns SQLITE_IOERR_SHORT_READ it must also fill

** in the unread portions of the buffer with zeros. A VFS that

** fails to zero-fill short reads might seem to work. However,

** failure to zero-fill short reads will eventually lead to

** database corruption.

typedef struct sqlite3_io_methods sqlite3_io_methods;

struct sqlite3_io_methods {

int iVersion;

int (*xClose)(sqlite3_file*);

int (*xRead)(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst);

int (*xWrite)(sqlite3_file*, const void*, int iAmt, sqlite3_int64 iOfst);

int (*xTruncate)(sqlite3_file*, sqlite3_int64 size);

int (*xSync)(sqlite3_file*, int flags);

int (*xFileSize)(sqlite3_file*, sqlite3_int64 *pSize);

int (*xLock)(sqlite3_file*, int);

int (*xUnlock)(sqlite3_file*, int);

int (*xCheckReservedLock)(sqlite3_file*, int *pResOut);

int (*xFileControl)(sqlite3_file*, int op, void *pArg);

int (*xSectorSize)(sqlite3_file*);

int (*xDeviceCharacteristics)(sqlite3_file*);

/* Methods above are valid for version 1 */

int (*xShmMap)(sqlite3_file*, int iPg, int pgsz, int, void volatile**);

int (*xShmLock)(sqlite3_file*, int offset, int n, int flags);

void (*xShmBarrier)(sqlite3_file*);

int (*xShmUnmap)(sqlite3_file*, int deleteFlag);

/* Methods above are valid for version 2 */

/* Additional methods may be added in future releases */

};

** CAPI3REF: Standard File Control Opcodes

** These integer constants are opcodes for the xFileControl method

** of the [sqlite3_io_methods] object and for the [sqlite3_file_control()]

** interface.

** The [SQLITE_FCNTL_LOCKSTATE] opcode is used for debugging. This

** opcode causes the xFileControl method to write the current state of

** the lock (one of [SQLITE_LOCK_NONE], [SQLITE_LOCK_SHARED],

** [SQLITE_LOCK_RESERVED], [SQLITE_LOCK_PENDING], or [SQLITE_LOCK_EXCLUSIVE])

** into an integer that the pArg argument points to. This capability

** is used during testing and only needs to be supported when SQLITE_TEST

** is defined.

** The [SQLITE_FCNTL_SIZE_HINT] opcode is used by SQLite to give the VFS

** layer a hint of how large the database file will grow to be during the

** current transaction. This hint is not guaranteed to be accurate but it

** is often close. The underlying VFS might choose to preallocate database

** file space based on this hint in order to help writes to the database

** file run faster.

** The [SQLITE_FCNTL_CHUNK_SIZE] opcode is used to request that the VFS

** extends and truncates the database file in chunks of a size specified

** by the user. The fourth argument to [sqlite3_file_control()] should

** point to an integer (type int) containing the new chunk-size to use

** for the nominated database. Allocating database file space in large

** chunks (say 1MB at a time), may reduce file-system fragmentation and

** improve performance on some systems.

** The [SQLITE_FCNTL_FILE_POINTER] opcode is used to obtain a pointer

** to the [sqlite3_file] object associated with a particular database

** connection. See the [sqlite3_file_control()] documentation for

** additional information.

** ^(The [SQLITE_FCNTL_SYNC_OMITTED] opcode is generated internally by

** SQLite and sent to all VFSes in place of a call to the xSync method

** when the database connection has [PRAGMA synchronous] set to OFF.)^

** Some specialized VFSes need this signal in order to operate correctly

** when [PRAGMA synchronous | PRAGMA synchronous=OFF] is set, but most

** VFSes do not need this signal and should silently ignore this opcode.

** Applications should not call [sqlite3_file_control()] with this

** opcode as doing so may disrupt the operation of the specialized VFSes

** that do require it.

#define SQLITE_FCNTL_LOCKSTATE 1

#define SQLITE_GET_LOCKPROXYFILE 2

#define SQLITE_SET_LOCKPROXYFILE 3

#define SQLITE_LAST_ERRNO 4

#define SQLITE_FCNTL_SIZE_HINT 5

#define SQLITE_FCNTL_CHUNK_SIZE 6

#define SQLITE_FCNTL_FILE_POINTER 7

#define SQLITE_FCNTL_SYNC_OMITTED 8

** CAPI3REF: Mutex Handle

** The mutex module within SQLite defines [sqlite3_mutex] to be an

** abstract type for a mutex object. The SQLite core never looks

** at the internal representation of an [sqlite3_mutex]. It only

** deals with pointers to the [sqlite3_mutex] object.

** Mutexes are created using [sqlite3_mutex_alloc()].

typedef struct sqlite3_mutex sqlite3_mutex;

** CAPI3REF: OS Interface Object

** An instance of the sqlite3_vfs object defines the interface between

** the SQLite core and the underlying operating system. The "vfs"

** in the name of the object stands for "virtual file system". See

** the [VFS | VFS documentation] for further information.

** The value of the iVersion field is initially 1 but may be larger in

** future versions of SQLite. Additional fields may be appended to this

** object when the iVersion value is increased. Note that the structure

** of the sqlite3_vfs object changes in the transaction between

** SQLite version 3.5.9 and 3.6.0 and yet the iVersion field was not

** modified.

** The szOsFile field is the size of the subclassed [sqlite3_file]

** structure used by this VFS. mxPathname is the maximum length of

** a pathname in this VFS.

** Registered sqlite3_vfs objects are kept on a linked list formed by

** the pNext pointer. The [sqlite3_vfs_register()]

** and [sqlite3_vfs_unregister()] interfaces manage this list

** in a thread-safe way. The [sqlite3_vfs_find()] interface

** searches the list. Neither the application code nor the VFS

** implementation should use the pNext pointer.

** The pNext field is the only field in the sqlite3_vfs

** structure that SQLite will ever modify. SQLite will only access

** or modify this field while holding a particular static mutex.

** The application should never modify anything within the sqlite3_vfs

** object once the object has been registered.

** The zName field holds the name of the VFS module. The name must

** be unique across all VFS modules.

** [[sqlite3_vfs.xOpen]]

** ^SQLite guarantees that the zFilename parameter to xOpen

** is either a NULL pointer or string obtained

** from xFullPathname() with an optional suffix added.

** ^If a suffix is added to the zFilename parameter, it will

** consist of a single "-" character followed by no more than

** 10 alphanumeric and/or "-" characters.

** ^SQLite further guarantees that

** the string will be valid and unchanged until xClose() is

** called. Because of the previous sentence,

** the [sqlite3_file] can safely store a pointer to the

** filename if it needs to remember the filename for some reason.

** If the zFilename parameter to xOpen is a NULL pointer then xOpen

** must invent its own temporary name for the file. ^Whenever the

** xFilename parameter is NULL it will also be the case that the

** flags parameter will include [SQLITE_OPEN_DELETEONCLOSE].

** The flags argument to xOpen() includes all bits set in

** the flags argument to [sqlite3_open_v2()]. Or if [sqlite3_open()]

** or [sqlite3_open16()] is used, then flags includes at least

** [SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE].

** If xOpen() opens a file read-only then it sets *pOutFlags to

** include [SQLITE_OPEN_READONLY]. Other bits in *pOutFlags may be set.

** ^(SQLite will also add one of the following flags to the xOpen()

** call, depending on the object being opened:

** <ul>

** <li> [SQLITE_OPEN_MAIN_DB]

** <li> [SQLITE_OPEN_MAIN_JOURNAL]

** <li> [SQLITE_OPEN_TEMP_DB]

** <li> [SQLITE_OPEN_TEMP_JOURNAL]

** <li> [SQLITE_OPEN_TRANSIENT_DB]

** <li> [SQLITE_OPEN_SUBJOURNAL]

** <li> [SQLITE_OPEN_MASTER_JOURNAL]

** <li> [SQLITE_OPEN_WAL]

** </ul>)^

** The file I/O implementation can use the object type flags to

** change the way it deals with files. For example, an application

** that does not care about crash recovery or rollback might make

** the open of a journal file a no-op. Writes to this journal would

** also be no-ops, and any attempt to read the journal would return

** SQLITE_IOERR. Or the implementation might recognize that a database

** file will be doing page-aligned sector reads and writes in a random

** order and set up its I/O subsystem accordingly.

** SQLite might also add one of the following flags to the xOpen method:

** <ul>

** <li> [SQLITE_OPEN_DELETEONCLOSE]

** <li> [SQLITE_OPEN_EXCLUSIVE]

** </ul>

** The [SQLITE_OPEN_DELETEONCLOSE] flag means the file should be

** deleted when it is closed. ^The [SQLITE_OPEN_DELETEONCLOSE]

** will be set for TEMP databases and their journals, transient

** databases, and subjournals.

** ^The [SQLITE_OPEN_EXCLUSIVE] flag is always used in conjunction

** with the [SQLITE_OPEN_CREATE] flag, which are both directly

** analogous to the O_EXCL and O_CREAT flags of the POSIX open()

** API. The SQLITE_OPEN_EXCLUSIVE flag, when paired with the

** SQLITE_OPEN_CREATE, is used to indicate that file should always

** be created, and that it is an error if it already exists.

** It is <i>not</i> used to indicate the file should be opened

** for exclusive access.

** ^At least szOsFile bytes of memory are allocated by SQLite

** to hold the [sqlite3_file] structure passed as the third

** argument to xOpen. The xOpen method does not have to

** allocate the structure; it should just fill it in. Note that

** the xOpen method must set the sqlite3_file.pMethods to either

** a valid [sqlite3_io_methods] object or to NULL. xOpen must do

** this even if the open fails. SQLite expects that the sqlite3_file.pMethods

** element will be valid after xOpen returns regardless of the success

** or failure of the xOpen call.

** [[sqlite3_vfs.xAccess]]

** ^The flags argument to xAccess() may be [SQLITE_ACCESS_EXISTS]

** to test for the existence of a file, or [SQLITE_ACCESS_READWRITE] to

** test whether a file is readable and writable, or [SQLITE_ACCESS_READ]

** to test whether a file is at least readable. The file can be a

** directory.

** ^SQLite will always allocate at least mxPathname+1 bytes for the

** output buffer xFullPathname. The exact size of the output buffer

** is also passed as a parameter to both methods. If the output buffer

** is not large enough, [SQLITE_CANTOPEN] should be returned. Since this is

** handled as a fatal error by SQLite, vfs implementations should endeavor

** to prevent this by setting mxPathname to a sufficiently large value.

** The xRandomness(), xSleep(), xCurrentTime(), and xCurrentTimeInt64()

** interfaces are not strictly a part of the filesystem, but they are

** included in the VFS structure for completeness.

** The xRandomness() function attempts to return nBytes bytes

** of good-quality randomness into zOut. The return value is

** the actual number of bytes of randomness obtained.

** The xSleep() method causes the calling thread to sleep for at

** least the number of microseconds given. ^The xCurrentTime()

** method returns a Julian Day Number for the current date and time as

** a floating point value.

** ^The xCurrentTimeInt64() method returns, as an integer, the Julian

** Day Number multiplied by 86400000 (the number of milliseconds in

** a 24-hour day).

** ^SQLite will use the xCurrentTimeInt64() method to get the current

** date and time if that method is available (if iVersion is 2 or

** greater and the function pointer is not NULL) and will fall back

** to xCurrentTime() if xCurrentTimeInt64() is unavailable.

** ^The xSetSystemCall(), xGetSystemCall(), and xNestSystemCall() interfaces

** are not used by the SQLite core. These optional interfaces are provided

** by some VFSes to facilitate testing of the VFS code. By overriding

** system calls with functions under its control, a test program can

** simulate faults and error conditions that would otherwise be difficult

** or impossible to induce. The set of system calls that can be overridden

** varies from one VFS to another, and from one version of the same VFS to the

** next. Applications that use these interfaces must be prepared for any

** or all of these interfaces to be NULL or for their behavior to change

** from one release to the next. Applications must not attempt to access

** any of these methods if the iVersion of the VFS is less than 3.

typedef struct sqlite3_vfs sqlite3_vfs;

typedef void (*sqlite3_syscall_ptr)(void);

struct sqlite3_vfs {

int iVersion; /* Structure version number (currently 3) */

int szOsFile; /* Size of subclassed sqlite3_file */

int mxPathname; /* Maximum file pathname length */

sqlite3_vfs *pNext; /* Next registered VFS */

const char *zName; /* Name of this virtual file system */

void *pAppData; /* Pointer to application-specific data */

int (*xOpen)(sqlite3_vfs*, const char *zName, sqlite3_file*,

int flags, int *pOutFlags);

int (*xDelete)(sqlite3_vfs*, const char *zName, int syncDir);

int (*xAccess)(sqlite3_vfs*, const char *zName, int flags, int *pResOut);

int (*xFullPathname)(sqlite3_vfs*, const char *zName, int nOut, char *zOut);

void *(*xDlOpen)(sqlite3_vfs*, const char *zFilename);

void (*xDlError)(sqlite3_vfs*, int nByte, char *zErrMsg);

void (*(*xDlSym)(sqlite3_vfs*,void*, const char *zSymbol))(void);

void (*xDlClose)(sqlite3_vfs*, void*);

int (*xRandomness)(sqlite3_vfs*, int nByte, char *zOut);

int (*xSleep)(sqlite3_vfs*, int microseconds);

int (*xCurrentTime)(sqlite3_vfs*, double*);

int (*xGetLastError)(sqlite3_vfs*, int, char *);

** The methods above are in version 1 of the sqlite_vfs object

** definition. Those that follow are added in version 2 or later

int (*xCurrentTimeInt64)(sqlite3_vfs*, sqlite3_int64*);

** The methods above are in versions 1 and 2 of the sqlite_vfs object.

** Those below are for version 3 and greater.

int (*xSetSystemCall)(sqlite3_vfs*, const char *zName, sqlite3_syscall_ptr);

sqlite3_syscall_ptr (*xGetSystemCall)(sqlite3_vfs*, const char *zName);

const char *(*xNextSystemCall)(sqlite3_vfs*, const char *zName);

** The methods above are in versions 1 through 3 of the sqlite_vfs object.

** New fields may be appended in figure versions. The iVersion

** value will increment whenever this happens.

};

** CAPI3REF: Flags for the xAccess VFS method

** These integer constants can be used as the third parameter to

** the xAccess method of an [sqlite3_vfs] object. They determine

** what kind of permissions the xAccess method is looking for.

** With SQLITE_ACCESS_EXISTS, the xAccess method

** simply checks whether the file exists.

** With SQLITE_ACCESS_READWRITE, the xAccess method

** checks whether the named directory is both readable and writable

** (in other words, if files can be added, removed, and renamed within

** the directory).

** The SQLITE_ACCESS_READWRITE constant is currently used only by the

** [temp_store_directory pragma], though this could change in a future

** release of SQLite.

** With SQLITE_ACCESS_READ, the xAccess method

** checks whether the file is readable. The SQLITE_ACCESS_READ constant is

** currently unused, though it might be used in a future release of

** SQLite.

#define SQLITE_ACCESS_EXISTS 0

#define SQLITE_ACCESS_READWRITE 1 /* Used by PRAGMA temp_store_directory */

#define SQLITE_ACCESS_READ 2 /* Unused */

** CAPI3REF: Flags for the xShmLock VFS method

** These integer constants define the various locking operations

** allowed by the xShmLock method of [sqlite3_io_methods]. The

** following are the only legal combinations of flags to the

** xShmLock method:

** <ul>

** <li> SQLITE_SHM_LOCK | SQLITE_SHM_SHARED

** <li> SQLITE_SHM_LOCK | SQLITE_SHM_EXCLUSIVE

** <li> SQLITE_SHM_UNLOCK | SQLITE_SHM_SHARED

View remainder of file in raw view

minetest/src/sqlite/sqlite3.h at master · basicinside/minetest · GitHub

Navigation Menu

Expand file tree

Breadcrumbs

sqlite3.h

Latest commit

History

Breadcrumbs

sqlite3.h

File metadata and controls

Footer

Footer navigation