-
Notifications
You must be signed in to change notification settings - Fork 37
Expand file tree
/
Copy pathsqlite3_h.cs
More file actions
executable file
·7214 lines (7014 loc) · 342 KB
/
sqlite3_h.cs
File metadata and controls
executable file
·7214 lines (7014 loc) · 342 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
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
using u8 = System.Byte;
using System.Diagnostics;
namespace System.Data.SQLite
{
public partial class Sqlite3
{
/*
** 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.
*************************************************************************
** Included in SQLite3 port to C#-SQLite; 2008 Noah B Hart
** C#-SQLite is an independent reimplementation of the SQLite software library
**
** SQLITE_SOURCE_ID: 2011-06-23 19:49:22 4374b7e83ea0a3fbc3691f9c0c936272862f32f2
**
*************************************************************************
*/
//#if !_SQLITE3_H_
//#define _SQLITE3_H_
//#include <stdarg.h> /* Needed for the definition of va_list */
/*
** Make sure we can call this stuff from C++.
*/
//#if __cplusplus
//extern "C" {
//#endif
/*
** Add the ability to override 'extern'
*/
//#if !SQLITE_EXTERN
//# define SQLITE_EXTERN extern
//#endif
//#if !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.
*/
//#if SQLITE_VERSION
//# undef SQLITE_VERSION
//#endif
//#if 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"
//#define SQLITE_VERSION_NUMBER 3007007
//#define SQLITE_SOURCE_ID "2011-06-23 19:49:22 4374b7e83ea0a3fbc3691f9c0c936272862f32f2"
const string SQLITE_VERSION = "3.7.7(C#)";
const int SQLITE_VERSION_NUMBER = 300700701;
const string SQLITE_SOURCE_ID = "Ported to C# from 2011-06-23 19:49:22 4374b7e83ea0a3fbc3691f9c0c936272862f32f2";
/*
** 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 */
public const int SQLITE_OK = 0;
public const int SQLITE_ERROR = 1;
public const int SQLITE_INTERNAL = 2;
public const int SQLITE_PERM = 3;
public const int SQLITE_ABORT = 4;
public const int SQLITE_BUSY = 5;
public const int SQLITE_LOCKED = 6;
public const int SQLITE_NOMEM = 7;
public const int SQLITE_READONLY = 8;
public const int SQLITE_INTERRUPT = 9;
public const int SQLITE_IOERR = 10;
public const int SQLITE_CORRUPT = 11;
public const int SQLITE_NOTFOUND = 12;
public const int SQLITE_FULL = 13;
public const int SQLITE_CANTOPEN = 14;
public const int SQLITE_PROTOCOL = 15;
public const int SQLITE_EMPTY = 16;
public const int SQLITE_SCHEMA = 17;
public const int SQLITE_TOOBIG = 18;
public const int SQLITE_CONSTRAINT = 19;
public const int SQLITE_MISMATCH = 20;
public const int SQLITE_MISUSE = 21;
public const int SQLITE_NOLFS = 22;
public const int SQLITE_AUTH = 23;
public const int SQLITE_FORMAT = 24;
public const int SQLITE_RANGE = 25;
public const int SQLITE_NOTADB = 26;
public const int SQLITE_ROW = 100;
public const int SQLITE_DONE = 101;
/*
** 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))
const int SQLITE_IOERR_READ = (SQLITE_IOERR | (1 << 8));
const int SQLITE_IOERR_SHORT_READ = (SQLITE_IOERR | (2 << 8));
const int SQLITE_IOERR_WRITE = (SQLITE_IOERR | (3 << 8));
const int SQLITE_IOERR_FSYNC = (SQLITE_IOERR | (4 << 8));
const int SQLITE_IOERR_DIR_FSYNC = (SQLITE_IOERR | (5 << 8));
const int SQLITE_IOERR_TRUNCATE = (SQLITE_IOERR | (6 << 8));
const int SQLITE_IOERR_FSTAT = (SQLITE_IOERR | (7 << 8));
const int SQLITE_IOERR_UNLOCK = (SQLITE_IOERR | (8 << 8));
const int SQLITE_IOERR_RDLOCK = (SQLITE_IOERR | (9 << 8));
const int SQLITE_IOERR_DELETE = (SQLITE_IOERR | (10 << 8));
const int SQLITE_IOERR_BLOCKED = (SQLITE_IOERR | (11 << 8));
const int SQLITE_IOERR_NOMEM = (SQLITE_IOERR | (12 << 8));
const int SQLITE_IOERR_ACCESS = (SQLITE_IOERR | (13 << 8));
const int SQLITE_IOERR_CHECKRESERVEDLOCK = (SQLITE_IOERR | (14 << 8));
const int SQLITE_IOERR_LOCK = (SQLITE_IOERR | (15 << 8));
const int SQLITE_IOERR_CLOSE = (SQLITE_IOERR | (16 << 8));
const int SQLITE_IOERR_DIR_CLOSE = (SQLITE_IOERR | (17 << 8));
const int SQLITE_IOERR_SHMOPEN = (SQLITE_IOERR | (18 << 8));
const int SQLITE_IOERR_SHMSIZE = (SQLITE_IOERR | (19 << 8));
const int SQLITE_IOERR_SHMLOCK = (SQLITE_IOERR | (20 << 8));
const int SQLITE_IOERR_SHMMAP = (SQLITE_IOERR | (21 << 8));
const int SQLITE_IOERR_SEEK = (SQLITE_IOERR | (22 << 8));
const int SQLITE_LOCKED_SHAREDCACHE = (SQLITE_LOCKED | (1 << 8));
const int SQLITE_BUSY_RECOVERY = (SQLITE_BUSY | (1 << 8));
const int SQLITE_CANTOPEN_NOTEMPDIR = (SQLITE_CANTOPEN | (1 << 8));
const int SQLITE_CORRUPT_VTAB = (SQLITE_CORRUPT | (1 << 8));
const int SQLITE_READONLY_RECOVERY = (SQLITE_READONLY | (1 << 8));
const int 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 */
public const int SQLITE_OPEN_READONLY = 0x00000001;
public const int SQLITE_OPEN_READWRITE = 0x00000002;
public const int SQLITE_OPEN_CREATE = 0x00000004;
public const int SQLITE_OPEN_DELETEONCLOSE = 0x00000008;
public const int SQLITE_OPEN_EXCLUSIVE = 0x00000010;
public const int SQLITE_OPEN_AUTOPROXY = 0x00000020;
public const int SQLITE_OPEN_URI = 0x00000040;
public const int SQLITE_OPEN_MAIN_DB = 0x00000100;
public const int SQLITE_OPEN_TEMP_DB = 0x00000200;
public const int SQLITE_OPEN_TRANSIENT_DB = 0x00000400;
public const int SQLITE_OPEN_MAIN_JOURNAL = 0x00000800;
public const int SQLITE_OPEN_TEMP_JOURNAL = 0x00001000;
public const int SQLITE_OPEN_SUBJOURNAL = 0x00002000;
public const int SQLITE_OPEN_MASTER_JOURNAL = 0x00004000;
public const int SQLITE_OPEN_NOMUTEX = 0x00008000;
public const int SQLITE_OPEN_FULLMUTEX = 0x00010000;
public const int SQLITE_OPEN_SHAREDCACHE = 0x00020000;
public const int SQLITE_OPEN_PRIVATECACHE = 0x00040000;
public const int SQLITE_OPEN_WAL = 0x00080000;
/*
** 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
const int SQLITE_IOCAP_ATOMIC = 0x00000001;
const int SQLITE_IOCAP_ATOMIC512 = 0x00000002;
const int SQLITE_IOCAP_ATOMIC1K = 0x00000004;
const int SQLITE_IOCAP_ATOMIC2K = 0x00000008;
const int SQLITE_IOCAP_ATOMIC4K = 0x00000010;
const int SQLITE_IOCAP_ATOMIC8K = 0x00000020;
const int SQLITE_IOCAP_ATOMIC16K = 0x00000040;
const int SQLITE_IOCAP_ATOMIC32K = 0x00000080;
const int SQLITE_IOCAP_ATOMIC64K = 0x00000100;
const int SQLITE_IOCAP_SAFE_APPEND = 0x00000200;
const int SQLITE_IOCAP_SEQUENTIAL = 0x00000400;
const int 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
const int SQLITE_LOCK_NONE = 0;
const int SQLITE_LOCK_SHARED = 1;
const int SQLITE_LOCK_RESERVED = 2;
const int SQLITE_LOCK_PENDING = 3;
const int 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
const int SQLITE_SYNC_NORMAL = 0x00002;
const int SQLITE_SYNC_FULL = 0x00003;
const int 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 */
//};
public partial class sqlite3_file
{
public sqlite3_io_methods pMethods;/* Must be first */
}
/*
** 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, object *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, object 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 */
//};
public class sqlite3_io_methods
{
public int iVersion;
public dxClose xClose;
public dxRead xRead;
public dxWrite xWrite;
public dxTruncate xTruncate;
public dxSync xSync;
public dxFileSize xFileSize;
public dxLock xLock;
public dxUnlock xUnlock;
public dxCheckReservedLock xCheckReservedLock;
public dxFileControl xFileControl;
public dxSectorSize xSectorSize;
public dxDeviceCharacteristics xDeviceCharacteristics;
public dxShmMap xShmMap;//int (*xShmMap)(sqlite3_file*, int iPg, int pgsz, int, object volatile*);
public dxShmLock xShmLock;//int (*xShmLock)(sqlite3_file*, int offset, int n, int flags);
public dxShmBarrier xShmBarrier;//void (*xShmBarrier)(sqlite3_file);
public dxShmUnmap xShmUnmap;//int (*xShmUnmap)(sqlite3_file*, int deleteFlag);
/* Additional methods may be added in future releases */
public sqlite3_io_methods(int iVersion,
dxClose xClose,
dxRead xRead,
dxWrite xWrite,
dxTruncate xTruncate,
dxSync xSync,
dxFileSize xFileSize,
dxLock xLock,
dxUnlock xUnlock,
dxCheckReservedLock xCheckReservedLock,
dxFileControl xFileControl,
dxSectorSize xSectorSize,
dxDeviceCharacteristics xDeviceCharacteristics,
dxShmMap xShmMap,
dxShmLock xShmLock,
dxShmBarrier xShmBarrier,
dxShmUnmap xShmUnmap
)
{
this.iVersion = iVersion;
this.xClose = xClose;
this.xRead = xRead;
this.xWrite = xWrite;
this.xTruncate = xTruncate;
this.xSync = xSync;
this.xFileSize = xFileSize;
this.xLock = xLock;
this.xUnlock = xUnlock;
this.xCheckReservedLock = xCheckReservedLock;
this.xFileControl = xFileControl;
this.xSectorSize = xSectorSize;
this.xDeviceCharacteristics = xDeviceCharacteristics;
this.xShmMap = xShmMap;
this.xShmLock = xShmLock;
this.xShmBarrier = xShmBarrier;
this.xShmUnmap = xShmUnmap;
}
}
/*
** 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
const int SQLITE_FCNTL_LOCKSTATE = 1;
const int SQLITE_GET_LOCKPROXYFILE = 2;
const int SQLITE_SET_LOCKPROXYFILE = 3;
const int SQLITE_LAST_ERRNO = 4;
const int SQLITE_FCNTL_SIZE_HINT = 5;
const int SQLITE_FCNTL_CHUNK_SIZE = 6;
const int SQLITE_FCNTL_FILE_POINTER = 7;
const int 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 */
// string zName; /* Name of this virtual file system */
// void *pAppData; /* Pointer to application-specific data */
// int (*xOpen)(sqlite3_vfs*, string zName, sqlite3_file*,
// int flags, int *pOutFlags);
// int (*xDelete)(sqlite3_vfs*, string zName, int syncDir);
// int (*xAccess)(sqlite3_vfs*, string zName, int flags, int *pResOut);
// int (*xFullPathname)(sqlite3_vfs*, string zName, int nOut, string zOut);
// void *(*xDlOpen)(sqlite3_vfs*, string zFilename);
// void (*xDlError)(sqlite3_vfs*, int nByte, string zErrMsg);
// void (*(*xDlSym)(sqlite3_vfs*,void*, string zSymbol))(void);
// void (*xDlClose)(sqlite3_vfs*, void);
// int (*xRandomness)(sqlite3_vfs*, int nByte, string 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.
// ** New fields may be appended in figure versions. The iVersion
// ** value will increment whenever this happens.
// */
//};
public class sqlite3_vfs
{
public int iVersion; /* Structure version number (currently 3) */
public int szOsFile; /* Size of subclassed sqlite3_file */
public int mxPathname; /* Maximum file pathname length */
public sqlite3_vfs pNext; /* Next registered VFS */
public string zName; /* Name of this virtual file system */
public object pAppData; /* Pointer to application-specific data */
public dxOpen xOpen;
public dxDelete xDelete;
public dxAccess xAccess;
public dxFullPathname xFullPathname;
public dxDlOpen xDlOpen;
public dxDlError xDlError;
public dxDlSym xDlSym;
public dxDlClose xDlClose;
public dxRandomness xRandomness;
public dxSleep xSleep;
public dxCurrentTime xCurrentTime;
public dxGetLastError xGetLastError;
/*
** The methods above are in version 1 of the sqlite_vfs object
** definition. Those that follow are added in version 2 or later
*/
public dxCurrentTimeInt64 xCurrentTimeInt64;
public sqlite3_vfs()
{
}
public sqlite3_vfs(int iVersion,
int szOsFile,
int mxPathname,
sqlite3_vfs pNext,
string zName,
object pAppData,
dxOpen xOpen,
dxDelete xDelete,
dxAccess xAccess,
dxFullPathname xFullPathname,
dxDlOpen xDlOpen,
dxDlError xDlError,
dxDlSym xDlSym,
dxDlClose xDlClose,
dxRandomness xRandomness,
dxSleep xSleep,
dxCurrentTime xCurrentTime,
dxGetLastError xGetLastError,
dxCurrentTimeInt64 xCurrentTimeInt64,
dxSetSystemCall xSetSystemCall,
dxGetSystemCall xGetSystemCall,
dxNextSystemCall xNextSystemCall)
{
this.iVersion = iVersion;
this.szOsFile = szOsFile;
this.mxPathname = mxPathname;
this.pNext = pNext;
this.zName = zName;
this.pAppData = pAppData;
this.xOpen = xOpen;
this.xDelete = xDelete;
this.xAccess = xAccess;
this.xFullPathname = xFullPathname;
this.xDlOpen = xDlOpen;
this.xDlError = xDlError;
this.xDlSym = xDlSym;
this.xDlClose = xDlClose;
this.xRandomness = xRandomness;
this.xSleep = xSleep;
this.xCurrentTime = xCurrentTime;
this.xGetLastError = xGetLastError;
this.xCurrentTimeInt64 = xCurrentTimeInt64;
}
public void CopyTo(sqlite3_vfs ct)
{
ct.iVersion = this.iVersion;
ct.szOsFile = this.szOsFile;
ct.mxPathname = this.mxPathname;
ct.pNext = this.pNext;
ct.zName = this.zName;
ct.pAppData = this.pAppData;
ct.xOpen = this.xOpen;
ct.xDelete = this.xDelete;
ct.xAccess = this.xAccess;
ct.xFullPathname = this.xFullPathname;
ct.xDlOpen = this.xDlOpen;
ct.xDlError = this.xDlError;
ct.xDlSym = this.xDlSym;
ct.xDlClose = this.xDlClose;
ct.xRandomness = this.xRandomness;
ct.xSleep = this.xSleep;
ct.xCurrentTime = this.xCurrentTime;
ct.xGetLastError = this.xGetLastError;
ct.xCurrentTimeInt64 = this.xCurrentTimeInt64;
}
}
/*
** 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.