{{ message }}
forked from IronLanguages/ironpython3
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathsqliteInt_h.cs
More file actions
4641 lines (4354 loc) · 192 KB
/
Copy pathsqliteInt_h.cs
File metadata and controls
4641 lines (4354 loc) · 192 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
#define SQLITE_MAX_EXPR_DEPTH
using System;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Text;
using Bitmask = System.UInt64;
using i16 = System.Int16;
using i64 = System.Int64;
using sqlite3_int64 = System.Int64;
using u8 = System.Byte;
using u16 = System.UInt16;
using u32 = System.UInt32;
using u64 = System.UInt64;
using unsigned = System.UInt64;
using Pgno = System.UInt32;
#if !SQLITE_MAX_VARIABLE_NUMBER
using ynVar = System.Int16;
#else
using ynVar = System.Int32;
#endif
/*
** The yDbMask datatype for the bitmask of all attached databases.
*/
#if SQLITE_MAX_ATTACHED//>30
// typedef sqlite3_uint64 yDbMask;
using yDbMask = System.Int64;
#else
// typedef unsigned int yDbMask;
using yDbMask = System.Int32;
#endif
namespace Community.CsharpSqlite
{
using sqlite3_value = Sqlite3.Mem;
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.
**
*************************************************************************
** Internal interface definitions for SQLite.
**
*************************************************************************
** 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 !_SQLITEINT_H_
//#define _SQLITEINT_H_
/*
** These #defines should enable >2GB file support on POSIX if the
** underlying operating system supports it. If the OS lacks
** large file support, or if the OS is windows, these should be no-ops.
**
** Ticket #2739: The _LARGEFILE_SOURCE macro must appear before any
** system #includes. Hence, this block of code must be the very first
** code in all source files.
**
** Large file support can be disabled using the -DSQLITE_DISABLE_LFS switch
** on the compiler command line. This is necessary if you are compiling
** on a recent machine (ex: Red Hat 7.2) but you want your code to work
** on an older machine (ex: Red Hat 6.0). If you compile on Red Hat 7.2
** without this option, LFS is enable. But LFS does not exist in the kernel
** in Red Hat 6.0, so the code won't work. Hence, for maximum binary
** portability you should omit LFS.
**
** Similar is true for Mac OS X. LFS is only supported on Mac OS X 9 and later.
*/
//#if !SQLITE_DISABLE_LFS
//# define _LARGE_FILE 1
//# ifndef _FILE_OFFSET_BITS
//# define _FILE_OFFSET_BITS 64
//# endif
//# define _LARGEFILE_SOURCE 1
//#endif
/*
** Include the configuration header output by 'configure' if we're using the
** autoconf-based build
*/
#if _HAVE_SQLITE_CONFIG_H
//#include "config.h"
#endif
//#include "sqliteLimit.h"
/* Disable nuisance warnings on Borland compilers */
//#if (__BORLANDC__)
//#pragma warn -rch /* unreachable code */
//#pragma warn -ccc /* Condition is always true or false */
//#pragma warn -aus /* Assigned value is never used */
//#pragma warn -csu /* Comparing signed and unsigned */
//#pragma warn -spa /* Suspicious pointer arithmetic */
//#endif
/* Needed for various definitions... */
//#if !_GNU_SOURCE
//#define _GNU_SOURCE
//#endif
/*
** Include standard header files as necessary
*/
#if HAVE_STDINT_H
//#include <stdint.h>
#endif
#if HAVE_INTTYPES_H
//#include <inttypes.h>
#endif
/*
** The number of samples of an index that SQLite takes in order to
** construct a histogram of the table content when running ANALYZE
** and with SQLITE_ENABLE_STAT2
*/
//#define SQLITE_INDEX_SAMPLES 10
public const int SQLITE_INDEX_SAMPLES = 10;
/*
** The following macros are used to cast pointers to integers and
** integers to pointers. The way you do this varies from one compiler
** to the next, so we have developed the following set of #if statements
** to generate appropriate macros for a wide range of compilers.
**
** The correct "ANSI" way to do this is to use the intptr_t type.
** Unfortunately, that typedef is not available on all compilers, or
** if it is available, it requires an #include of specific headers
** that vary from one machine to the next.
**
** Ticket #3860: The llvm-gcc-4.2 compiler from Apple chokes on
** the ((void)&((char)0)[X]) construct. But MSVC chokes on ((void)(X)).
** So we have to define the macros in different ways depending on the
** compiler.
*/
//#if (__PTRDIFF_TYPE__) /* This case should work for GCC */
//# define SQLITE_INT_TO_PTR(X) ((void)(__PTRDIFF_TYPE__)(X))
//# define SQLITE_PTR_TO_INT(X) ((int)(__PTRDIFF_TYPE__)(X))
//#elif !defined(__GNUC__) /* Works for compilers other than LLVM */
//# define SQLITE_INT_TO_PTR(X) ((void)&((char)0)[X])
//# define SQLITE_PTR_TO_INT(X) ((int)(((char)X)-(char)0))
//#elif defined(HAVE_STDINT_H) /* Use this case if we have ANSI headers */
//# define SQLITE_INT_TO_PTR(X) ((void)(intptr_t)(X))
//# define SQLITE_PTR_TO_INT(X) ((int)(intptr_t)(X))
//#else /* Generates a warning - but it always works */
//# define SQLITE_INT_TO_PTR(X) ((void)(X))
//# define SQLITE_PTR_TO_INT(X) ((int)(X))
//#endif
/*
** The SQLITE_THREADSAFE macro must be defined as 0, 1, or 2.
** 0 means mutexes are permanently disable and the library is never
** threadsafe. 1 means the library is serialized which is the highest
** level of threadsafety. 2 means the libary is multithreaded - multiple
** threads can use SQLite as long as no two threads try to use the same
** database connection at the same time.
**
** Older versions of SQLite used an optional THREADSAFE macro.
** We support that for legacy.
*/
#if !SQLITE_THREADSAFE
//# define SQLITE_THREADSAFE 2
const int SQLITE_THREADSAFE = 2;
#else
const int SQLITE_THREADSAFE = 2; /* IMP: R-07272-22309 */
#endif
/*
** The SQLITE_DEFAULT_MEMSTATUS macro must be defined as either 0 or 1.
** It determines whether or not the features related to
** SQLITE_CONFIG_MEMSTATUS are available by default or not. This value can
** be overridden at runtime using the sqlite3_config() API.
*/
#if !(SQLITE_DEFAULT_MEMSTATUS)
//# define SQLITE_DEFAULT_MEMSTATUS 1
const int SQLITE_DEFAULT_MEMSTATUS = 0;
#else
const int SQLITE_DEFAULT_MEMSTATUS = 1;
#endif
/*
** Exactly one of the following macros must be defined in order to
** specify which memory allocation subsystem to use.
**
** SQLITE_SYSTEM_MALLOC // Use normal system malloc()
** SQLITE_MEMDEBUG // Debugging version of system malloc()
**
** (Historical note: There used to be several other options, but we've
** pared it down to just these two.)
**
** If none of the above are defined, then set SQLITE_SYSTEM_MALLOC as
** the default.
*/
//#if (SQLITE_SYSTEM_MALLOC)+defined(SQLITE_MEMDEBUG)+\
//# error "At most one of the following compile-time configuration options\
// is allows: SQLITE_SYSTEM_MALLOC, SQLITE_MEMDEBUG"
//#endif
//#if (SQLITE_SYSTEM_MALLOC)+defined(SQLITE_MEMDEBUG)+\
//# define SQLITE_SYSTEM_MALLOC 1
//#endif
/*
** If SQLITE_MALLOC_SOFT_LIMIT is not zero, then try to keep the
** sizes of memory allocations below this value where possible.
*/
#if !(SQLITE_MALLOC_SOFT_LIMIT)
const int SQLITE_MALLOC_SOFT_LIMIT = 1024;
#endif
/*
** We need to define _XOPEN_SOURCE as follows in order to enable
** recursive mutexes on most Unix systems. But Mac OS X is different.
** The _XOPEN_SOURCE define causes problems for Mac OS X we are told,
** so it is omitted there. See ticket #2673.
**
** Later we learn that _XOPEN_SOURCE is poorly or incorrectly
** implemented on some systems. So we avoid defining it at all
** if it is already defined or if it is unneeded because we are
** not doing a threadsafe build. Ticket #2681.
**
** See also ticket #2741.
*/
#if !_XOPEN_SOURCE && !__DARWIN__ && !__APPLE__ && SQLITE_THREADSAFE
const int _XOPEN_SOURCE = 500;//#define _XOPEN_SOURCE 500 /* Needed to enable pthread recursive mutexes */
#endif
/*
** The TCL headers are only needed when compiling the TCL bindings.
*/
#if SQLITE_TCL || TCLSH
//# include <tcl.h>
#endif
/*
** Many people are failing to set -DNDEBUG=1 when compiling SQLite.
** Setting NDEBUG makes the code smaller and run faster. So the following
** lines are added to automatically set NDEBUG unless the -DSQLITE_DEBUG=1
** option is set. Thus NDEBUG becomes an opt-in rather than an opt-out
** feature.
*/
#if !NDEBUG && !SQLITE_DEBUG
const int NDEBUG = 1;//# define NDEBUG 1
#endif
/*
** The testcase() macro is used to aid in coverage testing. When
** doing coverage testing, the condition inside the argument to
** testcase() must be evaluated both true and false in order to
** get full branch coverage. The testcase() macro is inserted
** to help ensure adequate test coverage in places where simple
** condition/decision coverage is inadequate. For example, testcase()
** can be used to make sure boundary values are tested. For
** bitmask tests, testcase() can be used to make sure each bit
** is significant and used at least once. On switch statements
** where multiple cases go to the same block of code, testcase()
** can insure that all cases are evaluated.
**
*/
#if SQLITE_COVERAGE_TEST
void sqlite3Coverage(int);
//# define testcase(X) if( X ){ sqlite3Coverage(__LINE__); }
#else
//# define testcase(X)
static void testcase<T>( T X )
{
}
#endif
/*
** The TESTONLY macro is used to enclose variable declarations or
** other bits of code that are needed to support the arguments
** within testcase() and Debug.Assert() macros.
*/
#if !NDEBUG || SQLITE_COVERAGE_TEST
//# define TESTONLY(X) X
// -- Need workaround for C#, since inline macros don't exist
#else
//# define TESTONLY(X)
#endif
/*
** Sometimes we need a small amount of code such as a variable initialization
** to setup for a later Debug.Assert() statement. We do not want this code to
** appear when Debug.Assert() is disabled. The following macro is therefore
** used to contain that setup code. The "VVA" acronym stands for
** "Verification, Validation, and Accreditation". In other words, the
** code within VVA_ONLY() will only run during verification processes.
*/
#if !NDEBUG
//# define VVA_ONLY(X) X
#else
//# define VVA_ONLY(X)
#endif
/*
** The ALWAYS and NEVER macros surround boolean expressions which
** are intended to always be true or false, respectively. Such
** expressions could be omitted from the code completely. But they
** are included in a few cases in order to enhance the resilience
** of SQLite to unexpected behavior - to make the code "self-healing"
** or "ductile" rather than being "brittle" and crashing at the first
** hint of unplanned behavior.
**
** In other words, ALWAYS and NEVER are added for defensive code.
**
** When doing coverage testing ALWAYS and NEVER are hard-coded to
** be true and false so that the unreachable code then specify will
** not be counted as untested code.
*/
#if SQLITE_COVERAGE_TEST
//# define ALWAYS(X) (1)
//# define NEVER(X) (0)
#elif !NDEBUG
//# define ALWAYS(X) ((X)?1:(Debug.Assert(0),0))
static bool ALWAYS( bool X )
{
if ( X != true )
Debug.Assert( false );
return true;
}
static int ALWAYS( int X )
{
if ( X == 0 )
Debug.Assert( false );
return 1;
}
static bool ALWAYS<T>( T X )
{
if ( X == null )
Debug.Assert( false );
return true;
}
//# define NEVER(X) ((X)?(Debug.Assert(0),1):0)
static bool NEVER( bool X )
{
if ( X == true )
Debug.Assert( false );
return false;
}
static byte NEVER( byte X )
{
if ( X != 0 )
Debug.Assert( false );
return 0;
}
static int NEVER( int X )
{
if ( X != 0 )
Debug.Assert( false );
return 0;
}
static bool NEVER<T>( T X )
{
if ( X != null )
Debug.Assert( false );
return false;
}
#else
//# define ALWAYS(X) (X)
static bool ALWAYS(bool X) { return X; }
static byte ALWAYS(byte X) { return X; }
static int ALWAYS(int X) { return X; }
static bool ALWAYS<T>( T X ) { return true; }
//# define NEVER(X) (X)
static bool NEVER(bool X) { return X; }
static byte NEVER(byte X) { return X; }
static int NEVER(int X) { return X; }
static bool NEVER<T>(T X) { return false; }
#endif
/*
** Return true (non-zero) if the input is a integer that is too large
** to fit in 32-bits. This macro is used inside of various testcase()
** macros to verify that we have tested SQLite for large-file support.
*/
static bool IS_BIG_INT( i64 X )
{
return ( ( ( X ) & ~(i64)0xffffffff ) != 0 );
}//#define IS_BIG_INT(X) (((X)&~(i64)0xffffffff)!=0)
/*
** The macro unlikely() is a hint that surrounds a boolean
** expression that is usually false. Macro likely() surrounds
** a boolean expression that is usually true. GCC is able to
** use these hints to generate better code, sometimes.
*/
#if (__GNUC__) && FALSE
//# define likely(X) __builtin_expect((X),1)
//# define unlikely(X) __builtin_expect((X),0)
#else
//# define likely(X) !!(X)
static bool likely( bool X )
{
return !!X;
}
//# define unlikely(X) !!(X)
static bool unlikely( bool X )
{
return !!X;
}
#endif
//#include "sqlite3.h"
//#include "hash.h"
//#include "parse.h"
//#include <stdio.h>
//#include <stdlib.h>
//#include <string.h>
//#include <assert.h>
//#include <stddef.h>
/*
** If compiling for a processor that lacks floating point support,
** substitute integer for floating-point
*/
#if SQLITE_OMIT_FLOATING_POINT
//# define double sqlite_int64
//# define float sqlite_int64
//# define LONGDOUBLE_TYPE sqlite_int64
//#if !SQLITE_BIG_DBL
//# define SQLITE_BIG_DBL (((sqlite3_int64)1)<<50)
//# endif
//# define SQLITE_OMIT_DATETIME_FUNCS 1
//# define SQLITE_OMIT_TRACE 1
//# undef SQLITE_MIXED_ENDIAN_64BIT_FLOAT
//# undef SQLITE_HAVE_ISNAN
#endif
#if !SQLITE_BIG_DBL
const double SQLITE_BIG_DBL = ( ( (sqlite3_int64)1 ) << 60 );//# define SQLITE_BIG_DBL (1e99)
#endif
/*
** OMIT_TEMPDB is set to 1 if SQLITE_OMIT_TEMPDB is defined, or 0
** afterward. Having this macro allows us to cause the C compiler
** to omit code used by TEMP tables without messy #if !statements.
*/
#if SQLITE_OMIT_TEMPDB
//#define OMIT_TEMPDB 1
#else
static int OMIT_TEMPDB = 0;
#endif
/*
** The "file format" number is an integer that is incremented whenever
** the VDBE-level file format changes. The following macros define the
** the default file format for new databases and the maximum file format
** that the library can read.
*/
static public int SQLITE_MAX_FILE_FORMAT = 4;//#define SQLITE_MAX_FILE_FORMAT 4
//#if !SQLITE_DEFAULT_FILE_FORMAT
static int SQLITE_DEFAULT_FILE_FORMAT = 1;//# define SQLITE_DEFAULT_FILE_FORMAT 1
//#endif
/*
** Determine whether triggers are recursive by default. This can be
** changed at run-time using a pragma.
*/
#if !SQLITE_DEFAULT_RECURSIVE_TRIGGERS
//# define SQLITE_DEFAULT_RECURSIVE_TRIGGERS 0
static public bool SQLITE_DEFAULT_RECURSIVE_TRIGGERS = false;
#else
static public bool SQLITE_DEFAULT_RECURSIVE_TRIGGERS = true;
#endif
/*
** Provide a default value for SQLITE_TEMP_STORE in case it is not specified
** on the command-line
*/
//#if !SQLITE_TEMP_STORE
static int SQLITE_TEMP_STORE = 1;//#define SQLITE_TEMP_STORE 1
//#endif
/*
** GCC does not define the offsetof() macro so we'll have to do it
** ourselves.
*/
#if !offsetof
//#define offsetof(STRUCTURE,FIELD) ((int)((char)&((STRUCTURE)0)->FIELD))
#endif
/*
** Check to see if this machine uses EBCDIC. (Yes, believe it or
** not, there are still machines out there that use EBCDIC.)
*/
#if FALSE //'A' == '\301'
//# define SQLITE_EBCDIC 1
#else
const int SQLITE_ASCII = 1;//#define SQLITE_ASCII 1
#endif
/*
** Integers of known sizes. These typedefs might change for architectures
** where the sizes very. Preprocessor macros are available so that the
** types can be conveniently redefined at compile-type. Like this:
**
** cc '-Du32PTR_TYPE=long long int' ...
*/
//#if !u32_TYPE
//# ifdef HAVE_u32_T
//# define u32_TYPE u32_t
//# else
//# define u32_TYPE unsigned int
//# endif
//#endif
//#if !u3216_TYPE
//# ifdef HAVE_u3216_T
//# define u3216_TYPE u3216_t
//# else
//# define u3216_TYPE unsigned short int
//# endif
//#endif
//#if !INT16_TYPE
//# ifdef HAVE_INT16_T
//# define INT16_TYPE int16_t
//# else
//# define INT16_TYPE short int
//# endif
//#endif
//#if !u328_TYPE
//# ifdef HAVE_u328_T
//# define u328_TYPE u328_t
//# else
//# define u328_TYPE unsigned char
//# endif
//#endif
//#if !INT8_TYPE
//# ifdef HAVE_INT8_T
//# define INT8_TYPE int8_t
//# else
//# define INT8_TYPE signed char
//# endif
//#endif
//#if !LONGDOUBLE_TYPE
//# define LONGDOUBLE_TYPE long double
//#endif
//typedef sqlite_int64 i64; /* 8-byte signed integer */
//typedef sqlite_u3264 u64; /* 8-byte unsigned integer */
//typedef u32_TYPE u32; /* 4-byte unsigned integer */
//typedef u3216_TYPE u16; /* 2-byte unsigned integer */
//typedef INT16_TYPE i16; /* 2-byte signed integer */
//typedef u328_TYPE u8; /* 1-byte unsigned integer */
//typedef INT8_TYPE i8; /* 1-byte signed integer */
/*
** SQLITE_MAX_U32 is a u64 constant that is the maximum u64 value
** that can be stored in a u32 without loss of data. The value
** is 0x00000000ffffffff. But because of quirks of some compilers, we
** have to specify the value in the less intuitive manner shown:
*/
//#define SQLITE_MAX_U32 ((((u64)1)<<32)-1)
const u32 SQLITE_MAX_U32 = (u32)( ( ( (u64)1 ) << 32 ) - 1 );
/*
** Macros to determine whether the machine is big or little endian,
** evaluated at runtime.
*/
#if SQLITE_AMALGAMATION
//const int sqlite3one = 1;
#else
const bool sqlite3one = true;
#endif
#if i386 || __i386__ || _M_IX86
const int ;//#define SQLITE_BIGENDIAN 0
const int ;//#define SQLITE_LITTLEENDIAN 1
const int ;//#define SQLITE_UTF16NATIVE SQLITE_UTF16LE
#else
static u8 SQLITE_BIGENDIAN = 0;//#define SQLITE_BIGENDIAN (*(char )(&sqlite3one)==0)
static u8 SQLITE_LITTLEENDIAN = 1;//#define SQLITE_LITTLEENDIAN (*(char )(&sqlite3one)==1)
static u8 SQLITE_UTF16NATIVE = ( SQLITE_BIGENDIAN != 0 ? SQLITE_UTF16BE : SQLITE_UTF16LE );//#define SQLITE_UTF16NATIVE (SQLITE_BIGENDIAN?SQLITE_UTF16BE:SQLITE_UTF16LE)
#endif
/*
** Constants for the largest and smallest possible 64-bit signed integers.
** These macros are designed to work correctly on both 32-bit and 64-bit
** compilers.
*/
//#define LARGEST_INT64 (0xffffffff|(((i64)0x7fffffff)<<32))
//#define SMALLEST_INT64 (((i64)-1) - LARGEST_INT64)
const i64 LARGEST_INT64 = i64.MaxValue;//( 0xffffffff | ( ( (i64)0x7fffffff ) << 32 ) );
const i64 SMALLEST_INT64 = i64.MinValue;//( ( ( i64 ) - 1 ) - LARGEST_INT64 );
/*
** Round up a number to the next larger multiple of 8. This is used
** to force 8-byte alignment on 64-bit architectures.
*/
//#define ROUND8(x) (((x)+7)&~7)
static int ROUND8( int x )
{
return ( x + 7 ) & ~7;
}
/*
** Round down to the nearest multiple of 8
*/
//#define ROUNDDOWN8(x) ((x)&~7)
static int ROUNDDOWN8( int x )
{
return x & ~7;
}
/*
** Assert that the pointer X is aligned to an 8-byte boundary. This
** macro is used only within Debug.Assert() to verify that the code gets
** all alignment restrictions correct.
**
** Except, if SQLITE_4_BYTE_ALIGNED_MALLOC is defined, then the
** underlying malloc() implemention might return us 4-byte aligned
** pointers. In that case, only verify 4-byte alignment.
*/
//#if SQLITE_4_BYTE_ALIGNED_MALLOC
//# define EIGHT_BYTE_ALIGNMENT(X) ((((char)(X) - (char)0)&3)==0)
//#else
//# define EIGHT_BYTE_ALIGNMENT(X) ((((char)(X) - (char)0)&7)==0)
//#endif
/*
** An instance of the following structure is used to store the busy-handler
** callback for a given sqlite handle.
**
** The sqlite.busyHandler member of the sqlite struct contains the busy
** callback for the database handle. Each pager opened via the sqlite
** handle is passed a pointer to sqlite.busyHandler. The busy-handler
** callback is currently invoked only from within pager.c.
*/
//typedef struct BusyHandler BusyHandler;
public class BusyHandler
{
public dxBusy xFunc;//)(void *,int); /* The busy callback */
public object pArg; /* First arg to busy callback */
public int nBusy; /* Incremented with each busy call */
};
/*
** Name of the master database table. The master database table
** is a special table that holds the names and attributes of all
** user tables and indices.
*/
const string MASTER_NAME = "sqlite_master";//#define MASTER_NAME "sqlite_master"
const string TEMP_MASTER_NAME = "sqlite_temp_master";//#define TEMP_MASTER_NAME "sqlite_temp_master"
/*
** The root-page of the master database table.
*/
const int MASTER_ROOT = 1;//#define MASTER_ROOT 1
/*
** The name of the schema table.
*/
static string SCHEMA_TABLE( int x ) //#define SCHEMA_TABLE(x) ((!OMIT_TEMPDB)&&(x==1)?TEMP_MASTER_NAME:MASTER_NAME)
{
return ( ( OMIT_TEMPDB == 0 ) && ( x == 1 ) ? TEMP_MASTER_NAME : MASTER_NAME );
}
/*
** A convenience macro that returns the number of elements in
** an array.
*/
//#define ArraySize(X) ((int)(sizeof(X)/sizeof(X[0])))
static int ArraySize<T>( T[] x )
{
return x.Length;
}
/*
** The following value as a destructor means to use sqlite3DbFree().
** This is an internal extension to SQLITE_STATIC and SQLITE_TRANSIENT.
*/
//#define SQLITE_DYNAMIC ((sqlite3_destructor_type)sqlite3DbFree)
static dxDel SQLITE_DYNAMIC;
/*
** When SQLITE_OMIT_WSD is defined, it means that the target platform does
** not support Writable Static Data (WSD) such as global and static variables.
** All variables must either be on the stack or dynamically allocated from
** the heap. When WSD is unsupported, the variable declarations scattered
** throughout the SQLite code must become constants instead. The SQLITE_WSD
** macro is used for this purpose. And instead of referencing the variable
** directly, we use its constant as a key to lookup the run-time allocated
** buffer that holds real variable. The constant is also the initializer
** for the run-time allocated buffer.
**
** In the usual case where WSD is supported, the SQLITE_WSD and GLOBAL
** macros become no-ops and have zero performance impact.
*/
#if SQLITE_OMIT_WSD
//#define SQLITE_WSD const
//#define GLOBAL(t,v) (*(t)sqlite3_wsd_find((void)&(v), sizeof(v)))
//#define sqlite3GlobalConfig GLOBAL(struct Sqlite3Config, sqlite3Config)
int sqlite3_wsd_init(int N, int J);
void *sqlite3_wsd_find(void *K, int L);
#else
//#define SQLITE_WSD
//#define GLOBAL(t,v) v
//#define sqlite3GlobalConfig sqlite3Config
static Sqlite3Config sqlite3GlobalConfig;
#endif
/*
** The following macros are used to suppress compiler warnings and to
** make it clear to human readers when a function parameter is deliberately
** left unused within the body of a function. This usually happens when
** a function is called via a function pointer. For example the
** implementation of an SQL aggregate step callback may not use the
** parameter indicating the number of arguments passed to the aggregate,
** if it knows that this is enforced elsewhere.
**
** When a function parameter is not used at all within the body of a function,
** it is generally named "NotUsed" or "NotUsed2" to make things even clearer.
** However, these macros may also be used to suppress warnings related to
** parameters that may or may not be used depending on compilation options.
** For example those parameters only used in Debug.Assert() statements. In these
** cases the parameters are named as per the usual conventions.
*/
//#define UNUSED_PARAMETER(x) (void)(x)
static void UNUSED_PARAMETER<T>( T x )
{
}
//#define UNUSED_PARAMETER2(x,y) UNUSED_PARAMETER(x),UNUSED_PARAMETER(y)
static void UNUSED_PARAMETER2<T1, T2>( T1 x, T2 y )
{
UNUSED_PARAMETER( x );
UNUSED_PARAMETER( y );
}
/*
** Forward references to structures
*/
//typedef struct AggInfo AggInfo;
//typedef struct AuthContext AuthContext;
//typedef struct AutoincInfo AutoincInfo;
//typedef struct Bitvec Bitvec;
//typedef struct CollSeq CollSeq;
//typedef struct Column Column;
//typedef struct Db Db;
//typedef struct Schema Schema;
//typedef struct Expr Expr;
//typedef struct ExprList ExprList;
//typedef struct ExprSpan ExprSpan;
//typedef struct FKey FKey;
//typedef struct FuncDestructor FuncDestructor;
//typedef struct FuncDef FuncDef;
//typedef struct IdList IdList;
//typedef struct Index Index;
//typedef struct IndexSample IndexSample;
//typedef struct KeyClass KeyClass;
//typedef struct KeyInfo KeyInfo;
//typedef struct Lookaside Lookaside;
//typedef struct LookasideSlot LookasideSlot;
//typedef struct Module Module;
//typedef struct NameContext NameContext;
//typedef struct Parse Parse;
//typedef struct RowSet RowSet;
//typedef struct Savepoint Savepoint;
//typedef struct Select Select;
//typedef struct SrcList SrcList;
//typedef struct StrAccum StrAccum;
//typedef struct Table Table;
//typedef struct TableLock TableLock;
//typedef struct Token Token;
//typedef struct Trigger Trigger;
//typedef struct TriggerPrg TriggerPrg;
//typedef struct TriggerStep TriggerStep;
//typedef struct UnpackedRecord UnpackedRecord;
//typedef struct VTable VTable;
//typedef struct VtabCtx VtabCtx;
//typedef struct Walker Walker;
//typedef struct WherePlan WherePlan;
//typedef struct WhereInfo WhereInfo;
//typedef struct WhereLevel WhereLevel;
/*
** Defer sourcing vdbe.h and btree.h until after the "u8" and
** "BusyHandler" typedefs. vdbe.h also requires a few of the opaque
** pointer types (i.e. FuncDef) defined above.
*/
//#include "btree.h"
//#include "vdbe.h"
//#include "pager.h"
//#include "pcache_g.h"
//#include "os.h"
//#include "mutex.h"
/*
** Each database file to be accessed by the system is an instance
** of the following structure. There are normally two of these structures
** in the sqlite.aDb[] array. aDb[0] is the main database file and
** aDb[1] is the database file used to hold temporary tables. Additional
** databases may be attached.
*/
public class Db
{
public string zName; /* Name of this database */
public Btree pBt; /* The B Tree structure for this database file */
public u8 inTrans; /* 0: not writable. 1: Transaction. 2: Checkpoint */
public u8 safety_level; /* How aggressive at syncing data to disk */
public Schema pSchema; /* Pointer to database schema (possibly shared) */
};
/*
** An instance of the following structure stores a database schema.
**
** Most Schema objects are associated with a Btree. The exception is
** the Schema for the TEMP databaes (sqlite3.aDb[1]) which is free-standing.
** In shared cache mode, a single Schema object can be shared by multiple
** Btrees that refer to the same underlying BtShared object.
**
** Schema objects are automatically deallocated when the last Btree that
** references them is destroyed. The TEMP Schema is manually freed by
** sqlite3_close().
*
** A thread must be holding a mutex on the corresponding Btree in order
** to access Schema content. This implies that the thread must also be
** holding a mutex on the sqlite3 connection pointer that owns the Btree.
** For a TEMP Schema, only the connection mutex is required.
*/
public class Schema
{
public int schema_cookie; /* Database schema version number for this file */
public u32 iGeneration; /* Generation counter. Incremented with each change */
public Hash tblHash = new Hash(); /* All tables indexed by name */
public Hash idxHash = new Hash(); /* All (named) indices indexed by name */
public Hash trigHash = new Hash();/* All triggers indexed by name */
public Hash fkeyHash = new Hash();/* All foreign keys by referenced table name */
public Table pSeqTab; /* The sqlite_sequence table used by AUTOINCREMENT */
public u8 file_format; /* Schema format version for this file */
public u8 enc; /* Text encoding used by this database */
public u16 flags; /* Flags associated with this schema */
public int cache_size; /* Number of pages to use in the cache */
public Schema Copy()
{
if ( this == null )
return null;
else
{
Schema cp = (Schema)MemberwiseClone();
return cp;
}
}
public void Clear()
{
if ( this != null )
{
schema_cookie = 0;
tblHash = new Hash();
idxHash = new Hash();
trigHash = new Hash();
fkeyHash = new Hash();
pSeqTab = null;
}
}
};
/*
** These macros can be used to test, set, or clear bits in the
** Db.pSchema->flags field.
*/
//#define DbHasProperty(D,I,P) (((D)->aDb[I].pSchema->flags&(P))==(P))
static bool DbHasProperty( sqlite3 D, int I, ushort P )
{
return ( D.aDb[I].pSchema.flags & P ) == P;
}
//#define DbHasAnyProperty(D,I,P) (((D)->aDb[I].pSchema->flags&(P))!=0)
//#define DbSetProperty(D,I,P) (D)->aDb[I].pSchema->flags|=(P)
static void DbSetProperty( sqlite3 D, int I, ushort P )
{
D.aDb[I].pSchema.flags = (u16)( D.aDb[I].pSchema.flags | P );
}
//#define DbClearProperty(D,I,P) (D)->aDb[I].pSchema->flags&=~(P)
static void DbClearProperty( sqlite3 D, int I, ushort P )
{
D.aDb[I].pSchema.flags = (u16)( D.aDb[I].pSchema.flags & ~P );
}
/*
** Allowed values for the DB.pSchema->flags field.
**
** The DB_SchemaLoaded flag is set after the database schema has been
** read into internal hash tables.
**
** DB_UnresetViews means that one or more views have column names that
** have been filled out. If the schema changes, these column names might
** changes and so the view will need to be reset.
*/
//#define DB_SchemaLoaded 0x0001 /* The schema has been loaded */
//#define DB_UnresetViews 0x0002 /* Some views have defined column names */
//#define DB_Empty 0x0004 /* The file is empty (length 0 bytes) */
const u16 DB_SchemaLoaded = 0x0001;
const u16 DB_UnresetViews = 0x0002;
const u16 DB_Empty = 0x0004;
/*
** The number of different kinds of things that can be limited
** using the sqlite3_limit() interface.
*/
//#define SQLITE_N_LIMIT (SQLITE_LIMIT_TRIGGER_DEPTH+1)
const int SQLITE_N_LIMIT = SQLITE_LIMIT_TRIGGER_DEPTH + 1;
/*
** Lookaside malloc is a set of fixed-size buffers that can be used
** to satisfy small transient memory allocation requests for objects
** associated with a particular database connection. The use of
** lookaside malloc provides a significant performance enhancement
** (approx 10%) by avoiding numerous malloc/free requests while parsing
** SQL statements.
**
** The Lookaside structure holds configuration information about the
** lookaside malloc subsystem. Each available memory allocation in
** the lookaside subsystem is stored on a linked list of LookasideSlot
** objects.
**
** Lookaside allocations are only allowed for objects that are associated
** with a particular database connection. Hence, schema information cannot
** be stored in lookaside because in shared cache mode the schema information
** is shared by multiple database connections. Therefore, while parsing
** schema information, the Lookaside.bEnabled flag is cleared so that
** lookaside allocations are not used to construct the schema objects.
*/
public class Lookaside
{
public int sz; /* Size of each buffer in bytes */
public u8 bEnabled; /* False to disable new lookaside allocations */
public bool bMalloced; /* True if pStart obtained from sqlite3_malloc() */
public int nOut; /* Number of buffers currently checked out */
public int mxOut; /* Highwater mark for nOut */
public int[] anStat = new int[3]; /* 0: hits. 1: size misses. 2: full misses */
public LookasideSlot pFree; /* List of available buffers */
public int pStart; /* First byte of available memory space */
public int pEnd; /* First byte past end of available space */
};
public class LookasideSlot
{
public LookasideSlot pNext; /* Next buffer in the list of free buffers */
};
/*
** A hash table for function definitions.
**
** Hash each FuncDef structure into one of the FuncDefHash.a[] slots.
** Collisions are on the FuncDef.pHash chain.
*/
public class FuncDefHash
{
public FuncDef[] a = new FuncDef[23]; /* Hash table for functions */
};
/*
** Each database connection is an instance of the following structure.
**
** The sqlite.lastRowid records the last insert rowid generated by an
** insert statement. Inserts on views do not affect its value. Each
** trigger has its own context, so that lastRowid can be updated inside
** triggers as usual. The previous value will be restored once the trigger
** exits. Upon entering a before or instead of trigger, lastRowid is no
** longer (since after version 2.8.12) reset to -1.
**
** The sqlite.nChange does not count changes within triggers and keeps no
** context. It is reset at start of sqlite3_exec.
** The sqlite.lsChange represents the number of changes made by the last
** insert, update, or delete statement. It remains constant throughout the
** length of a statement and is then updated by OP_SetCounts. It keeps a
** context stack just like lastRowid so that the count of changes
** within a trigger is not seen outside the trigger. Changes to views do not
** affect the value of lsChange.
** The sqlite.csChange keeps track of the number of current changes (since
** the last statement) and is used to update sqlite_lsChange.
**
** The member variables sqlite.errCode, sqlite.zErrMsg and sqlite.zErrMsg16
** store the most recent error code and, if applicable, string. The
** internal function sqlite3Error() is used to set these variables
** consistently.
*/
public class sqlite3
{
public sqlite3_vfs pVfs; /* OS Interface */
public int nDb; /* Number of backends currently in use */
public Db[] aDb = new Db[SQLITE_MAX_ATTACHED]; /* All backends */
public int flags; /* Miscellaneous flags. See below */
You can’t perform that action at this time.