Fossil SCM

(cherry-pick): Have Fossil use the new "PRAGMA optimize" feature of SQLite 3.18.0 alpha. Use latest SQLite CLI enhancements.

jan.nijtmans 2017-03-15 14:30 UTC branch-2.1
Commit d123620ee3e23aa0bf83016b2bf210413d492792764da794472ae53b9bf01aa8
Parent 1c23cca8c9c0ace…
3 files changed +1 +1454 -248 +1454 -248
~ src/db.c ~ src/shell.c ~ src/shell.c
M src/db.c
+1
--- src/db.c
+++ src/db.c
@@ -1662,10 +1662,11 @@
16621662
 while( db.pAllStmt ){
16631663
 db_finalize(db.pAllStmt);
16641664
 }
16651665
 db_end_transaction(1);
16661666
 pStmt = 0;
1667
+ sqlite3_exec(g.db, "PRAGMA optimize", 0, 0, 0);
16671668
 db_close_config();
16681669
16691670
 /* If the localdb has a lot of unused free space,
16701671
 ** then VACUUM it as we shut down.
16711672
 */
16721673
--- src/db.c
+++ src/db.c
@@ -1662,10 +1662,11 @@
1662 while( db.pAllStmt ){
1663 db_finalize(db.pAllStmt);
1664 }
1665 db_end_transaction(1);
1666 pStmt = 0;
 
1667 db_close_config();
1668
1669 /* If the localdb has a lot of unused free space,
1670 ** then VACUUM it as we shut down.
1671 */
1672
--- src/db.c
+++ src/db.c
@@ -1662,10 +1662,11 @@
1662 while( db.pAllStmt ){
1663 db_finalize(db.pAllStmt);
1664 }
1665 db_end_transaction(1);
1666 pStmt = 0;
1667 sqlite3_exec(g.db, "PRAGMA optimize", 0, 0, 0);
1668 db_close_config();
1669
1670 /* If the localdb has a lot of unused free space,
1671 ** then VACUUM it as we shut down.
1672 */
1673
M src/shell.c
+1454 -248
--- src/shell.c
+++ src/shell.c
@@ -452,32 +452,10 @@
452452
 while( IsDigit(*z) ){ z++; }
453453
 if( realnum ) *realnum = 1;
454454
 }
455455
 return *z==0;
456456
 }
457
-
458
-/*
459
-** A global char* and an SQL function to access its current value
460
-** from within an SQL statement. This program used to use the
461
-** sqlite_exec_printf() API to substitue a string into an SQL statement.
462
-** The correct way to do this with sqlite3 is to use the bind API, but
463
-** since the shell is built around the callback paradigm it would be a lot
464
-** of work. Instead just use this hack, which is quite harmless.
465
-*/
466
-static const char *zShellStatic = 0;
467
-static void shellstaticFunc(
468
- sqlite3_context *context,
469
- int argc,
470
- sqlite3_value **argv
471
-){
472
- assert( 0==argc );
473
- assert( zShellStatic );
474
- UNUSED_PARAMETER(argc);
475
- UNUSED_PARAMETER(argv);
476
- sqlite3_result_text(context, zShellStatic, -1, SQLITE_STATIC);
477
-}
478
-
479457
480458
 /*
481459
 ** Compute a string length that is limited to what can be stored in
482460
 ** lower 30 bits of a 32-bit signed integer.
483461
 */
@@ -575,10 +553,783 @@
575553
 if( zResult && *zResult ) shell_add_history(zResult);
576554
 #endif
577555
 }
578556
 return zResult;
579557
 }
558
+/*
559
+** A variable length string to which one can append text.
560
+*/
561
+typedef struct ShellText ShellText;
562
+struct ShellText {
563
+ char *z;
564
+ int n;
565
+ int nAlloc;
566
+};
567
+
568
+/*
569
+** Initialize and destroy a ShellText object
570
+*/
571
+static void initText(ShellText *p){
572
+ memset(p, 0, sizeof(*p));
573
+}
574
+static void freeText(ShellText *p){
575
+ free(p->z);
576
+ initText(p);
577
+}
578
+
579
+/* zIn is either a pointer to a NULL-terminated string in memory obtained
580
+** from malloc(), or a NULL pointer. The string pointed to by zAppend is
581
+** added to zIn, and the result returned in memory obtained from malloc().
582
+** zIn, if it was not NULL, is freed.
583
+**
584
+** If the third argument, quote, is not '\0', then it is used as a
585
+** quote character for zAppend.
586
+*/
587
+static void appendText(ShellText *p, char const *zAppend, char quote){
588
+ int len;
589
+ int i;
590
+ int nAppend = strlen30(zAppend);
591
+
592
+ len = nAppend+p->n+1;
593
+ if( quote ){
594
+ len += 2;
595
+ for(i=0; i<nAppend; i++){
596
+ if( zAppend[i]==quote ) len++;
597
+ }
598
+ }
599
+
600
+ if( p->n+len>=p->nAlloc ){
601
+ p->nAlloc = p->nAlloc*2 + len + 20;
602
+ p->z = realloc(p->z, p->nAlloc);
603
+ if( p->z==0 ){
604
+ memset(p, 0, sizeof(*p));
605
+ return;
606
+ }
607
+ }
608
+
609
+ if( quote ){
610
+ char *zCsr = p->z+p->n;
611
+ *zCsr++ = quote;
612
+ for(i=0; i<nAppend; i++){
613
+ *zCsr++ = zAppend[i];
614
+ if( zAppend[i]==quote ) *zCsr++ = quote;
615
+ }
616
+ *zCsr++ = quote;
617
+ p->n = (int)(zCsr - p->z);
618
+ *zCsr = '\0';
619
+ }else{
620
+ memcpy(p->z+p->n, zAppend, nAppend);
621
+ p->n += nAppend;
622
+ p->z[p->n] = '\0';
623
+ }
624
+}
625
+
626
+/*
627
+** Attempt to determine if identifier zName needs to be quoted, either
628
+** because it contains non-alphanumeric characters, or because it is an
629
+** SQLite keyword. Be conservative in this estimate: When in doubt assume
630
+** that quoting is required.
631
+**
632
+** Return '"' if quoting is required. Return 0 if no quoting is required.
633
+*/
634
+static char quoteChar(const char *zName){
635
+ /* All SQLite keywords, in alphabetical order */
636
+ static const char *azKeywords[] = {
637
+ "ABORT", "ACTION", "ADD", "AFTER", "ALL", "ALTER", "ANALYZE", "AND", "AS",
638
+ "ASC", "ATTACH", "AUTOINCREMENT", "BEFORE", "BEGIN", "BETWEEN", "BY",
639
+ "CASCADE", "CASE", "CAST", "CHECK", "COLLATE", "COLUMN", "COMMIT",
640
+ "CONFLICT", "CONSTRAINT", "CREATE", "CROSS", "CURRENT_DATE",
641
+ "CURRENT_TIME", "CURRENT_TIMESTAMP", "DATABASE", "DEFAULT", "DEFERRABLE",
642
+ "DEFERRED", "DELETE", "DESC", "DETACH", "DISTINCT", "DROP", "EACH",
643
+ "ELSE", "END", "ESCAPE", "EXCEPT", "EXCLUSIVE", "EXISTS", "EXPLAIN",
644
+ "FAIL", "FOR", "FOREIGN", "FROM", "FULL", "GLOB", "GROUP", "HAVING", "IF",
645
+ "IGNORE", "IMMEDIATE", "IN", "INDEX", "INDEXED", "INITIALLY", "INNER",
646
+ "INSERT", "INSTEAD", "INTERSECT", "INTO", "IS", "ISNULL", "JOIN", "KEY",
647
+ "LEFT", "LIKE", "LIMIT", "MATCH", "NATURAL", "NO", "NOT", "NOTNULL",
648
+ "NULL", "OF", "OFFSET", "ON", "OR", "ORDER", "OUTER", "PLAN", "PRAGMA",
649
+ "PRIMARY", "QUERY", "RAISE", "RECURSIVE", "REFERENCES", "REGEXP",
650
+ "REINDEX", "RELEASE", "RENAME", "REPLACE", "RESTRICT", "RIGHT",
651
+ "ROLLBACK", "ROW", "SAVEPOINT", "SELECT", "SET", "TABLE", "TEMP",
652
+ "TEMPORARY", "THEN", "TO", "TRANSACTION", "TRIGGER", "UNION", "UNIQUE",
653
+ "UPDATE", "USING", "VACUUM", "VALUES", "VIEW", "VIRTUAL", "WHEN", "WHERE",
654
+ "WITH", "WITHOUT",
655
+ };
656
+ int i, lwr, upr, mid, c;
657
+ if( !isalpha((unsigned char)zName[0]) && zName[0]!='_' ) return '"';
658
+ for(i=0; zName[i]; i++){
659
+ if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ) return '"';
660
+ }
661
+ lwr = 0;
662
+ upr = sizeof(azKeywords)/sizeof(azKeywords[0]) - 1;
663
+ while( lwr<=upr ){
664
+ mid = (lwr+upr)/2;
665
+ c = sqlite3_stricmp(azKeywords[mid], zName);
666
+ if( c==0 ) return '"';
667
+ if( c<0 ){
668
+ lwr = mid+1;
669
+ }else{
670
+ upr = mid-1;
671
+ }
672
+ }
673
+ return 0;
674
+}
675
+
676
+/******************************************************************************
677
+** SHA3 hash implementation copied from ../ext/misc/shathree.c
678
+*/
679
+typedef sqlite3_uint64 u64;
680
+/*
681
+** Macros to determine whether the machine is big or little endian,
682
+** and whether or not that determination is run-time or compile-time.
683
+**
684
+** For best performance, an attempt is made to guess at the byte-order
685
+** using C-preprocessor macros. If that is unsuccessful, or if
686
+** -DSHA3_BYTEORDER=0 is set, then byte-order is determined
687
+** at run-time.
688
+*/
689
+#ifndef SHA3_BYTEORDER
690
+# if defined(i386) || defined(__i386__) || defined(_M_IX86) || \
691
+ defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) || \
692
+ defined(_M_AMD64) || defined(_M_ARM) || defined(__x86) || \
693
+ defined(__arm__)
694
+# define SHA3_BYTEORDER 1234
695
+# elif defined(sparc) || defined(__ppc__)
696
+# define SHA3_BYTEORDER 4321
697
+# else
698
+# define SHA3_BYTEORDER 0
699
+# endif
700
+#endif
701
+
702
+
703
+/*
704
+** State structure for a SHA3 hash in progress
705
+*/
706
+typedef struct SHA3Context SHA3Context;
707
+struct SHA3Context {
708
+ union {
709
+ u64 s[25]; /* Keccak state. 5x5 lines of 64 bits each */
710
+ unsigned char x[1600]; /* ... or 1600 bytes */
711
+ } u;
712
+ unsigned nRate; /* Bytes of input accepted per Keccak iteration */
713
+ unsigned nLoaded; /* Input bytes loaded into u.x[] so far this cycle */
714
+ unsigned ixMask; /* Insert next input into u.x[nLoaded^ixMask]. */
715
+};
716
+
717
+/*
718
+** A single step of the Keccak mixing function for a 1600-bit state
719
+*/
720
+static void KeccakF1600Step(SHA3Context *p){
721
+ int i;
722
+ u64 B0, B1, B2, B3, B4;
723
+ u64 C0, C1, C2, C3, C4;
724
+ u64 D0, D1, D2, D3, D4;
725
+ static const u64 RC[] = {
726
+ 0x0000000000000001ULL, 0x0000000000008082ULL,
727
+ 0x800000000000808aULL, 0x8000000080008000ULL,
728
+ 0x000000000000808bULL, 0x0000000080000001ULL,
729
+ 0x8000000080008081ULL, 0x8000000000008009ULL,
730
+ 0x000000000000008aULL, 0x0000000000000088ULL,
731
+ 0x0000000080008009ULL, 0x000000008000000aULL,
732
+ 0x000000008000808bULL, 0x800000000000008bULL,
733
+ 0x8000000000008089ULL, 0x8000000000008003ULL,
734
+ 0x8000000000008002ULL, 0x8000000000000080ULL,
735
+ 0x000000000000800aULL, 0x800000008000000aULL,
736
+ 0x8000000080008081ULL, 0x8000000000008080ULL,
737
+ 0x0000000080000001ULL, 0x8000000080008008ULL
738
+ };
739
+# define A00 (p->u.s[0])
740
+# define A01 (p->u.s[1])
741
+# define A02 (p->u.s[2])
742
+# define A03 (p->u.s[3])
743
+# define A04 (p->u.s[4])
744
+# define A10 (p->u.s[5])
745
+# define A11 (p->u.s[6])
746
+# define A12 (p->u.s[7])
747
+# define A13 (p->u.s[8])
748
+# define A14 (p->u.s[9])
749
+# define A20 (p->u.s[10])
750
+# define A21 (p->u.s[11])
751
+# define A22 (p->u.s[12])
752
+# define A23 (p->u.s[13])
753
+# define A24 (p->u.s[14])
754
+# define A30 (p->u.s[15])
755
+# define A31 (p->u.s[16])
756
+# define A32 (p->u.s[17])
757
+# define A33 (p->u.s[18])
758
+# define A34 (p->u.s[19])
759
+# define A40 (p->u.s[20])
760
+# define A41 (p->u.s[21])
761
+# define A42 (p->u.s[22])
762
+# define A43 (p->u.s[23])
763
+# define A44 (p->u.s[24])
764
+# define ROL64(a,x) ((a<<x)|(a>>(64-x)))
765
+
766
+ for(i=0; i<24; i+=4){
767
+ C0 = A00^A10^A20^A30^A40;
768
+ C1 = A01^A11^A21^A31^A41;
769
+ C2 = A02^A12^A22^A32^A42;
770
+ C3 = A03^A13^A23^A33^A43;
771
+ C4 = A04^A14^A24^A34^A44;
772
+ D0 = C4^ROL64(C1, 1);
773
+ D1 = C0^ROL64(C2, 1);
774
+ D2 = C1^ROL64(C3, 1);
775
+ D3 = C2^ROL64(C4, 1);
776
+ D4 = C3^ROL64(C0, 1);
777
+
778
+ B0 = (A00^D0);
779
+ B1 = ROL64((A11^D1), 44);
780
+ B2 = ROL64((A22^D2), 43);
781
+ B3 = ROL64((A33^D3), 21);
782
+ B4 = ROL64((A44^D4), 14);
783
+ A00 = B0 ^((~B1)& B2 );
784
+ A00 ^= RC[i];
785
+ A11 = B1 ^((~B2)& B3 );
786
+ A22 = B2 ^((~B3)& B4 );
787
+ A33 = B3 ^((~B4)& B0 );
788
+ A44 = B4 ^((~B0)& B1 );
789
+
790
+ B2 = ROL64((A20^D0), 3);
791
+ B3 = ROL64((A31^D1), 45);
792
+ B4 = ROL64((A42^D2), 61);
793
+ B0 = ROL64((A03^D3), 28);
794
+ B1 = ROL64((A14^D4), 20);
795
+ A20 = B0 ^((~B1)& B2 );
796
+ A31 = B1 ^((~B2)& B3 );
797
+ A42 = B2 ^((~B3)& B4 );
798
+ A03 = B3 ^((~B4)& B0 );
799
+ A14 = B4 ^((~B0)& B1 );
800
+
801
+ B4 = ROL64((A40^D0), 18);
802
+ B0 = ROL64((A01^D1), 1);
803
+ B1 = ROL64((A12^D2), 6);
804
+ B2 = ROL64((A23^D3), 25);
805
+ B3 = ROL64((A34^D4), 8);
806
+ A40 = B0 ^((~B1)& B2 );
807
+ A01 = B1 ^((~B2)& B3 );
808
+ A12 = B2 ^((~B3)& B4 );
809
+ A23 = B3 ^((~B4)& B0 );
810
+ A34 = B4 ^((~B0)& B1 );
811
+
812
+ B1 = ROL64((A10^D0), 36);
813
+ B2 = ROL64((A21^D1), 10);
814
+ B3 = ROL64((A32^D2), 15);
815
+ B4 = ROL64((A43^D3), 56);
816
+ B0 = ROL64((A04^D4), 27);
817
+ A10 = B0 ^((~B1)& B2 );
818
+ A21 = B1 ^((~B2)& B3 );
819
+ A32 = B2 ^((~B3)& B4 );
820
+ A43 = B3 ^((~B4)& B0 );
821
+ A04 = B4 ^((~B0)& B1 );
822
+
823
+ B3 = ROL64((A30^D0), 41);
824
+ B4 = ROL64((A41^D1), 2);
825
+ B0 = ROL64((A02^D2), 62);
826
+ B1 = ROL64((A13^D3), 55);
827
+ B2 = ROL64((A24^D4), 39);
828
+ A30 = B0 ^((~B1)& B2 );
829
+ A41 = B1 ^((~B2)& B3 );
830
+ A02 = B2 ^((~B3)& B4 );
831
+ A13 = B3 ^((~B4)& B0 );
832
+ A24 = B4 ^((~B0)& B1 );
833
+
834
+ C0 = A00^A20^A40^A10^A30;
835
+ C1 = A11^A31^A01^A21^A41;
836
+ C2 = A22^A42^A12^A32^A02;
837
+ C3 = A33^A03^A23^A43^A13;
838
+ C4 = A44^A14^A34^A04^A24;
839
+ D0 = C4^ROL64(C1, 1);
840
+ D1 = C0^ROL64(C2, 1);
841
+ D2 = C1^ROL64(C3, 1);
842
+ D3 = C2^ROL64(C4, 1);
843
+ D4 = C3^ROL64(C0, 1);
844
+
845
+ B0 = (A00^D0);
846
+ B1 = ROL64((A31^D1), 44);
847
+ B2 = ROL64((A12^D2), 43);
848
+ B3 = ROL64((A43^D3), 21);
849
+ B4 = ROL64((A24^D4), 14);
850
+ A00 = B0 ^((~B1)& B2 );
851
+ A00 ^= RC[i+1];
852
+ A31 = B1 ^((~B2)& B3 );
853
+ A12 = B2 ^((~B3)& B4 );
854
+ A43 = B3 ^((~B4)& B0 );
855
+ A24 = B4 ^((~B0)& B1 );
856
+
857
+ B2 = ROL64((A40^D0), 3);
858
+ B3 = ROL64((A21^D1), 45);
859
+ B4 = ROL64((A02^D2), 61);
860
+ B0 = ROL64((A33^D3), 28);
861
+ B1 = ROL64((A14^D4), 20);
862
+ A40 = B0 ^((~B1)& B2 );
863
+ A21 = B1 ^((~B2)& B3 );
864
+ A02 = B2 ^((~B3)& B4 );
865
+ A33 = B3 ^((~B4)& B0 );
866
+ A14 = B4 ^((~B0)& B1 );
867
+
868
+ B4 = ROL64((A30^D0), 18);
869
+ B0 = ROL64((A11^D1), 1);
870
+ B1 = ROL64((A42^D2), 6);
871
+ B2 = ROL64((A23^D3), 25);
872
+ B3 = ROL64((A04^D4), 8);
873
+ A30 = B0 ^((~B1)& B2 );
874
+ A11 = B1 ^((~B2)& B3 );
875
+ A42 = B2 ^((~B3)& B4 );
876
+ A23 = B3 ^((~B4)& B0 );
877
+ A04 = B4 ^((~B0)& B1 );
878
+
879
+ B1 = ROL64((A20^D0), 36);
880
+ B2 = ROL64((A01^D1), 10);
881
+ B3 = ROL64((A32^D2), 15);
882
+ B4 = ROL64((A13^D3), 56);
883
+ B0 = ROL64((A44^D4), 27);
884
+ A20 = B0 ^((~B1)& B2 );
885
+ A01 = B1 ^((~B2)& B3 );
886
+ A32 = B2 ^((~B3)& B4 );
887
+ A13 = B3 ^((~B4)& B0 );
888
+ A44 = B4 ^((~B0)& B1 );
889
+
890
+ B3 = ROL64((A10^D0), 41);
891
+ B4 = ROL64((A41^D1), 2);
892
+ B0 = ROL64((A22^D2), 62);
893
+ B1 = ROL64((A03^D3), 55);
894
+ B2 = ROL64((A34^D4), 39);
895
+ A10 = B0 ^((~B1)& B2 );
896
+ A41 = B1 ^((~B2)& B3 );
897
+ A22 = B2 ^((~B3)& B4 );
898
+ A03 = B3 ^((~B4)& B0 );
899
+ A34 = B4 ^((~B0)& B1 );
900
+
901
+ C0 = A00^A40^A30^A20^A10;
902
+ C1 = A31^A21^A11^A01^A41;
903
+ C2 = A12^A02^A42^A32^A22;
904
+ C3 = A43^A33^A23^A13^A03;
905
+ C4 = A24^A14^A04^A44^A34;
906
+ D0 = C4^ROL64(C1, 1);
907
+ D1 = C0^ROL64(C2, 1);
908
+ D2 = C1^ROL64(C3, 1);
909
+ D3 = C2^ROL64(C4, 1);
910
+ D4 = C3^ROL64(C0, 1);
911
+
912
+ B0 = (A00^D0);
913
+ B1 = ROL64((A21^D1), 44);
914
+ B2 = ROL64((A42^D2), 43);
915
+ B3 = ROL64((A13^D3), 21);
916
+ B4 = ROL64((A34^D4), 14);
917
+ A00 = B0 ^((~B1)& B2 );
918
+ A00 ^= RC[i+2];
919
+ A21 = B1 ^((~B2)& B3 );
920
+ A42 = B2 ^((~B3)& B4 );
921
+ A13 = B3 ^((~B4)& B0 );
922
+ A34 = B4 ^((~B0)& B1 );
923
+
924
+ B2 = ROL64((A30^D0), 3);
925
+ B3 = ROL64((A01^D1), 45);
926
+ B4 = ROL64((A22^D2), 61);
927
+ B0 = ROL64((A43^D3), 28);
928
+ B1 = ROL64((A14^D4), 20);
929
+ A30 = B0 ^((~B1)& B2 );
930
+ A01 = B1 ^((~B2)& B3 );
931
+ A22 = B2 ^((~B3)& B4 );
932
+ A43 = B3 ^((~B4)& B0 );
933
+ A14 = B4 ^((~B0)& B1 );
934
+
935
+ B4 = ROL64((A10^D0), 18);
936
+ B0 = ROL64((A31^D1), 1);
937
+ B1 = ROL64((A02^D2), 6);
938
+ B2 = ROL64((A23^D3), 25);
939
+ B3 = ROL64((A44^D4), 8);
940
+ A10 = B0 ^((~B1)& B2 );
941
+ A31 = B1 ^((~B2)& B3 );
942
+ A02 = B2 ^((~B3)& B4 );
943
+ A23 = B3 ^((~B4)& B0 );
944
+ A44 = B4 ^((~B0)& B1 );
945
+
946
+ B1 = ROL64((A40^D0), 36);
947
+ B2 = ROL64((A11^D1), 10);
948
+ B3 = ROL64((A32^D2), 15);
949
+ B4 = ROL64((A03^D3), 56);
950
+ B0 = ROL64((A24^D4), 27);
951
+ A40 = B0 ^((~B1)& B2 );
952
+ A11 = B1 ^((~B2)& B3 );
953
+ A32 = B2 ^((~B3)& B4 );
954
+ A03 = B3 ^((~B4)& B0 );
955
+ A24 = B4 ^((~B0)& B1 );
956
+
957
+ B3 = ROL64((A20^D0), 41);
958
+ B4 = ROL64((A41^D1), 2);
959
+ B0 = ROL64((A12^D2), 62);
960
+ B1 = ROL64((A33^D3), 55);
961
+ B2 = ROL64((A04^D4), 39);
962
+ A20 = B0 ^((~B1)& B2 );
963
+ A41 = B1 ^((~B2)& B3 );
964
+ A12 = B2 ^((~B3)& B4 );
965
+ A33 = B3 ^((~B4)& B0 );
966
+ A04 = B4 ^((~B0)& B1 );
967
+
968
+ C0 = A00^A30^A10^A40^A20;
969
+ C1 = A21^A01^A31^A11^A41;
970
+ C2 = A42^A22^A02^A32^A12;
971
+ C3 = A13^A43^A23^A03^A33;
972
+ C4 = A34^A14^A44^A24^A04;
973
+ D0 = C4^ROL64(C1, 1);
974
+ D1 = C0^ROL64(C2, 1);
975
+ D2 = C1^ROL64(C3, 1);
976
+ D3 = C2^ROL64(C4, 1);
977
+ D4 = C3^ROL64(C0, 1);
978
+
979
+ B0 = (A00^D0);
980
+ B1 = ROL64((A01^D1), 44);
981
+ B2 = ROL64((A02^D2), 43);
982
+ B3 = ROL64((A03^D3), 21);
983
+ B4 = ROL64((A04^D4), 14);
984
+ A00 = B0 ^((~B1)& B2 );
985
+ A00 ^= RC[i+3];
986
+ A01 = B1 ^((~B2)& B3 );
987
+ A02 = B2 ^((~B3)& B4 );
988
+ A03 = B3 ^((~B4)& B0 );
989
+ A04 = B4 ^((~B0)& B1 );
990
+
991
+ B2 = ROL64((A10^D0), 3);
992
+ B3 = ROL64((A11^D1), 45);
993
+ B4 = ROL64((A12^D2), 61);
994
+ B0 = ROL64((A13^D3), 28);
995
+ B1 = ROL64((A14^D4), 20);
996
+ A10 = B0 ^((~B1)& B2 );
997
+ A11 = B1 ^((~B2)& B3 );
998
+ A12 = B2 ^((~B3)& B4 );
999
+ A13 = B3 ^((~B4)& B0 );
1000
+ A14 = B4 ^((~B0)& B1 );
1001
+
1002
+ B4 = ROL64((A20^D0), 18);
1003
+ B0 = ROL64((A21^D1), 1);
1004
+ B1 = ROL64((A22^D2), 6);
1005
+ B2 = ROL64((A23^D3), 25);
1006
+ B3 = ROL64((A24^D4), 8);
1007
+ A20 = B0 ^((~B1)& B2 );
1008
+ A21 = B1 ^((~B2)& B3 );
1009
+ A22 = B2 ^((~B3)& B4 );
1010
+ A23 = B3 ^((~B4)& B0 );
1011
+ A24 = B4 ^((~B0)& B1 );
1012
+
1013
+ B1 = ROL64((A30^D0), 36);
1014
+ B2 = ROL64((A31^D1), 10);
1015
+ B3 = ROL64((A32^D2), 15);
1016
+ B4 = ROL64((A33^D3), 56);
1017
+ B0 = ROL64((A34^D4), 27);
1018
+ A30 = B0 ^((~B1)& B2 );
1019
+ A31 = B1 ^((~B2)& B3 );
1020
+ A32 = B2 ^((~B3)& B4 );
1021
+ A33 = B3 ^((~B4)& B0 );
1022
+ A34 = B4 ^((~B0)& B1 );
1023
+
1024
+ B3 = ROL64((A40^D0), 41);
1025
+ B4 = ROL64((A41^D1), 2);
1026
+ B0 = ROL64((A42^D2), 62);
1027
+ B1 = ROL64((A43^D3), 55);
1028
+ B2 = ROL64((A44^D4), 39);
1029
+ A40 = B0 ^((~B1)& B2 );
1030
+ A41 = B1 ^((~B2)& B3 );
1031
+ A42 = B2 ^((~B3)& B4 );
1032
+ A43 = B3 ^((~B4)& B0 );
1033
+ A44 = B4 ^((~B0)& B1 );
1034
+ }
1035
+}
1036
+
1037
+/*
1038
+** Initialize a new hash. iSize determines the size of the hash
1039
+** in bits and should be one of 224, 256, 384, or 512. Or iSize
1040
+** can be zero to use the default hash size of 256 bits.
1041
+*/
1042
+static void SHA3Init(SHA3Context *p, int iSize){
1043
+ memset(p, 0, sizeof(*p));
1044
+ if( iSize>=128 && iSize<=512 ){
1045
+ p->nRate = (1600 - ((iSize + 31)&~31)*2)/8;
1046
+ }else{
1047
+ p->nRate = (1600 - 2*256)/8;
1048
+ }
1049
+#if SHA3_BYTEORDER==1234
1050
+ /* Known to be little-endian at compile-time. No-op */
1051
+#elif SHA3_BYTEORDER==4321
1052
+ p->ixMask = 7; /* Big-endian */
1053
+#else
1054
+ {
1055
+ static unsigned int one = 1;
1056
+ if( 1==*(unsigned char*)&one ){
1057
+ /* Little endian. No byte swapping. */
1058
+ p->ixMask = 0;
1059
+ }else{
1060
+ /* Big endian. Byte swap. */
1061
+ p->ixMask = 7;
1062
+ }
1063
+ }
1064
+#endif
1065
+}
1066
+
1067
+/*
1068
+** Make consecutive calls to the SHA3Update function to add new content
1069
+** to the hash
1070
+*/
1071
+static void SHA3Update(
1072
+ SHA3Context *p,
1073
+ const unsigned char *aData,
1074
+ unsigned int nData
1075
+){
1076
+ unsigned int i = 0;
1077
+#if SHA3_BYTEORDER==1234
1078
+ if( (p->nLoaded % 8)==0 && ((aData - (const unsigned char*)0)&7)==0 ){
1079
+ for(; i+7<nData; i+=8){
1080
+ p->u.s[p->nLoaded/8] ^= *(u64*)&aData[i];
1081
+ p->nLoaded += 8;
1082
+ if( p->nLoaded>=p->nRate ){
1083
+ KeccakF1600Step(p);
1084
+ p->nLoaded = 0;
1085
+ }
1086
+ }
1087
+ }
1088
+#endif
1089
+ for(; i<nData; i++){
1090
+#if SHA3_BYTEORDER==1234
1091
+ p->u.x[p->nLoaded] ^= aData[i];
1092
+#elif SHA3_BYTEORDER==4321
1093
+ p->u.x[p->nLoaded^0x07] ^= aData[i];
1094
+#else
1095
+ p->u.x[p->nLoaded^p->ixMask] ^= aData[i];
1096
+#endif
1097
+ p->nLoaded++;
1098
+ if( p->nLoaded==p->nRate ){
1099
+ KeccakF1600Step(p);
1100
+ p->nLoaded = 0;
1101
+ }
1102
+ }
1103
+}
1104
+
1105
+/*
1106
+** After all content has been added, invoke SHA3Final() to compute
1107
+** the final hash. The function returns a pointer to the binary
1108
+** hash value.
1109
+*/
1110
+static unsigned char *SHA3Final(SHA3Context *p){
1111
+ unsigned int i;
1112
+ if( p->nLoaded==p->nRate-1 ){
1113
+ const unsigned char c1 = 0x86;
1114
+ SHA3Update(p, &c1, 1);
1115
+ }else{
1116
+ const unsigned char c2 = 0x06;
1117
+ const unsigned char c3 = 0x80;
1118
+ SHA3Update(p, &c2, 1);
1119
+ p->nLoaded = p->nRate - 1;
1120
+ SHA3Update(p, &c3, 1);
1121
+ }
1122
+ for(i=0; i<p->nRate; i++){
1123
+ p->u.x[i+p->nRate] = p->u.x[i^p->ixMask];
1124
+ }
1125
+ return &p->u.x[p->nRate];
1126
+}
1127
+
1128
+/*
1129
+** Implementation of the sha3(X,SIZE) function.
1130
+**
1131
+** Return a BLOB which is the SIZE-bit SHA3 hash of X. The default
1132
+** size is 256. If X is a BLOB, it is hashed as is.
1133
+** For all other non-NULL types of input, X is converted into a UTF-8 string
1134
+** and the string is hashed without the trailing 0x00 terminator. The hash
1135
+** of a NULL value is NULL.
1136
+*/
1137
+static void sha3Func(
1138
+ sqlite3_context *context,
1139
+ int argc,
1140
+ sqlite3_value **argv
1141
+){
1142
+ SHA3Context cx;
1143
+ int eType = sqlite3_value_type(argv[0]);
1144
+ int nByte = sqlite3_value_bytes(argv[0]);
1145
+ int iSize;
1146
+ if( argc==1 ){
1147
+ iSize = 256;
1148
+ }else{
1149
+ iSize = sqlite3_value_int(argv[1]);
1150
+ if( iSize!=224 && iSize!=256 && iSize!=384 && iSize!=512 ){
1151
+ sqlite3_result_error(context, "SHA3 size should be one of: 224 256 "
1152
+ "384 512", -1);
1153
+ return;
1154
+ }
1155
+ }
1156
+ if( eType==SQLITE_NULL ) return;
1157
+ SHA3Init(&cx, iSize);
1158
+ if( eType==SQLITE_BLOB ){
1159
+ SHA3Update(&cx, sqlite3_value_blob(argv[0]), nByte);
1160
+ }else{
1161
+ SHA3Update(&cx, sqlite3_value_text(argv[0]), nByte);
1162
+ }
1163
+ sqlite3_result_blob(context, SHA3Final(&cx), iSize/8, SQLITE_TRANSIENT);
1164
+}
1165
+
1166
+/* Compute a string using sqlite3_vsnprintf() with a maximum length
1167
+** of 50 bytes and add it to the hash.
1168
+*/
1169
+static void hash_step_vformat(
1170
+ SHA3Context *p, /* Add content to this context */
1171
+ const char *zFormat,
1172
+ ...
1173
+){
1174
+ va_list ap;
1175
+ int n;
1176
+ char zBuf[50];
1177
+ va_start(ap, zFormat);
1178
+ sqlite3_vsnprintf(sizeof(zBuf),zBuf,zFormat,ap);
1179
+ va_end(ap);
1180
+ n = (int)strlen(zBuf);
1181
+ SHA3Update(p, (unsigned char*)zBuf, n);
1182
+}
1183
+
1184
+/*
1185
+** Implementation of the sha3_query(SQL,SIZE) function.
1186
+**
1187
+** This function compiles and runs the SQL statement(s) given in the
1188
+** argument. The results are hashed using a SIZE-bit SHA3. The default
1189
+** size is 256.
1190
+**
1191
+** The format of the byte stream that is hashed is summarized as follows:
1192
+**
1193
+** S<n>:<sql>
1194
+** R
1195
+** N
1196
+** I<int>
1197
+** F<ieee-float>
1198
+** B<size>:<bytes>
1199
+** T<size>:<text>
1200
+**
1201
+** <sql> is the original SQL text for each statement run and <n> is
1202
+** the size of that text. The SQL text is UTF-8. A single R character
1203
+** occurs before the start of each row. N means a NULL value.
1204
+** I mean an 8-byte little-endian integer <int>. F is a floating point
1205
+** number with an 8-byte little-endian IEEE floating point value <ieee-float>.
1206
+** B means blobs of <size> bytes. T means text rendered as <size>
1207
+** bytes of UTF-8. The <n> and <size> values are expressed as an ASCII
1208
+** text integers.
1209
+**
1210
+** For each SQL statement in the X input, there is one S segment. Each
1211
+** S segment is followed by zero or more R segments, one for each row in the
1212
+** result set. After each R, there are one or more N, I, F, B, or T segments,
1213
+** one for each column in the result set. Segments are concatentated directly
1214
+** with no delimiters of any kind.
1215
+*/
1216
+static void sha3QueryFunc(
1217
+ sqlite3_context *context,
1218
+ int argc,
1219
+ sqlite3_value **argv
1220
+){
1221
+ sqlite3 *db = sqlite3_context_db_handle(context);
1222
+ const char *zSql = (const char*)sqlite3_value_text(argv[0]);
1223
+ sqlite3_stmt *pStmt = 0;
1224
+ int nCol; /* Number of columns in the result set */
1225
+ int i; /* Loop counter */
1226
+ int rc;
1227
+ int n;
1228
+ const char *z;
1229
+ SHA3Context cx;
1230
+ int iSize;
1231
+
1232
+ if( argc==1 ){
1233
+ iSize = 256;
1234
+ }else{
1235
+ iSize = sqlite3_value_int(argv[1]);
1236
+ if( iSize!=224 && iSize!=256 && iSize!=384 && iSize!=512 ){
1237
+ sqlite3_result_error(context, "SHA3 size should be one of: 224 256 "
1238
+ "384 512", -1);
1239
+ return;
1240
+ }
1241
+ }
1242
+ if( zSql==0 ) return;
1243
+ SHA3Init(&cx, iSize);
1244
+ while( zSql[0] ){
1245
+ rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zSql);
1246
+ if( rc ){
1247
+ char *zMsg = sqlite3_mprintf("error SQL statement [%s]: %s",
1248
+ zSql, sqlite3_errmsg(db));
1249
+ sqlite3_finalize(pStmt);
1250
+ sqlite3_result_error(context, zMsg, -1);
1251
+ sqlite3_free(zMsg);
1252
+ return;
1253
+ }
1254
+ if( !sqlite3_stmt_readonly(pStmt) ){
1255
+ char *zMsg = sqlite3_mprintf("non-query: [%s]", sqlite3_sql(pStmt));
1256
+ sqlite3_finalize(pStmt);
1257
+ sqlite3_result_error(context, zMsg, -1);
1258
+ sqlite3_free(zMsg);
1259
+ return;
1260
+ }
1261
+ nCol = sqlite3_column_count(pStmt);
1262
+ z = sqlite3_sql(pStmt);
1263
+ if( z==0 ){
1264
+ sqlite3_finalize(pStmt);
1265
+ continue;
1266
+ }
1267
+ n = (int)strlen(z);
1268
+ hash_step_vformat(&cx,"S%d:",n);
1269
+ SHA3Update(&cx,(unsigned char*)z,n);
1270
+
1271
+ /* Compute a hash over the result of the query */
1272
+ while( SQLITE_ROW==sqlite3_step(pStmt) ){
1273
+ SHA3Update(&cx,(const unsigned char*)"R",1);
1274
+ for(i=0; i<nCol; i++){
1275
+ switch( sqlite3_column_type(pStmt,i) ){
1276
+ case SQLITE_NULL: {
1277
+ SHA3Update(&cx, (const unsigned char*)"N",1);
1278
+ break;
1279
+ }
1280
+ case SQLITE_INTEGER: {
1281
+ sqlite3_uint64 u;
1282
+ int j;
1283
+ unsigned char x[9];
1284
+ sqlite3_int64 v = sqlite3_column_int64(pStmt,i);
1285
+ memcpy(&u, &v, 8);
1286
+ for(j=8; j>=1; j--){
1287
+ x[j] = u & 0xff;
1288
+ u >>= 8;
1289
+ }
1290
+ x[0] = 'I';
1291
+ SHA3Update(&cx, x, 9);
1292
+ break;
1293
+ }
1294
+ case SQLITE_FLOAT: {
1295
+ sqlite3_uint64 u;
1296
+ int j;
1297
+ unsigned char x[9];
1298
+ double r = sqlite3_column_double(pStmt,i);
1299
+ memcpy(&u, &r, 8);
1300
+ for(j=8; j>=1; j--){
1301
+ x[j] = u & 0xff;
1302
+ u >>= 8;
1303
+ }
1304
+ x[0] = 'F';
1305
+ SHA3Update(&cx,x,9);
1306
+ break;
1307
+ }
1308
+ case SQLITE_TEXT: {
1309
+ int n2 = sqlite3_column_bytes(pStmt, i);
1310
+ const unsigned char *z2 = sqlite3_column_text(pStmt, i);
1311
+ hash_step_vformat(&cx,"T%d:",n2);
1312
+ SHA3Update(&cx, z2, n2);
1313
+ break;
1314
+ }
1315
+ case SQLITE_BLOB: {
1316
+ int n2 = sqlite3_column_bytes(pStmt, i);
1317
+ const unsigned char *z2 = sqlite3_column_blob(pStmt, i);
1318
+ hash_step_vformat(&cx,"B%d:",n2);
1319
+ SHA3Update(&cx, z2, n2);
1320
+ break;
1321
+ }
1322
+ }
1323
+ }
1324
+ }
1325
+ sqlite3_finalize(pStmt);
1326
+ }
1327
+ sqlite3_result_blob(context, SHA3Final(&cx), iSize/8, SQLITE_TRANSIENT);
1328
+}
1329
+/* End of SHA3 hashing logic copy/pasted from ../ext/misc/shathree.c
1330
+********************************************************************************/
5801331
5811332
 #if defined(SQLITE_ENABLE_SESSION)
5821333
 /*
5831334
 ** State information for a single open session
5841335
 */
@@ -608,17 +1359,14 @@
6081359
 ** instance of the following structure.
6091360
 */
6101361
 typedef struct ShellState ShellState;
6111362
 struct ShellState {
6121363
 sqlite3 *db; /* The database */
613
- int echoOn; /* True to echo input commands */
6141364
 int autoExplain; /* Automatically turn on .explain mode */
6151365
 int autoEQP; /* Run EXPLAIN QUERY PLAN prior to seach SQL stmt */
6161366
 int statsOn; /* True to display memory stats before each finalize */
6171367
 int scanstatsOn; /* True to display scan stats before each finalize */
618
- int countChanges; /* True to display change counts */
619
- int backslashOn; /* Resolve C-style \x escapes in SQL input text */
6201368
 int outCount; /* Revert to stdout when reaching zero */
6211369
 int cnt; /* Number of records displayed so far */
6221370
 FILE *out; /* Write results here */
6231371
 FILE *traceOut; /* Output for sqlite3_trace() */
6241372
 int nErr; /* Number of errors seen */
@@ -653,13 +1401,24 @@
6531401
 };
6541402
6551403
 /*
6561404
 ** These are the allowed shellFlgs values
6571405
 */
658
-#define SHFLG_Scratch 0x00001 /* The --scratch option is used */
659
-#define SHFLG_Pagecache 0x00002 /* The --pagecache option is used */
660
-#define SHFLG_Lookaside 0x00004 /* Lookaside memory is used */
1406
+#define SHFLG_Scratch 0x00000001 /* The --scratch option is used */
1407
+#define SHFLG_Pagecache 0x00000002 /* The --pagecache option is used */
1408
+#define SHFLG_Lookaside 0x00000004 /* Lookaside memory is used */
1409
+#define SHFLG_Backslash 0x00000008 /* The --backslash option is used */
1410
+#define SHFLG_PreserveRowid 0x00000010 /* .dump preserves rowid values */
1411
+#define SHFLG_CountChanges 0x00000020 /* .changes setting */
1412
+#define SHFLG_Echo 0x00000040 /* .echo or --echo setting */
1413
+
1414
+/*
1415
+** Macros for testing and setting shellFlgs
1416
+*/
1417
+#define ShellHasFlag(P,X) (((P)->shellFlgs & (X))!=0)
1418
+#define ShellSetFlag(P,X) ((P)->shellFlgs|=(X))
1419
+#define ShellClearFlag(P,X) ((P)->shellFlgs&=(~(X)))
6611420
6621421
 /*
6631422
 ** These are the allowed modes.
6641423
 */
6651424
 #define MODE_Line 0 /* One column per line. Blank line between records */
@@ -729,36 +1488,56 @@
7291488
 raw_printf(out,"'");
7301489
 }
7311490
7321491
 /*
7331492
 ** Output the given string as a quoted string using SQL quoting conventions.
1493
+**
1494
+** The "\n" and "\r" characters are converted to char(10) and char(13)
1495
+** to prevent them from being transformed by end-of-line translators.
7341496
 */
7351497
 static void output_quoted_string(FILE *out, const char *z){
7361498
 int i;
737
- int nSingle = 0;
1499
+ char c;
7381500
 setBinaryMode(out, 1);
739
- for(i=0; z[i]; i++){
740
- if( z[i]=='\'' ) nSingle++;
741
- }
742
- if( nSingle==0 ){
1501
+ for(i=0; (c = z[i])!=0 && c!='\'' && c!='\n' && c!='\r'; i++){}
1502
+ if( c==0 ){
7431503
 utf8_printf(out,"'%s'",z);
7441504
 }else{
745
- raw_printf(out,"'");
1505
+ int inQuote = 0;
1506
+ int bStarted = 0;
7461507
 while( *z ){
747
- for(i=0; z[i] && z[i]!='\''; i++){}
748
- if( i==0 ){
749
- raw_printf(out,"''");
750
- z++;
751
- }else if( z[i]=='\'' ){
752
- utf8_printf(out,"%.*s''",i,z);
753
- z += i+1;
754
- }else{
755
- utf8_printf(out,"%s",z);
1508
+ for(i=0; (c = z[i])!=0 && c!='\n' && c!='\r' && c!='\''; i++){}
1509
+ if( c=='\'' ) i++;
1510
+ if( i ){
1511
+ if( !inQuote ){
1512
+ if( bStarted ) raw_printf(out, "||");
1513
+ raw_printf(out, "'");
1514
+ inQuote = 1;
1515
+ }
1516
+ utf8_printf(out, "%.*s", i, z);
1517
+ z += i;
1518
+ bStarted = 1;
1519
+ }
1520
+ if( c=='\'' ){
1521
+ raw_printf(out, "'");
1522
+ continue;
1523
+ }
1524
+ if( inQuote ){
1525
+ raw_printf(out, "'");
1526
+ inQuote = 0;
1527
+ }
1528
+ if( c==0 ){
7561529
 break;
7571530
 }
1531
+ for(i=0; (c = z[i])=='\r' || c=='\n'; i++){
1532
+ if( bStarted ) raw_printf(out, "||");
1533
+ raw_printf(out, "char(%d)", c);
1534
+ bStarted = 1;
1535
+ }
1536
+ z += i;
7581537
 }
759
- raw_printf(out,"'");
1538
+ if( inQuote ) raw_printf(out, "'");
7601539
 }
7611540
 setTextMode(out, 1);
7621541
 }
7631542
7641543
 /*
@@ -1246,13 +2025,17 @@
12462025
 if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){
12472026
 utf8_printf(p->out,"%sNULL",zSep);
12482027
 }else if( aiType && aiType[i]==SQLITE_TEXT ){
12492028
 if( zSep[0] ) utf8_printf(p->out,"%s",zSep);
12502029
 output_quoted_string(p->out, azArg[i]);
1251
- }else if( aiType && (aiType[i]==SQLITE_INTEGER
1252
- || aiType[i]==SQLITE_FLOAT) ){
2030
+ }else if( aiType && aiType[i]==SQLITE_INTEGER ){
12532031
 utf8_printf(p->out,"%s%s",zSep, azArg[i]);
2032
+ }else if( aiType && aiType[i]==SQLITE_FLOAT ){
2033
+ char z[50];
2034
+ double r = sqlite3_column_double(p->pStmt, i);
2035
+ sqlite3_snprintf(50,z,"%!.20g", r);
2036
+ raw_printf(p->out, "%s%s", zSep, z);
12542037
 }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){
12552038
 const void *pBlob = sqlite3_column_blob(p->pStmt, i);
12562039
 int nBlob = sqlite3_column_bytes(p->pStmt, i);
12572040
 if( zSep[0] ) utf8_printf(p->out,"%s",zSep);
12582041
 output_hex_blob(p->out, pBlob, nBlob);
@@ -1292,92 +2075,106 @@
12922075
 */
12932076
 static int callback(void *pArg, int nArg, char **azArg, char **azCol){
12942077
 /* since we don't have type info, call the shell_callback with a NULL value */
12952078
 return shell_callback(pArg, nArg, azArg, azCol, NULL);
12962079
 }
2080
+
2081
+/*
2082
+** This is the callback routine from sqlite3_exec() that appends all
2083
+** output onto the end of a ShellText object.
2084
+*/
2085
+static int captureOutputCallback(void *pArg, int nArg, char **azArg, char **az){
2086
+ ShellText *p = (ShellText*)pArg;
2087
+ int i;
2088
+ if( p->n ) appendText(p, "|", 0);
2089
+ for(i=0; i<nArg; i++){
2090
+ if( i ) appendText(p, ",", 0);
2091
+ if( azArg[i] ) appendText(p, azArg[i], 0);
2092
+ }
2093
+ return 0;
2094
+}
2095
+
2096
+/*
2097
+** Generate an appropriate SELFTEST table in the main database.
2098
+*/
2099
+static void createSelftestTable(ShellState *p){
2100
+ char *zErrMsg = 0;
2101
+ sqlite3_exec(p->db,
2102
+ "SAVEPOINT selftest_init;\n"
2103
+ "CREATE TABLE IF NOT EXISTS selftest(\n"
2104
+ " tno INTEGER PRIMARY KEY,\n" /* Test number */
2105
+ " op TEXT,\n" /* Operator: memo run */
2106
+ " cmd TEXT,\n" /* Command text */
2107
+ " ans TEXT\n" /* Desired answer */
2108
+ ");"
2109
+ "CREATE TEMP TABLE [_shell$self](op,cmd,ans);\n"
2110
+ "INSERT INTO [_shell$self](rowid,op,cmd)\n"
2111
+ " VALUES(coalesce((SELECT (max(tno)+100)/10 FROM selftest),10),\n"
2112
+ " 'memo','Tests generated by --init');\n"
2113
+ "INSERT INTO [_shell$self]\n"
2114
+ " SELECT 'run',\n"
2115
+ " 'SELECT hex(sha3_query(''SELECT type,name,tbl_name,sql "
2116
+ "FROM sqlite_master ORDER BY 2'',224))',\n"
2117
+ " hex(sha3_query('SELECT type,name,tbl_name,sql "
2118
+ "FROM sqlite_master ORDER BY 2',224));\n"
2119
+ "INSERT INTO [_shell$self]\n"
2120
+ " SELECT 'run',"
2121
+ " 'SELECT hex(sha3_query(''SELECT * FROM \"' ||"
2122
+ " printf('%w',name) || '\" NOT INDEXED'',224))',\n"
2123
+ " hex(sha3_query(printf('SELECT * FROM \"%w\" NOT INDEXED',name),224))\n"
2124
+ " FROM (\n"
2125
+ " SELECT name FROM sqlite_master\n"
2126
+ " WHERE type='table'\n"
2127
+ " AND name<>'selftest'\n"
2128
+ " AND coalesce(rootpage,0)>0\n"
2129
+ " )\n"
2130
+ " ORDER BY name;\n"
2131
+ "INSERT INTO [_shell$self]\n"
2132
+ " VALUES('run','PRAGMA integrity_check','ok');\n"
2133
+ "INSERT INTO selftest(tno,op,cmd,ans)"
2134
+ " SELECT rowid*10,op,cmd,ans FROM [_shell$self];\n"
2135
+ "DROP TABLE [_shell$self];"
2136
+ ,0,0,&zErrMsg);
2137
+ if( zErrMsg ){
2138
+ utf8_printf(stderr, "SELFTEST initialization failure: %s\n", zErrMsg);
2139
+ sqlite3_free(zErrMsg);
2140
+ }
2141
+ sqlite3_exec(p->db, "RELEASE selftest_init",0,0,0);
2142
+}
2143
+
12972144
12982145
 /*
12992146
 ** Set the destination table field of the ShellState structure to
13002147
 ** the name of the table given. Escape any quote characters in the
13012148
 ** table name.
13022149
 */
13032150
 static void set_table_name(ShellState *p, const char *zName){
13042151
 int i, n;
1305
- int needQuote;
2152
+ int cQuote;
13062153
 char *z;
13072154
13082155
 if( p->zDestTable ){
13092156
 free(p->zDestTable);
13102157
 p->zDestTable = 0;
13112158
 }
13122159
 if( zName==0 ) return;
1313
- needQuote = !isalpha((unsigned char)*zName) && *zName!='_';
1314
- for(i=n=0; zName[i]; i++, n++){
1315
- if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ){
1316
- needQuote = 1;
1317
- if( zName[i]=='\'' ) n++;
1318
- }
1319
- }
1320
- if( needQuote ) n += 2;
2160
+ cQuote = quoteChar(zName);
2161
+ n = strlen30(zName);
2162
+ if( cQuote ) n += 2;
13212163
 z = p->zDestTable = malloc( n+1 );
13222164
 if( z==0 ){
13232165
 raw_printf(stderr,"Error: out of memory\n");
13242166
 exit(1);
13252167
 }
13262168
 n = 0;
1327
- if( needQuote ) z[n++] = '\'';
2169
+ if( cQuote ) z[n++] = cQuote;
13282170
 for(i=0; zName[i]; i++){
13292171
 z[n++] = zName[i];
1330
- if( zName[i]=='\'' ) z[n++] = '\'';
1331
- }
1332
- if( needQuote ) z[n++] = '\'';
1333
- z[n] = 0;
1334
-}
1335
-
1336
-/* zIn is either a pointer to a NULL-terminated string in memory obtained
1337
-** from malloc(), or a NULL pointer. The string pointed to by zAppend is
1338
-** added to zIn, and the result returned in memory obtained from malloc().
1339
-** zIn, if it was not NULL, is freed.
1340
-**
1341
-** If the third argument, quote, is not '\0', then it is used as a
1342
-** quote character for zAppend.
1343
-*/
1344
-static char *appendText(char *zIn, char const *zAppend, char quote){
1345
- int len;
1346
- int i;
1347
- int nAppend = strlen30(zAppend);
1348
- int nIn = (zIn?strlen30(zIn):0);
1349
-
1350
- len = nAppend+nIn+1;
1351
- if( quote ){
1352
- len += 2;
1353
- for(i=0; i<nAppend; i++){
1354
- if( zAppend[i]==quote ) len++;
1355
- }
1356
- }
1357
-
1358
- zIn = (char *)realloc(zIn, len);
1359
- if( !zIn ){
1360
- return 0;
1361
- }
1362
-
1363
- if( quote ){
1364
- char *zCsr = &zIn[nIn];
1365
- *zCsr++ = quote;
1366
- for(i=0; i<nAppend; i++){
1367
- *zCsr++ = zAppend[i];
1368
- if( zAppend[i]==quote ) *zCsr++ = quote;
1369
- }
1370
- *zCsr++ = quote;
1371
- *zCsr++ = '\0';
1372
- assert( (zCsr-zIn)==len );
1373
- }else{
1374
- memcpy(&zIn[nIn], zAppend, nAppend);
1375
- zIn[len-1] = '\0';
1376
- }
1377
-
1378
- return zIn;
2172
+ if( zName[i]==cQuote ) z[n++] = cQuote;
2173
+ }
2174
+ if( cQuote ) z[n++] = cQuote;
2175
+ z[n] = 0;
13792176
 }
13802177
13812178
13822179
 /*
13832180
 ** Execute a query statement that will generate SQL output. Print
@@ -1484,10 +2281,35 @@
14842281
 }
14852282
 fclose(in);
14862283
 }
14872284
 #endif
14882285
2286
+/*
2287
+** Display a single line of status using 64-bit values.
2288
+*/
2289
+static void displayStatLine(
2290
+ ShellState *p, /* The shell context */
2291
+ char *zLabel, /* Label for this one line */
2292
+ char *zFormat, /* Format for the result */
2293
+ int iStatusCtrl, /* Which status to display */
2294
+ int bReset /* True to reset the stats */
2295
+){
2296
+ sqlite3_int64 iCur = -1;
2297
+ sqlite3_int64 iHiwtr = -1;
2298
+ int i, nPercent;
2299
+ char zLine[200];
2300
+ sqlite3_status64(iStatusCtrl, &iCur, &iHiwtr, bReset);
2301
+ for(i=0, nPercent=0; zFormat[i]; i++){
2302
+ if( zFormat[i]=='%' ) nPercent++;
2303
+ }
2304
+ if( nPercent>1 ){
2305
+ sqlite3_snprintf(sizeof(zLine), zLine, zFormat, iCur, iHiwtr);
2306
+ }else{
2307
+ sqlite3_snprintf(sizeof(zLine), zLine, zFormat, iHiwtr);
2308
+ }
2309
+ raw_printf(p->out, "%-36s %s\n", zLabel, zLine);
2310
+}
14892311
14902312
 /*
14912313
 ** Display memory stats.
14922314
 */
14932315
 static int display_stats(
@@ -1497,61 +2319,35 @@
14972319
 ){
14982320
 int iCur;
14992321
 int iHiwtr;
15002322
15012323
 if( pArg && pArg->out ){
1502
-
1503
- iHiwtr = iCur = -1;
1504
- sqlite3_status(SQLITE_STATUS_MEMORY_USED, &iCur, &iHiwtr, bReset);
1505
- raw_printf(pArg->out,
1506
- "Memory Used: %d (max %d) bytes\n",
1507
- iCur, iHiwtr);
1508
- iHiwtr = iCur = -1;
1509
- sqlite3_status(SQLITE_STATUS_MALLOC_COUNT, &iCur, &iHiwtr, bReset);
1510
- raw_printf(pArg->out, "Number of Outstanding Allocations: %d (max %d)\n",
1511
- iCur, iHiwtr);
2324
+ displayStatLine(pArg, "Memory Used:",
2325
+ "%lld (max %lld) bytes", SQLITE_STATUS_MEMORY_USED, bReset);
2326
+ displayStatLine(pArg, "Number of Outstanding Allocations:",
2327
+ "%lld (max %lld)", SQLITE_STATUS_MALLOC_COUNT, bReset);
15122328
 if( pArg->shellFlgs & SHFLG_Pagecache ){
1513
- iHiwtr = iCur = -1;
1514
- sqlite3_status(SQLITE_STATUS_PAGECACHE_USED, &iCur, &iHiwtr, bReset);
1515
- raw_printf(pArg->out,
1516
- "Number of Pcache Pages Used: %d (max %d) pages\n",
1517
- iCur, iHiwtr);
1518
- }
1519
- iHiwtr = iCur = -1;
1520
- sqlite3_status(SQLITE_STATUS_PAGECACHE_OVERFLOW, &iCur, &iHiwtr, bReset);
1521
- raw_printf(pArg->out,
1522
- "Number of Pcache Overflow Bytes: %d (max %d) bytes\n",
1523
- iCur, iHiwtr);
2329
+ displayStatLine(pArg, "Number of Pcache Pages Used:",
2330
+ "%lld (max %lld) pages", SQLITE_STATUS_PAGECACHE_USED, bReset);
2331
+ }
2332
+ displayStatLine(pArg, "Number of Pcache Overflow Bytes:",
2333
+ "%lld (max %lld) bytes", SQLITE_STATUS_PAGECACHE_OVERFLOW, bReset);
15242334
 if( pArg->shellFlgs & SHFLG_Scratch ){
1525
- iHiwtr = iCur = -1;
1526
- sqlite3_status(SQLITE_STATUS_SCRATCH_USED, &iCur, &iHiwtr, bReset);
1527
- raw_printf(pArg->out,
1528
- "Number of Scratch Allocations Used: %d (max %d)\n",
1529
- iCur, iHiwtr);
1530
- }
1531
- iHiwtr = iCur = -1;
1532
- sqlite3_status(SQLITE_STATUS_SCRATCH_OVERFLOW, &iCur, &iHiwtr, bReset);
1533
- raw_printf(pArg->out,
1534
- "Number of Scratch Overflow Bytes: %d (max %d) bytes\n",
1535
- iCur, iHiwtr);
1536
- iHiwtr = iCur = -1;
1537
- sqlite3_status(SQLITE_STATUS_MALLOC_SIZE, &iCur, &iHiwtr, bReset);
1538
- raw_printf(pArg->out, "Largest Allocation: %d bytes\n",
1539
- iHiwtr);
1540
- iHiwtr = iCur = -1;
1541
- sqlite3_status(SQLITE_STATUS_PAGECACHE_SIZE, &iCur, &iHiwtr, bReset);
1542
- raw_printf(pArg->out, "Largest Pcache Allocation: %d bytes\n",
1543
- iHiwtr);
1544
- iHiwtr = iCur = -1;
1545
- sqlite3_status(SQLITE_STATUS_SCRATCH_SIZE, &iCur, &iHiwtr, bReset);
1546
- raw_printf(pArg->out, "Largest Scratch Allocation: %d bytes\n",
1547
- iHiwtr);
2335
+ displayStatLine(pArg, "Number of Scratch Allocations Used:",
2336
+ "%lld (max %lld)", SQLITE_STATUS_SCRATCH_USED, bReset);
2337
+ }
2338
+ displayStatLine(pArg, "Number of Scratch Overflow Bytes:",
2339
+ "%lld (max %lld) bytes", SQLITE_STATUS_SCRATCH_OVERFLOW, bReset);
2340
+ displayStatLine(pArg, "Largest Allocation:",
2341
+ "%lld bytes", SQLITE_STATUS_MALLOC_SIZE, bReset);
2342
+ displayStatLine(pArg, "Largest Pcache Allocation:",
2343
+ "%lld bytes", SQLITE_STATUS_PAGECACHE_SIZE, bReset);
2344
+ displayStatLine(pArg, "Largest Scratch Allocation:",
2345
+ "%lld bytes", SQLITE_STATUS_SCRATCH_SIZE, bReset);
15482346
 #ifdef YYTRACKMAXSTACKDEPTH
1549
- iHiwtr = iCur = -1;
1550
- sqlite3_status(SQLITE_STATUS_PARSER_STACK, &iCur, &iHiwtr, bReset);
1551
- raw_printf(pArg->out, "Deepest Parser Stack: %d (max %d)\n",
1552
- iCur, iHiwtr);
2347
+ displayStatLine(pArg, "Deepest Parser Stack:",
2348
+ "%lld (max %lld)", SQLITE_STATUS_PARSER_STACK, bReset);
15532349
 #endif
15542350
 }
15552351
15562352
 if( pArg && pArg->out && db ){
15572353
 if( pArg->shellFlgs & SHFLG_Lookaside ){
@@ -1934,11 +2730,11 @@
19342730
 pArg->pStmt = pStmt;
19352731
 pArg->cnt = 0;
19362732
 }
19372733
19382734
 /* echo the sql statement if echo on */
1939
- if( pArg && pArg->echoOn ){
2735
+ if( pArg && ShellHasFlag(pArg, SHFLG_Echo) ){
19402736
 utf8_printf(pArg->out, "%s\n", zStmtSql ? zStmtSql : zSql);
19412737
 }
19422738
19432739
 /* Show the EXPLAIN QUERY PLAN if .eqp is on */
19442740
 if( pArg && pArg->autoEQP && sqlite3_strlike("EXPLAIN%",zStmtSql,0)!=0 ){
@@ -2022,10 +2818,142 @@
20222818
 } /* end while */
20232819
20242820
 return rc;
20252821
 }
20262822
2823
+/*
2824
+** Release memory previously allocated by tableColumnList().
2825
+*/
2826
+static void freeColumnList(char **azCol){
2827
+ int i;
2828
+ for(i=1; azCol[i]; i++){
2829
+ sqlite3_free(azCol[i]);
2830
+ }
2831
+ /* azCol[0] is a static string */
2832
+ sqlite3_free(azCol);
2833
+}
2834
+
2835
+/*
2836
+** Return a list of pointers to strings which are the names of all
2837
+** columns in table zTab. The memory to hold the names is dynamically
2838
+** allocated and must be released by the caller using a subsequent call
2839
+** to freeColumnList().
2840
+**
2841
+** The azCol[0] entry is usually NULL. However, if zTab contains a rowid
2842
+** value that needs to be preserved, then azCol[0] is filled in with the
2843
+** name of the rowid column.
2844
+**
2845
+** The first regular column in the table is azCol[1]. The list is terminated
2846
+** by an entry with azCol[i]==0.
2847
+*/
2848
+static char **tableColumnList(ShellState *p, const char *zTab){
2849
+ char **azCol = 0;
2850
+ sqlite3_stmt *pStmt;
2851
+ char *zSql;
2852
+ int nCol = 0;
2853
+ int nAlloc = 0;
2854
+ int nPK = 0; /* Number of PRIMARY KEY columns seen */
2855
+ int isIPK = 0; /* True if one PRIMARY KEY column of type INTEGER */
2856
+ int preserveRowid = ShellHasFlag(p, SHFLG_PreserveRowid);
2857
+ int rc;
2858
+
2859
+ zSql = sqlite3_mprintf("PRAGMA table_info=%Q", zTab);
2860
+ rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
2861
+ sqlite3_free(zSql);
2862
+ if( rc ) return 0;
2863
+ while( sqlite3_step(pStmt)==SQLITE_ROW ){
2864
+ if( nCol>=nAlloc-2 ){
2865
+ nAlloc = nAlloc*2 + nCol + 10;
2866
+ azCol = sqlite3_realloc(azCol, nAlloc*sizeof(azCol[0]));
2867
+ if( azCol==0 ){
2868
+ raw_printf(stderr, "Error: out of memory\n");
2869
+ exit(1);
2870
+ }
2871
+ }
2872
+ azCol[++nCol] = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 1));
2873
+ if( sqlite3_column_int(pStmt, 5) ){
2874
+ nPK++;
2875
+ if( nPK==1
2876
+ && sqlite3_stricmp((const char*)sqlite3_column_text(pStmt,2),
2877
+ "INTEGER")==0
2878
+ ){
2879
+ isIPK = 1;
2880
+ }else{
2881
+ isIPK = 0;
2882
+ }
2883
+ }
2884
+ }
2885
+ sqlite3_finalize(pStmt);
2886
+ azCol[0] = 0;
2887
+ azCol[nCol+1] = 0;
2888
+
2889
+ /* The decision of whether or not a rowid really needs to be preserved
2890
+ ** is tricky. We never need to preserve a rowid for a WITHOUT ROWID table
2891
+ ** or a table with an INTEGER PRIMARY KEY. We are unable to preserve
2892
+ ** rowids on tables where the rowid is inaccessible because there are other
2893
+ ** columns in the table named "rowid", "_rowid_", and "oid".
2894
+ */
2895
+ if( preserveRowid && isIPK ){
2896
+ /* If a single PRIMARY KEY column with type INTEGER was seen, then it
2897
+ ** might be an alise for the ROWID. But it might also be a WITHOUT ROWID
2898
+ ** table or a INTEGER PRIMARY KEY DESC column, neither of which are
2899
+ ** ROWID aliases. To distinguish these cases, check to see if
2900
+ ** there is a "pk" entry in "PRAGMA index_list". There will be
2901
+ ** no "pk" index if the PRIMARY KEY really is an alias for the ROWID.
2902
+ */
2903
+ zSql = sqlite3_mprintf("SELECT 1 FROM pragma_index_list(%Q)"
2904
+ " WHERE origin='pk'", zTab);
2905
+ rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
2906
+ sqlite3_free(zSql);
2907
+ if( rc ){
2908
+ freeColumnList(azCol);
2909
+ return 0;
2910
+ }
2911
+ rc = sqlite3_step(pStmt);
2912
+ sqlite3_finalize(pStmt);
2913
+ preserveRowid = rc==SQLITE_ROW;
2914
+ }
2915
+ if( preserveRowid ){
2916
+ /* Only preserve the rowid if we can find a name to use for the
2917
+ ** rowid */
2918
+ static char *azRowid[] = { "rowid", "_rowid_", "oid" };
2919
+ int i, j;
2920
+ for(j=0; j<3; j++){
2921
+ for(i=1; i<=nCol; i++){
2922
+ if( sqlite3_stricmp(azRowid[j],azCol[i])==0 ) break;
2923
+ }
2924
+ if( i>nCol ){
2925
+ /* At this point, we know that azRowid[j] is not the name of any
2926
+ ** ordinary column in the table. Verify that azRowid[j] is a valid
2927
+ ** name for the rowid before adding it to azCol[0]. WITHOUT ROWID
2928
+ ** tables will fail this last check */
2929
+ int rc;
2930
+ rc = sqlite3_table_column_metadata(p->db,0,zTab,azRowid[j],0,0,0,0,0);
2931
+ if( rc==SQLITE_OK ) azCol[0] = azRowid[j];
2932
+ break;
2933
+ }
2934
+ }
2935
+ }
2936
+ return azCol;
2937
+}
2938
+
2939
+/*
2940
+** Toggle the reverse_unordered_selects setting.
2941
+*/
2942
+static void toggleSelectOrder(sqlite3 *db){
2943
+ sqlite3_stmt *pStmt = 0;
2944
+ int iSetting = 0;
2945
+ char zStmt[100];
2946
+ sqlite3_prepare_v2(db, "PRAGMA reverse_unordered_selects", -1, &pStmt, 0);
2947
+ if( sqlite3_step(pStmt)==SQLITE_ROW ){
2948
+ iSetting = sqlite3_column_int(pStmt, 0);
2949
+ }
2950
+ sqlite3_finalize(pStmt);
2951
+ sqlite3_snprintf(sizeof(zStmt), zStmt,
2952
+ "PRAGMA reverse_unordered_selects(%d)", !iSetting);
2953
+ sqlite3_exec(db, zStmt, 0, 0, 0);
2954
+}
20272955
20282956
 /*
20292957
 ** This is a different callback routine used for dumping the database.
20302958
 ** Each row received by this callback consists of a table name,
20312959
 ** the table type ("index" or "table") and SQL to create the table.
@@ -2034,21 +2962,20 @@
20342962
 static int dump_callback(void *pArg, int nArg, char **azArg, char **azCol){
20352963
 int rc;
20362964
 const char *zTable;
20372965
 const char *zType;
20382966
 const char *zSql;
2039
- const char *zPrepStmt = 0;
20402967
 ShellState *p = (ShellState *)pArg;
20412968
20422969
 UNUSED_PARAMETER(azCol);
20432970
 if( nArg!=3 ) return 1;
20442971
 zTable = azArg[0];
20452972
 zType = azArg[1];
20462973
 zSql = azArg[2];
20472974
20482975
 if( strcmp(zTable, "sqlite_sequence")==0 ){
2049
- zPrepStmt = "DELETE FROM sqlite_sequence;\n";
2976
+ raw_printf(p->out, "DELETE FROM sqlite_sequence;\n");
20502977
 }else if( sqlite3_strglob("sqlite_stat?", zTable)==0 ){
20512978
 raw_printf(p->out, "ANALYZE sqlite_master;\n");
20522979
 }else if( strncmp(zTable, "sqlite_", 7)==0 ){
20532980
 return 0;
20542981
 }else if( strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){
@@ -2067,62 +2994,74 @@
20672994
 }else{
20682995
 printSchemaLine(p->out, zSql, ";\n");
20692996
 }
20702997
20712998
 if( strcmp(zType, "table")==0 ){
2072
- sqlite3_stmt *pTableInfo = 0;
2073
- char *zSelect = 0;
2074
- char *zTableInfo = 0;
2075
- char *zTmp = 0;
2076
- int nRow = 0;
2077
-
2078
- zTableInfo = appendText(zTableInfo, "PRAGMA table_info(", 0);
2079
- zTableInfo = appendText(zTableInfo, zTable, '"');
2080
- zTableInfo = appendText(zTableInfo, ");", 0);
2081
-
2082
- rc = sqlite3_prepare_v2(p->db, zTableInfo, -1, &pTableInfo, 0);
2083
- free(zTableInfo);
2084
- if( rc!=SQLITE_OK || !pTableInfo ){
2085
- return 1;
2086
- }
2087
-
2088
- zSelect = appendText(zSelect, "SELECT 'INSERT INTO ' || ", 0);
2999
+ ShellText sSelect;
3000
+ ShellText sTable;
3001
+ char **azCol;
3002
+ int i;
3003
+ char *savedDestTable;
3004
+ int savedMode;
3005
+
3006
+ azCol = tableColumnList(p, zTable);
3007
+ if( azCol==0 ){
3008
+ p->nErr++;
3009
+ return 0;
3010
+ }
3011
+
20893012
 /* Always quote the table name, even if it appears to be pure ascii,
20903013
 ** in case it is a keyword. Ex: INSERT INTO "table" ... */
2091
- zTmp = appendText(zTmp, zTable, '"');
2092
- if( zTmp ){
2093
- zSelect = appendText(zSelect, zTmp, '\'');
2094
- free(zTmp);
2095
- }
2096
- zSelect = appendText(zSelect, " || ' VALUES(' || ", 0);
2097
- rc = sqlite3_step(pTableInfo);
2098
- while( rc==SQLITE_ROW ){
2099
- const char *zText = (const char *)sqlite3_column_text(pTableInfo, 1);
2100
- zSelect = appendText(zSelect, "quote(", 0);
2101
- zSelect = appendText(zSelect, zText, '"');
2102
- rc = sqlite3_step(pTableInfo);
2103
- if( rc==SQLITE_ROW ){
2104
- zSelect = appendText(zSelect, "), ", 0);
2105
- }else{
2106
- zSelect = appendText(zSelect, ") ", 0);
2107
- }
2108
- nRow++;
2109
- }
2110
- rc = sqlite3_finalize(pTableInfo);
2111
- if( rc!=SQLITE_OK || nRow==0 ){
2112
- free(zSelect);
2113
- return 1;
2114
- }
2115
- zSelect = appendText(zSelect, "|| ')' FROM ", 0);
2116
- zSelect = appendText(zSelect, zTable, '"');
2117
-
2118
- rc = run_table_dump_query(p, zSelect, zPrepStmt);
2119
- if( rc==SQLITE_CORRUPT ){
2120
- zSelect = appendText(zSelect, " ORDER BY rowid DESC", 0);
2121
- run_table_dump_query(p, zSelect, 0);
2122
- }
2123
- free(zSelect);
3014
+ initText(&sTable);
3015
+ appendText(&sTable, zTable, quoteChar(zTable));
3016
+ /* If preserving the rowid, add a column list after the table name.
3017
+ ** In other words: "INSERT INTO tab(rowid,a,b,c,...) VALUES(...)"
3018
+ ** instead of the usual "INSERT INTO tab VALUES(...)".
3019
+ */
3020
+ if( azCol[0] ){
3021
+ appendText(&sTable, "(", 0);
3022
+ appendText(&sTable, azCol[0], 0);
3023
+ for(i=1; azCol[i]; i++){
3024
+ appendText(&sTable, ",", 0);
3025
+ appendText(&sTable, azCol[i], quoteChar(azCol[i]));
3026
+ }
3027
+ appendText(&sTable, ")", 0);
3028
+ }
3029
+
3030
+ /* Build an appropriate SELECT statement */
3031
+ initText(&sSelect);
3032
+ appendText(&sSelect, "SELECT ", 0);
3033
+ if( azCol[0] ){
3034
+ appendText(&sSelect, azCol[0], 0);
3035
+ appendText(&sSelect, ",", 0);
3036
+ }
3037
+ for(i=1; azCol[i]; i++){
3038
+ appendText(&sSelect, azCol[i], quoteChar(azCol[i]));
3039
+ if( azCol[i+1] ){
3040
+ appendText(&sSelect, ",", 0);
3041
+ }
3042
+ }
3043
+ freeColumnList(azCol);
3044
+ appendText(&sSelect, " FROM ", 0);
3045
+ appendText(&sSelect, zTable, quoteChar(zTable));
3046
+
3047
+ savedDestTable = p->zDestTable;
3048
+ savedMode = p->mode;
3049
+ p->zDestTable = sTable.z;
3050
+ p->mode = p->cMode = MODE_Insert;
3051
+ rc = shell_exec(p->db, sSelect.z, shell_callback, p, 0);
3052
+ if( (rc&0xff)==SQLITE_CORRUPT ){
3053
+ raw_printf(p->out, "/****** CORRUPTION ERROR *******/\n");
3054
+ toggleSelectOrder(p->db);
3055
+ shell_exec(p->db, sSelect.z, shell_callback, p, 0);
3056
+ toggleSelectOrder(p->db);
3057
+ }
3058
+ p->zDestTable = savedDestTable;
3059
+ p->mode = savedMode;
3060
+ freeText(&sTable);
3061
+ freeText(&sSelect);
3062
+ if( rc ) p->nErr++;
21243063
 }
21253064
 return 0;
21263065
 }
21273066
21283067
 /*
@@ -2228,15 +3167,17 @@
22283167
 ".restore ?DB? FILE Restore content of DB (default \"main\") from FILE\n"
22293168
 ".save FILE Write in-memory database into FILE\n"
22303169
 ".scanstats on|off Turn sqlite3_stmt_scanstatus() metrics on or off\n"
22313170
 ".schema ?PATTERN? Show the CREATE statements matching PATTERN\n"
22323171
 " Add --indent for pretty-printing\n"
3172
+ ".selftest ?--init? Run tests defined in the SELFTEST table\n"
22333173
 ".separator COL ?ROW? Change the column separator and optionally the row\n"
22343174
 " separator for both the output mode and .import\n"
22353175
 #if defined(SQLITE_ENABLE_SESSION)
22363176
 ".session CMD ... Create or control sessions\n"
22373177
 #endif
3178
+ ".sha3sum ?OPTIONS...? Compute a SHA3 hash of database content\n"
22383179
 ".shell CMD ARGS... Run CMD ARGS... in a system shell\n"
22393180
 ".show Show the current values for various settings\n"
22403181
 ".stats ?on|off? Show stats or turn stats on or off\n"
22413182
 ".system CMD ARGS... Run CMD ARGS... in a system shell\n"
22423183
 ".tables ?TABLE? List names of tables\n"
@@ -2423,14 +3364,10 @@
24233364
 static void open_db(ShellState *p, int keepAlive){
24243365
 if( p->db==0 ){
24253366
 sqlite3_initialize();
24263367
 sqlite3_open(p->zDbFilename, &p->db);
24273368
 globalDb = p->db;
2428
- if( p->db && sqlite3_errcode(p->db)==SQLITE_OK ){
2429
- sqlite3_create_function(p->db, "shellstatic", 0, SQLITE_UTF8, 0,
2430
- shellstaticFunc, 0, 0);
2431
- }
24323369
 if( p->db==0 || SQLITE_OK!=sqlite3_errcode(p->db) ){
24333370
 utf8_printf(stderr,"Error: unable to open database \"%s\": %s\n",
24343371
 p->zDbFilename, sqlite3_errmsg(p->db));
24353372
 if( keepAlive ) return;
24363373
 exit(1);
@@ -2440,10 +3377,18 @@
24403377
 #endif
24413378
 sqlite3_create_function(p->db, "readfile", 1, SQLITE_UTF8, 0,
24423379
 readfileFunc, 0, 0);
24433380
 sqlite3_create_function(p->db, "writefile", 2, SQLITE_UTF8, 0,
24443381
 writefileFunc, 0, 0);
3382
+ sqlite3_create_function(p->db, "sha3", 1, SQLITE_UTF8, 0,
3383
+ sha3Func, 0, 0);
3384
+ sqlite3_create_function(p->db, "sha3", 2, SQLITE_UTF8, 0,
3385
+ sha3Func, 0, 0);
3386
+ sqlite3_create_function(p->db, "sha3_query", 1, SQLITE_UTF8, 0,
3387
+ sha3QueryFunc, 0, 0);
3388
+ sqlite3_create_function(p->db, "sha3_query", 2, SQLITE_UTF8, 0,
3389
+ sha3QueryFunc, 0, 0);
24453390
 }
24463391
 }
24473392
24483393
 /*
24493394
 ** Do C-language style dequoting.
@@ -2564,11 +3509,11 @@
25643509
25653510
 /*
25663511
 ** Interpret zArg as either an integer or a boolean value. Return 1 or 0
25673512
 ** for TRUE and FALSE. Return the integer value if appropriate.
25683513
 */
2569
-static int booleanValue(char *zArg){
3514
+static int booleanValue(const char *zArg){
25703515
 int i;
25713516
 if( zArg[0]=='0' && zArg[1]=='x' ){
25723517
 for(i=2; hexDigitValue(zArg[i])>=0; i++){}
25733518
 }else{
25743519
 for(i=0; zArg[i]>='0' && zArg[i]<='9'; i++){}
@@ -2582,10 +3527,21 @@
25823527
 }
25833528
 utf8_printf(stderr, "ERROR: Not a boolean value: \"%s\". Assuming \"no\".\n",
25843529
 zArg);
25853530
 return 0;
25863531
 }
3532
+
3533
+/*
3534
+** Set or clear a shell flag according to a boolean value.
3535
+*/
3536
+static void setOrClearFlag(ShellState *p, unsigned mFlag, const char *zArg){
3537
+ if( booleanValue(zArg) ){
3538
+ ShellSetFlag(p, mFlag);
3539
+ }else{
3540
+ ShellClearFlag(p, mFlag);
3541
+ }
3542
+}
25873543
25883544
 /*
25893545
 ** Close an output file, assuming it is not stderr or stdout
25903546
 */
25913547
 static void output_file_close(FILE *f){
@@ -3656,11 +4612,11 @@
36564612
 test_breakpoint();
36574613
 }else
36584614
36594615
 if( c=='c' && n>=3 && strncmp(azArg[0], "changes", n)==0 ){
36604616
 if( nArg==2 ){
3661
- p->countChanges = booleanValue(azArg[1]);
4617
+ setOrClearFlag(p, SHFLG_CountChanges, azArg[1]);
36624618
 }else{
36634619
 raw_printf(stderr, "Usage: .changes on|off\n");
36644620
 rc = 1;
36654621
 }
36664622
 }else
@@ -3720,25 +4676,46 @@
37204676
 if( c=='d' && strncmp(azArg[0], "dbinfo", n)==0 ){
37214677
 rc = shell_dbinfo_command(p, nArg, azArg);
37224678
 }else
37234679
37244680
 if( c=='d' && strncmp(azArg[0], "dump", n)==0 ){
4681
+ const char *zLike = 0;
4682
+ int i;
4683
+ ShellClearFlag(p, SHFLG_PreserveRowid);
4684
+ for(i=1; i<nArg; i++){
4685
+ if( azArg[i][0]=='-' ){
4686
+ const char *z = azArg[i]+1;
4687
+ if( z[0]=='-' ) z++;
4688
+ if( strcmp(z,"preserve-rowids")==0 ){
4689
+ ShellSetFlag(p, SHFLG_PreserveRowid);
4690
+ }else
4691
+ {
4692
+ raw_printf(stderr, "Unknown option \"%s\" on \".dump\"\n", azArg[i]);
4693
+ rc = 1;
4694
+ goto meta_command_exit;
4695
+ }
4696
+ }else if( zLike ){
4697
+ raw_printf(stderr, "Usage: .dump ?--preserve-rowids? ?LIKE-PATTERN?\n");
4698
+ rc = 1;
4699
+ goto meta_command_exit;
4700
+ }else{
4701
+ zLike = azArg[i];
4702
+ }
4703
+ }
37254704
 open_db(p, 0);
37264705
 /* When playing back a "dump", the content might appear in an order
37274706
 ** which causes immediate foreign key constraints to be violated.
37284707
 ** So disable foreign-key constraint enforcement to prevent problems. */
3729
- if( nArg!=1 && nArg!=2 ){
3730
- raw_printf(stderr, "Usage: .dump ?LIKE-PATTERN?\n");
3731
- rc = 1;
3732
- goto meta_command_exit;
3733
- }
37344708
 raw_printf(p->out, "PRAGMA foreign_keys=OFF;\n");
37354709
 raw_printf(p->out, "BEGIN TRANSACTION;\n");
37364710
 p->writableSchema = 0;
4711
+ /* Set writable_schema=ON since doing so forces SQLite to initialize
4712
+ ** as much of the schema as it can even if the sqlite_master table is
4713
+ ** corrupt. */
37374714
 sqlite3_exec(p->db, "SAVEPOINT dump; PRAGMA writable_schema=ON", 0, 0, 0);
37384715
 p->nErr = 0;
3739
- if( nArg==1 ){
4716
+ if( zLike==0 ){
37404717
 run_schema_dump_query(p,
37414718
 "SELECT name, type, sql FROM sqlite_master "
37424719
 "WHERE sql NOT NULL AND type=='table' AND name!='sqlite_sequence'"
37434720
 );
37444721
 run_schema_dump_query(p,
@@ -3748,25 +4725,24 @@
37484725
 run_table_dump_query(p,
37494726
 "SELECT sql FROM sqlite_master "
37504727
 "WHERE sql NOT NULL AND type IN ('index','trigger','view')", 0
37514728
 );
37524729
 }else{
3753
- int i;
3754
- for(i=1; i<nArg; i++){
3755
- zShellStatic = azArg[i];
3756
- run_schema_dump_query(p,
3757
- "SELECT name, type, sql FROM sqlite_master "
3758
- "WHERE tbl_name LIKE shellstatic() AND type=='table'"
3759
- " AND sql NOT NULL");
3760
- run_table_dump_query(p,
3761
- "SELECT sql FROM sqlite_master "
3762
- "WHERE sql NOT NULL"
3763
- " AND type IN ('index','trigger','view')"
3764
- " AND tbl_name LIKE shellstatic()", 0
3765
- );
3766
- zShellStatic = 0;
3767
- }
4730
+ char *zSql;
4731
+ zSql = sqlite3_mprintf(
4732
+ "SELECT name, type, sql FROM sqlite_master "
4733
+ "WHERE tbl_name LIKE %Q AND type=='table'"
4734
+ " AND sql NOT NULL", zLike);
4735
+ run_schema_dump_query(p,zSql);
4736
+ sqlite3_free(zSql);
4737
+ zSql = sqlite3_mprintf(
4738
+ "SELECT sql FROM sqlite_master "
4739
+ "WHERE sql NOT NULL"
4740
+ " AND type IN ('index','trigger','view')"
4741
+ " AND tbl_name LIKE %Q", zLike);
4742
+ run_table_dump_query(p, zSql, 0);
4743
+ sqlite3_free(zSql);
37684744
 }
37694745
 if( p->writableSchema ){
37704746
 raw_printf(p->out, "PRAGMA writable_schema=OFF;\n");
37714747
 p->writableSchema = 0;
37724748
 }
@@ -3775,11 +4751,11 @@
37754751
 raw_printf(p->out, p->nErr ? "ROLLBACK; -- due to errors\n" : "COMMIT;\n");
37764752
 }else
37774753
37784754
 if( c=='e' && strncmp(azArg[0], "echo", n)==0 ){
37794755
 if( nArg==2 ){
3780
- p->echoOn = booleanValue(azArg[1]);
4756
+ setOrClearFlag(p, SHFLG_Echo, azArg[1]);
37814757
 }else{
37824758
 raw_printf(stderr, "Usage: .echo on|off\n");
37834759
 rc = 1;
37844760
 }
37854761
 }else
@@ -4572,21 +5548,21 @@
45725548
 new_colv[0] = "sql";
45735549
 new_colv[1] = 0;
45745550
 callback(&data, 1, new_argv, new_colv);
45755551
 rc = SQLITE_OK;
45765552
 }else{
4577
- zShellStatic = azArg[1];
4578
- rc = sqlite3_exec(p->db,
5553
+ char *zSql;
5554
+ zSql = sqlite3_mprintf(
45795555
 "SELECT sql FROM "
45805556
 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
45815557
 " FROM sqlite_master UNION ALL"
45825558
 " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
4583
- "WHERE lower(tbl_name) LIKE shellstatic()"
5559
+ "WHERE lower(tbl_name) LIKE %Q"
45845560
 " AND type!='meta' AND sql NOTNULL "
4585
- "ORDER BY rowid",
4586
- callback, &data, &zErrMsg);
4587
- zShellStatic = 0;
5561
+ "ORDER BY rowid", azArg[1]);
5562
+ rc = sqlite3_exec(p->db, zSql, callback, &data, &zErrMsg);
5563
+ sqlite3_free(zSql);
45885564
 }
45895565
 }else if( nArg==1 ){
45905566
 rc = sqlite3_exec(p->db,
45915567
 "SELECT sql FROM "
45925568
 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
@@ -4835,10 +5811,123 @@
48355811
 utf8_printf(p->out, "%s", zBuf);
48365812
 }
48375813
 }
48385814
 }else
48395815
 #endif
5816
+
5817
+ if( c=='s' && n>=4 && strncmp(azArg[0],"selftest",n)==0 ){
5818
+ int bIsInit = 0; /* True to initialize the SELFTEST table */
5819
+ int bVerbose = 0; /* Verbose output */
5820
+ int bSelftestExists; /* True if SELFTEST already exists */
5821
+ char **azTest = 0; /* Content of the SELFTEST table */
5822
+ int nRow = 0; /* Number of rows in the SELFTEST table */
5823
+ int nCol = 4; /* Number of columns in the SELFTEST table */
5824
+ int i; /* Loop counter */
5825
+ int nTest = 0; /* Number of tests runs */
5826
+ int nErr = 0; /* Number of errors seen */
5827
+ ShellText str; /* Answer for a query */
5828
+ static char *azDefaultTest[] = {
5829
+ 0, 0, 0, 0,
5830
+ "0", "memo", "Missing SELFTEST table - default checks only", "",
5831
+ "1", "run", "PRAGMA integrity_check", "ok"
5832
+ };
5833
+ static const int nDefaultRow = 2;
5834
+
5835
+ open_db(p,0);
5836
+ for(i=1; i<nArg; i++){
5837
+ const char *z = azArg[i];
5838
+ if( z[0]=='-' && z[1]=='-' ) z++;
5839
+ if( strcmp(z,"-init")==0 ){
5840
+ bIsInit = 1;
5841
+ }else
5842
+ if( strcmp(z,"-v")==0 ){
5843
+ bVerbose++;
5844
+ }else
5845
+ {
5846
+ utf8_printf(stderr, "Unknown option \"%s\" on \"%s\"\n",
5847
+ azArg[i], azArg[0]);
5848
+ raw_printf(stderr, "Should be one of: --init -v\n");
5849
+ rc = 1;
5850
+ goto meta_command_exit;
5851
+ }
5852
+ }
5853
+ if( sqlite3_table_column_metadata(p->db,"main","selftest",0,0,0,0,0,0)
5854
+ != SQLITE_OK ){
5855
+ bSelftestExists = 0;
5856
+ }else{
5857
+ bSelftestExists = 1;
5858
+ }
5859
+ if( bIsInit ){
5860
+ createSelftestTable(p);
5861
+ bSelftestExists = 1;
5862
+ }
5863
+ if( bSelftestExists ){
5864
+ rc = sqlite3_get_table(p->db,
5865
+ "SELECT tno,op,cmd,ans FROM selftest ORDER BY tno",
5866
+ &azTest, &nRow, &nCol, 0);
5867
+ if( rc ){
5868
+ raw_printf(stderr, "Error querying the selftest table\n");
5869
+ rc = 1;
5870
+ sqlite3_free_table(azTest);
5871
+ goto meta_command_exit;
5872
+ }else if( nRow==0 ){
5873
+ sqlite3_free_table(azTest);
5874
+ azTest = azDefaultTest;
5875
+ nRow = nDefaultRow;
5876
+ }
5877
+ }else{
5878
+ azTest = azDefaultTest;
5879
+ nRow = nDefaultRow;
5880
+ }
5881
+ initText(&str);
5882
+ appendText(&str, "x", 0);
5883
+ for(i=1; i<=nRow; i++){
5884
+ int tno = atoi(azTest[i*nCol]);
5885
+ const char *zOp = azTest[i*nCol+1];
5886
+ const char *zSql = azTest[i*nCol+2];
5887
+ const char *zAns = azTest[i*nCol+3];
5888
+
5889
+ if( bVerbose>0 ){
5890
+ char *zQuote = sqlite3_mprintf("%q", zSql);
5891
+ printf("%d: %s %s\n", tno, zOp, zSql);
5892
+ sqlite3_free(zQuote);
5893
+ }
5894
+ if( strcmp(zOp,"memo")==0 ){
5895
+ utf8_printf(p->out, "%s\n", zSql);
5896
+ }else
5897
+ if( strcmp(zOp,"run")==0 ){
5898
+ char *zErrMsg = 0;
5899
+ str.n = 0;
5900
+ str.z[0] = 0;
5901
+ rc = sqlite3_exec(p->db, zSql, captureOutputCallback, &str, &zErrMsg);
5902
+ nTest++;
5903
+ if( bVerbose ){
5904
+ utf8_printf(p->out, "Result: %s\n", str.z);
5905
+ }
5906
+ if( rc || zErrMsg ){
5907
+ nErr++;
5908
+ rc = 1;
5909
+ utf8_printf(p->out, "%d: error-code-%d: %s\n", tno, rc, zErrMsg);
5910
+ sqlite3_free(zErrMsg);
5911
+ }else if( strcmp(zAns,str.z)!=0 ){
5912
+ nErr++;
5913
+ rc = 1;
5914
+ utf8_printf(p->out, "%d: Expected: [%s]\n", tno, zAns);
5915
+ utf8_printf(p->out, "%d: Got: [%s]\n", tno, str.z);
5916
+ }
5917
+ }else
5918
+ {
5919
+ utf8_printf(stderr,
5920
+ "Unknown operation \"%s\" on selftest line %d\n", zOp, tno);
5921
+ rc = 1;
5922
+ break;
5923
+ }
5924
+ }
5925
+ freeText(&str);
5926
+ if( azTest!=azDefaultTest ) sqlite3_free_table(azTest);
5927
+ utf8_printf(p->out, "%d errors out of %d tests\n", nErr, nTest);
5928
+ }else
48405929
48415930
 if( c=='s' && strncmp(azArg[0], "separator", n)==0 ){
48425931
 if( nArg<2 || nArg>3 ){
48435932
 raw_printf(stderr, "Usage: .separator COL ?ROW?\n");
48445933
 rc = 1;
@@ -4850,10 +5939,126 @@
48505939
 if( nArg>=3 ){
48515940
 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator,
48525941
 "%.*s", (int)ArraySize(p->rowSeparator)-1, azArg[2]);
48535942
 }
48545943
 }else
5944
+
5945
+ if( c=='s' && n>=4 && strncmp(azArg[0],"sha3sum",n)==0 ){
5946
+ const char *zLike = 0; /* Which table to checksum. 0 means everything */
5947
+ int i; /* Loop counter */
5948
+ int bSchema = 0; /* Also hash the schema */
5949
+ int bSeparate = 0; /* Hash each table separately */
5950
+ int iSize = 224; /* Hash algorithm to use */
5951
+ int bDebug = 0; /* Only show the query that would have run */
5952
+ sqlite3_stmt *pStmt; /* For querying tables names */
5953
+ char *zSql; /* SQL to be run */
5954
+ char *zSep; /* Separator */
5955
+ ShellText sSql; /* Complete SQL for the query to run the hash */
5956
+ ShellText sQuery; /* Set of queries used to read all content */
5957
+ open_db(p, 0);
5958
+ for(i=1; i<nArg; i++){
5959
+ const char *z = azArg[i];
5960
+ if( z[0]=='-' ){
5961
+ z++;
5962
+ if( z[0]=='-' ) z++;
5963
+ if( strcmp(z,"schema")==0 ){
5964
+ bSchema = 1;
5965
+ }else
5966
+ if( strcmp(z,"sha3-224")==0 || strcmp(z,"sha3-256")==0
5967
+ || strcmp(z,"sha3-384")==0 || strcmp(z,"sha3-512")==0
5968
+ ){
5969
+ iSize = atoi(&z[5]);
5970
+ }else
5971
+ if( strcmp(z,"debug")==0 ){
5972
+ bDebug = 1;
5973
+ }else
5974
+ {
5975
+ utf8_printf(stderr, "Unknown option \"%s\" on \"%s\"\n",
5976
+ azArg[i], azArg[0]);
5977
+ raw_printf(stderr, "Should be one of: --schema"
5978
+ " --sha3-224 --sha3-255 --sha3-384 --sha3-512\n");
5979
+ rc = 1;
5980
+ goto meta_command_exit;
5981
+ }
5982
+ }else if( zLike ){
5983
+ raw_printf(stderr, "Usage: .sha3sum ?OPTIONS? ?LIKE-PATTERN?\n");
5984
+ rc = 1;
5985
+ goto meta_command_exit;
5986
+ }else{
5987
+ zLike = z;
5988
+ bSeparate = 1;
5989
+ if( sqlite3_strlike("sqlite_%", zLike, 0)==0 ) bSchema = 1;
5990
+ }
5991
+ }
5992
+ if( bSchema ){
5993
+ zSql = "SELECT lower(name) FROM sqlite_master"
5994
+ " WHERE type='table' AND coalesce(rootpage,0)>1"
5995
+ " UNION ALL SELECT 'sqlite_master'"
5996
+ " ORDER BY 1 collate nocase";
5997
+ }else{
5998
+ zSql = "SELECT lower(name) FROM sqlite_master"
5999
+ " WHERE type='table' AND coalesce(rootpage,0)>1"
6000
+ " AND name NOT LIKE 'sqlite_%'"
6001
+ " ORDER BY 1 collate nocase";
6002
+ }
6003
+ sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
6004
+ initText(&sQuery);
6005
+ initText(&sSql);
6006
+ appendText(&sSql, "WITH [sha3sum$query](a,b) AS(",0);
6007
+ zSep = "VALUES(";
6008
+ while( SQLITE_ROW==sqlite3_step(pStmt) ){
6009
+ const char *zTab = (const char*)sqlite3_column_text(pStmt,0);
6010
+ if( zLike && sqlite3_strlike(zLike, zTab, 0)!=0 ) continue;
6011
+ if( strncmp(zTab, "sqlite_",7)!=0 ){
6012
+ appendText(&sQuery,"SELECT * FROM ", 0);
6013
+ appendText(&sQuery,zTab,'"');
6014
+ appendText(&sQuery," NOT INDEXED;", 0);
6015
+ }else if( strcmp(zTab, "sqlite_master")==0 ){
6016
+ appendText(&sQuery,"SELECT type,name,tbl_name,sql FROM sqlite_master"
6017
+ " ORDER BY name;", 0);
6018
+ }else if( strcmp(zTab, "sqlite_sequence")==0 ){
6019
+ appendText(&sQuery,"SELECT name,seq FROM sqlite_sequence"
6020
+ " ORDER BY name;", 0);
6021
+ }else if( strcmp(zTab, "sqlite_stat1")==0 ){
6022
+ appendText(&sQuery,"SELECT tbl,idx,stat FROM sqlite_stat1"
6023
+ " ORDER BY tbl,idx;", 0);
6024
+ }else if( strcmp(zTab, "sqlite_stat3")==0
6025
+ || strcmp(zTab, "sqlite_stat4")==0 ){
6026
+ appendText(&sQuery, "SELECT * FROM ", 0);
6027
+ appendText(&sQuery, zTab, 0);
6028
+ appendText(&sQuery, " ORDER BY tbl, idx, rowid;\n", 0);
6029
+ }
6030
+ appendText(&sSql, zSep, 0);
6031
+ appendText(&sSql, sQuery.z, '\'');
6032
+ sQuery.n = 0;
6033
+ appendText(&sSql, ",", 0);
6034
+ appendText(&sSql, zTab, '\'');
6035
+ zSep = "),(";
6036
+ }
6037
+ sqlite3_finalize(pStmt);
6038
+ if( bSeparate ){
6039
+ zSql = sqlite3_mprintf(
6040
+ "%s))"
6041
+ " SELECT lower(hex(sha3_query(a,%d))) AS hash, b AS label"
6042
+ " FROM [sha3sum$query]",
6043
+ sSql.z, iSize);
6044
+ }else{
6045
+ zSql = sqlite3_mprintf(
6046
+ "%s))"
6047
+ " SELECT lower(hex(sha3_query(group_concat(a,''),%d))) AS hash"
6048
+ " FROM [sha3sum$query]",
6049
+ sSql.z, iSize);
6050
+ }
6051
+ freeText(&sQuery);
6052
+ freeText(&sSql);
6053
+ if( bDebug ){
6054
+ utf8_printf(p->out, "%s\n", zSql);
6055
+ }else{
6056
+ shell_exec(p->db, zSql, shell_callback, p, 0);
6057
+ }
6058
+ sqlite3_free(zSql);
6059
+ }else
48556060
48566061
 if( c=='s'
48576062
 && (strncmp(azArg[0], "shell", n)==0 || strncmp(azArg[0],"system",n)==0)
48586063
 ){
48596064
 char *zCmd;
@@ -4879,11 +6084,12 @@
48796084
 if( nArg!=1 ){
48806085
 raw_printf(stderr, "Usage: .show\n");
48816086
 rc = 1;
48826087
 goto meta_command_exit;
48836088
 }
4884
- utf8_printf(p->out, "%12.12s: %s\n","echo", azBool[p->echoOn!=0]);
6089
+ utf8_printf(p->out, "%12.12s: %s\n","echo",
6090
+ azBool[ShellHasFlag(p, SHFLG_Echo)]);
48856091
 utf8_printf(p->out, "%12.12s: %s\n","eqp", azBool[p->autoEQP&3]);
48866092
 utf8_printf(p->out, "%12.12s: %s\n","explain",
48876093
 p->mode==MODE_Explain ? "on" : p->autoExplain ? "auto" : "off");
48886094
 utf8_printf(p->out,"%12.12s: %s\n","headers", azBool[p->showHeader!=0]);
48896095
 utf8_printf(p->out, "%12.12s: %s\n","mode", modeDescr[p->mode]);
@@ -5444,11 +6650,11 @@
54446650
 static int runOneSqlLine(ShellState *p, char *zSql, FILE *in, int startline){
54456651
 int rc;
54466652
 char *zErrMsg = 0;
54476653
54486654
 open_db(p, 0);
5449
- if( p->backslashOn ) resolve_backslashes(zSql);
6655
+ if( ShellHasFlag(p,SHFLG_Backslash) ) resolve_backslashes(zSql);
54506656
 BEGIN_TIMER;
54516657
 rc = shell_exec(p->db, zSql, shell_callback, p, &zErrMsg);
54526658
 END_TIMER;
54536659
 if( rc || zErrMsg ){
54546660
 char zPrefix[100];
@@ -5464,11 +6670,11 @@
54646670
 zErrMsg = 0;
54656671
 }else{
54666672
 utf8_printf(stderr, "%s %s\n", zPrefix, sqlite3_errmsg(p->db));
54676673
 }
54686674
 return 1;
5469
- }else if( p->countChanges ){
6675
+ }else if( ShellHasFlag(p, SHFLG_CountChanges) ){
54706676
 raw_printf(p->out, "changes: %3d total_changes: %d\n",
54716677
 sqlite3_changes(p->db), sqlite3_total_changes(p->db));
54726678
 }
54736679
 return 0;
54746680
 }
@@ -5507,15 +6713,15 @@
55076713
 if( in!=0 ) break;
55086714
 seenInterrupt = 0;
55096715
 }
55106716
 lineno++;
55116717
 if( nSql==0 && _all_whitespace(zLine) ){
5512
- if( p->echoOn ) printf("%s\n", zLine);
6718
+ if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zLine);
55136719
 continue;
55146720
 }
55156721
 if( zLine && zLine[0]=='.' && nSql==0 ){
5516
- if( p->echoOn ) printf("%s\n", zLine);
6722
+ if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zLine);
55176723
 rc = do_meta_command(zLine, p);
55186724
 if( rc==2 ){ /* exit requested */
55196725
 break;
55206726
 }else if( rc ){
55216727
 errCnt++;
@@ -5554,11 +6760,11 @@
55546760
 if( p->outCount ){
55556761
 output_reset(p);
55566762
 p->outCount = 0;
55576763
 }
55586764
 }else if( nSql && _all_whitespace(zSql) ){
5559
- if( p->echoOn ) printf("%s\n", zSql);
6765
+ if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zSql);
55606766
 nSql = 0;
55616767
 }
55626768
 }
55636769
 if( nSql && !_all_whitespace(zSql) ){
55646770
 runOneSqlLine(p, zSql, in, startline);
@@ -6023,11 +7229,11 @@
60237229
 }else if( strcmp(z,"-header")==0 ){
60247230
 data.showHeader = 1;
60257231
 }else if( strcmp(z,"-noheader")==0 ){
60267232
 data.showHeader = 0;
60277233
 }else if( strcmp(z,"-echo")==0 ){
6028
- data.echoOn = 1;
7234
+ ShellSetFlag(&data, SHFLG_Echo);
60297235
 }else if( strcmp(z,"-eqp")==0 ){
60307236
 data.autoEQP = 1;
60317237
 }else if( strcmp(z,"-eqpfull")==0 ){
60327238
 data.autoEQP = 2;
60337239
 }else if( strcmp(z,"-stats")==0 ){
@@ -6038,11 +7244,11 @@
60387244
 /* Undocumented command-line option: -backslash
60397245
 ** Causes C-style backslash escapes to be evaluated in SQL statements
60407246
 ** prior to sending the SQL into SQLite. Useful for injecting
60417247
 ** crazy bytes in the middle of SQL statements for testing and debugging.
60427248
 */
6043
- data.backslashOn = 1;
7249
+ ShellSetFlag(&data, SHFLG_Backslash);
60447250
 }else if( strcmp(z,"-bail")==0 ){
60457251
 bail_on_error = 1;
60467252
 }else if( strcmp(z,"-version")==0 ){
60477253
 printf("%s %s\n", sqlite3_libversion(), sqlite3_sourceid());
60487254
 return 0;
60497255
--- src/shell.c
+++ src/shell.c
@@ -452,32 +452,10 @@
452 while( IsDigit(*z) ){ z++; }
453 if( realnum ) *realnum = 1;
454 }
455 return *z==0;
456 }
457
458 /*
459 ** A global char* and an SQL function to access its current value
460 ** from within an SQL statement. This program used to use the
461 ** sqlite_exec_printf() API to substitue a string into an SQL statement.
462 ** The correct way to do this with sqlite3 is to use the bind API, but
463 ** since the shell is built around the callback paradigm it would be a lot
464 ** of work. Instead just use this hack, which is quite harmless.
465 */
466 static const char *zShellStatic = 0;
467 static void shellstaticFunc(
468 sqlite3_context *context,
469 int argc,
470 sqlite3_value **argv
471 ){
472 assert( 0==argc );
473 assert( zShellStatic );
474 UNUSED_PARAMETER(argc);
475 UNUSED_PARAMETER(argv);
476 sqlite3_result_text(context, zShellStatic, -1, SQLITE_STATIC);
477 }
478
479
480 /*
481 ** Compute a string length that is limited to what can be stored in
482 ** lower 30 bits of a 32-bit signed integer.
483 */
@@ -575,10 +553,783 @@
575 if( zResult && *zResult ) shell_add_history(zResult);
576 #endif
577 }
578 return zResult;
579 }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
580
581 #if defined(SQLITE_ENABLE_SESSION)
582 /*
583 ** State information for a single open session
584 */
@@ -608,17 +1359,14 @@
608 ** instance of the following structure.
609 */
610 typedef struct ShellState ShellState;
611 struct ShellState {
612 sqlite3 *db; /* The database */
613 int echoOn; /* True to echo input commands */
614 int autoExplain; /* Automatically turn on .explain mode */
615 int autoEQP; /* Run EXPLAIN QUERY PLAN prior to seach SQL stmt */
616 int statsOn; /* True to display memory stats before each finalize */
617 int scanstatsOn; /* True to display scan stats before each finalize */
618 int countChanges; /* True to display change counts */
619 int backslashOn; /* Resolve C-style \x escapes in SQL input text */
620 int outCount; /* Revert to stdout when reaching zero */
621 int cnt; /* Number of records displayed so far */
622 FILE *out; /* Write results here */
623 FILE *traceOut; /* Output for sqlite3_trace() */
624 int nErr; /* Number of errors seen */
@@ -653,13 +1401,24 @@
653 };
654
655 /*
656 ** These are the allowed shellFlgs values
657 */
658 #define SHFLG_Scratch 0x00001 /* The --scratch option is used */
659 #define SHFLG_Pagecache 0x00002 /* The --pagecache option is used */
660 #define SHFLG_Lookaside 0x00004 /* Lookaside memory is used */
 
 
 
 
 
 
 
 
 
 
 
661
662 /*
663 ** These are the allowed modes.
664 */
665 #define MODE_Line 0 /* One column per line. Blank line between records */
@@ -729,36 +1488,56 @@
729 raw_printf(out,"'");
730 }
731
732 /*
733 ** Output the given string as a quoted string using SQL quoting conventions.
 
 
 
734 */
735 static void output_quoted_string(FILE *out, const char *z){
736 int i;
737 int nSingle = 0;
738 setBinaryMode(out, 1);
739 for(i=0; z[i]; i++){
740 if( z[i]=='\'' ) nSingle++;
741 }
742 if( nSingle==0 ){
743 utf8_printf(out,"'%s'",z);
744 }else{
745 raw_printf(out,"'");
 
746 while( *z ){
747 for(i=0; z[i] && z[i]!='\''; i++){}
748 if( i==0 ){
749 raw_printf(out,"''");
750 z++;
751 }else if( z[i]=='\'' ){
752 utf8_printf(out,"%.*s''",i,z);
753 z += i+1;
754 }else{
755 utf8_printf(out,"%s",z);
 
 
 
 
 
 
 
 
 
 
 
 
756 break;
757 }
 
 
 
 
 
 
758 }
759 raw_printf(out,"'");
760 }
761 setTextMode(out, 1);
762 }
763
764 /*
@@ -1246,13 +2025,17 @@
1246 if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){
1247 utf8_printf(p->out,"%sNULL",zSep);
1248 }else if( aiType && aiType[i]==SQLITE_TEXT ){
1249 if( zSep[0] ) utf8_printf(p->out,"%s",zSep);
1250 output_quoted_string(p->out, azArg[i]);
1251 }else if( aiType && (aiType[i]==SQLITE_INTEGER
1252 || aiType[i]==SQLITE_FLOAT) ){
1253 utf8_printf(p->out,"%s%s",zSep, azArg[i]);
 
 
 
 
 
1254 }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){
1255 const void *pBlob = sqlite3_column_blob(p->pStmt, i);
1256 int nBlob = sqlite3_column_bytes(p->pStmt, i);
1257 if( zSep[0] ) utf8_printf(p->out,"%s",zSep);
1258 output_hex_blob(p->out, pBlob, nBlob);
@@ -1292,92 +2075,106 @@
1292 */
1293 static int callback(void *pArg, int nArg, char **azArg, char **azCol){
1294 /* since we don't have type info, call the shell_callback with a NULL value */
1295 return shell_callback(pArg, nArg, azArg, azCol, NULL);
1296 }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1297
1298 /*
1299 ** Set the destination table field of the ShellState structure to
1300 ** the name of the table given. Escape any quote characters in the
1301 ** table name.
1302 */
1303 static void set_table_name(ShellState *p, const char *zName){
1304 int i, n;
1305 int needQuote;
1306 char *z;
1307
1308 if( p->zDestTable ){
1309 free(p->zDestTable);
1310 p->zDestTable = 0;
1311 }
1312 if( zName==0 ) return;
1313 needQuote = !isalpha((unsigned char)*zName) && *zName!='_';
1314 for(i=n=0; zName[i]; i++, n++){
1315 if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ){
1316 needQuote = 1;
1317 if( zName[i]=='\'' ) n++;
1318 }
1319 }
1320 if( needQuote ) n += 2;
1321 z = p->zDestTable = malloc( n+1 );
1322 if( z==0 ){
1323 raw_printf(stderr,"Error: out of memory\n");
1324 exit(1);
1325 }
1326 n = 0;
1327 if( needQuote ) z[n++] = '\'';
1328 for(i=0; zName[i]; i++){
1329 z[n++] = zName[i];
1330 if( zName[i]=='\'' ) z[n++] = '\'';
1331 }
1332 if( needQuote ) z[n++] = '\'';
1333 z[n] = 0;
1334 }
1335
1336 /* zIn is either a pointer to a NULL-terminated string in memory obtained
1337 ** from malloc(), or a NULL pointer. The string pointed to by zAppend is
1338 ** added to zIn, and the result returned in memory obtained from malloc().
1339 ** zIn, if it was not NULL, is freed.
1340 **
1341 ** If the third argument, quote, is not '\0', then it is used as a
1342 ** quote character for zAppend.
1343 */
1344 static char *appendText(char *zIn, char const *zAppend, char quote){
1345 int len;
1346 int i;
1347 int nAppend = strlen30(zAppend);
1348 int nIn = (zIn?strlen30(zIn):0);
1349
1350 len = nAppend+nIn+1;
1351 if( quote ){
1352 len += 2;
1353 for(i=0; i<nAppend; i++){
1354 if( zAppend[i]==quote ) len++;
1355 }
1356 }
1357
1358 zIn = (char *)realloc(zIn, len);
1359 if( !zIn ){
1360 return 0;
1361 }
1362
1363 if( quote ){
1364 char *zCsr = &zIn[nIn];
1365 *zCsr++ = quote;
1366 for(i=0; i<nAppend; i++){
1367 *zCsr++ = zAppend[i];
1368 if( zAppend[i]==quote ) *zCsr++ = quote;
1369 }
1370 *zCsr++ = quote;
1371 *zCsr++ = '\0';
1372 assert( (zCsr-zIn)==len );
1373 }else{
1374 memcpy(&zIn[nIn], zAppend, nAppend);
1375 zIn[len-1] = '\0';
1376 }
1377
1378 return zIn;
1379 }
1380
1381
1382 /*
1383 ** Execute a query statement that will generate SQL output. Print
@@ -1484,10 +2281,35 @@
1484 }
1485 fclose(in);
1486 }
1487 #endif
1488
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1489
1490 /*
1491 ** Display memory stats.
1492 */
1493 static int display_stats(
@@ -1497,61 +2319,35 @@
1497 ){
1498 int iCur;
1499 int iHiwtr;
1500
1501 if( pArg && pArg->out ){
1502
1503 iHiwtr = iCur = -1;
1504 sqlite3_status(SQLITE_STATUS_MEMORY_USED, &iCur, &iHiwtr, bReset);
1505 raw_printf(pArg->out,
1506 "Memory Used: %d (max %d) bytes\n",
1507 iCur, iHiwtr);
1508 iHiwtr = iCur = -1;
1509 sqlite3_status(SQLITE_STATUS_MALLOC_COUNT, &iCur, &iHiwtr, bReset);
1510 raw_printf(pArg->out, "Number of Outstanding Allocations: %d (max %d)\n",
1511 iCur, iHiwtr);
1512 if( pArg->shellFlgs & SHFLG_Pagecache ){
1513 iHiwtr = iCur = -1;
1514 sqlite3_status(SQLITE_STATUS_PAGECACHE_USED, &iCur, &iHiwtr, bReset);
1515 raw_printf(pArg->out,
1516 "Number of Pcache Pages Used: %d (max %d) pages\n",
1517 iCur, iHiwtr);
1518 }
1519 iHiwtr = iCur = -1;
1520 sqlite3_status(SQLITE_STATUS_PAGECACHE_OVERFLOW, &iCur, &iHiwtr, bReset);
1521 raw_printf(pArg->out,
1522 "Number of Pcache Overflow Bytes: %d (max %d) bytes\n",
1523 iCur, iHiwtr);
1524 if( pArg->shellFlgs & SHFLG_Scratch ){
1525 iHiwtr = iCur = -1;
1526 sqlite3_status(SQLITE_STATUS_SCRATCH_USED, &iCur, &iHiwtr, bReset);
1527 raw_printf(pArg->out,
1528 "Number of Scratch Allocations Used: %d (max %d)\n",
1529 iCur, iHiwtr);
1530 }
1531 iHiwtr = iCur = -1;
1532 sqlite3_status(SQLITE_STATUS_SCRATCH_OVERFLOW, &iCur, &iHiwtr, bReset);
1533 raw_printf(pArg->out,
1534 "Number of Scratch Overflow Bytes: %d (max %d) bytes\n",
1535 iCur, iHiwtr);
1536 iHiwtr = iCur = -1;
1537 sqlite3_status(SQLITE_STATUS_MALLOC_SIZE, &iCur, &iHiwtr, bReset);
1538 raw_printf(pArg->out, "Largest Allocation: %d bytes\n",
1539 iHiwtr);
1540 iHiwtr = iCur = -1;
1541 sqlite3_status(SQLITE_STATUS_PAGECACHE_SIZE, &iCur, &iHiwtr, bReset);
1542 raw_printf(pArg->out, "Largest Pcache Allocation: %d bytes\n",
1543 iHiwtr);
1544 iHiwtr = iCur = -1;
1545 sqlite3_status(SQLITE_STATUS_SCRATCH_SIZE, &iCur, &iHiwtr, bReset);
1546 raw_printf(pArg->out, "Largest Scratch Allocation: %d bytes\n",
1547 iHiwtr);
1548 #ifdef YYTRACKMAXSTACKDEPTH
1549 iHiwtr = iCur = -1;
1550 sqlite3_status(SQLITE_STATUS_PARSER_STACK, &iCur, &iHiwtr, bReset);
1551 raw_printf(pArg->out, "Deepest Parser Stack: %d (max %d)\n",
1552 iCur, iHiwtr);
1553 #endif
1554 }
1555
1556 if( pArg && pArg->out && db ){
1557 if( pArg->shellFlgs & SHFLG_Lookaside ){
@@ -1934,11 +2730,11 @@
1934 pArg->pStmt = pStmt;
1935 pArg->cnt = 0;
1936 }
1937
1938 /* echo the sql statement if echo on */
1939 if( pArg && pArg->echoOn ){
1940 utf8_printf(pArg->out, "%s\n", zStmtSql ? zStmtSql : zSql);
1941 }
1942
1943 /* Show the EXPLAIN QUERY PLAN if .eqp is on */
1944 if( pArg && pArg->autoEQP && sqlite3_strlike("EXPLAIN%",zStmtSql,0)!=0 ){
@@ -2022,10 +2818,142 @@
2022 } /* end while */
2023
2024 return rc;
2025 }
2026
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2027
2028 /*
2029 ** This is a different callback routine used for dumping the database.
2030 ** Each row received by this callback consists of a table name,
2031 ** the table type ("index" or "table") and SQL to create the table.
@@ -2034,21 +2962,20 @@
2034 static int dump_callback(void *pArg, int nArg, char **azArg, char **azCol){
2035 int rc;
2036 const char *zTable;
2037 const char *zType;
2038 const char *zSql;
2039 const char *zPrepStmt = 0;
2040 ShellState *p = (ShellState *)pArg;
2041
2042 UNUSED_PARAMETER(azCol);
2043 if( nArg!=3 ) return 1;
2044 zTable = azArg[0];
2045 zType = azArg[1];
2046 zSql = azArg[2];
2047
2048 if( strcmp(zTable, "sqlite_sequence")==0 ){
2049 zPrepStmt = "DELETE FROM sqlite_sequence;\n";
2050 }else if( sqlite3_strglob("sqlite_stat?", zTable)==0 ){
2051 raw_printf(p->out, "ANALYZE sqlite_master;\n");
2052 }else if( strncmp(zTable, "sqlite_", 7)==0 ){
2053 return 0;
2054 }else if( strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){
@@ -2067,62 +2994,74 @@
2067 }else{
2068 printSchemaLine(p->out, zSql, ";\n");
2069 }
2070
2071 if( strcmp(zType, "table")==0 ){
2072 sqlite3_stmt *pTableInfo = 0;
2073 char *zSelect = 0;
2074 char *zTableInfo = 0;
2075 char *zTmp = 0;
2076 int nRow = 0;
2077
2078 zTableInfo = appendText(zTableInfo, "PRAGMA table_info(", 0);
2079 zTableInfo = appendText(zTableInfo, zTable, '"');
2080 zTableInfo = appendText(zTableInfo, ");", 0);
2081
2082 rc = sqlite3_prepare_v2(p->db, zTableInfo, -1, &pTableInfo, 0);
2083 free(zTableInfo);
2084 if( rc!=SQLITE_OK || !pTableInfo ){
2085 return 1;
2086 }
2087
2088 zSelect = appendText(zSelect, "SELECT 'INSERT INTO ' || ", 0);
2089 /* Always quote the table name, even if it appears to be pure ascii,
2090 ** in case it is a keyword. Ex: INSERT INTO "table" ... */
2091 zTmp = appendText(zTmp, zTable, '"');
2092 if( zTmp ){
2093 zSelect = appendText(zSelect, zTmp, '\'');
2094 free(zTmp);
2095 }
2096 zSelect = appendText(zSelect, " || ' VALUES(' || ", 0);
2097 rc = sqlite3_step(pTableInfo);
2098 while( rc==SQLITE_ROW ){
2099 const char *zText = (const char *)sqlite3_column_text(pTableInfo, 1);
2100 zSelect = appendText(zSelect, "quote(", 0);
2101 zSelect = appendText(zSelect, zText, '"');
2102 rc = sqlite3_step(pTableInfo);
2103 if( rc==SQLITE_ROW ){
2104 zSelect = appendText(zSelect, "), ", 0);
2105 }else{
2106 zSelect = appendText(zSelect, ") ", 0);
2107 }
2108 nRow++;
2109 }
2110 rc = sqlite3_finalize(pTableInfo);
2111 if( rc!=SQLITE_OK || nRow==0 ){
2112 free(zSelect);
2113 return 1;
2114 }
2115 zSelect = appendText(zSelect, "|| ')' FROM ", 0);
2116 zSelect = appendText(zSelect, zTable, '"');
2117
2118 rc = run_table_dump_query(p, zSelect, zPrepStmt);
2119 if( rc==SQLITE_CORRUPT ){
2120 zSelect = appendText(zSelect, " ORDER BY rowid DESC", 0);
2121 run_table_dump_query(p, zSelect, 0);
2122 }
2123 free(zSelect);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2124 }
2125 return 0;
2126 }
2127
2128 /*
@@ -2228,15 +3167,17 @@
2228 ".restore ?DB? FILE Restore content of DB (default \"main\") from FILE\n"
2229 ".save FILE Write in-memory database into FILE\n"
2230 ".scanstats on|off Turn sqlite3_stmt_scanstatus() metrics on or off\n"
2231 ".schema ?PATTERN? Show the CREATE statements matching PATTERN\n"
2232 " Add --indent for pretty-printing\n"
 
2233 ".separator COL ?ROW? Change the column separator and optionally the row\n"
2234 " separator for both the output mode and .import\n"
2235 #if defined(SQLITE_ENABLE_SESSION)
2236 ".session CMD ... Create or control sessions\n"
2237 #endif
 
2238 ".shell CMD ARGS... Run CMD ARGS... in a system shell\n"
2239 ".show Show the current values for various settings\n"
2240 ".stats ?on|off? Show stats or turn stats on or off\n"
2241 ".system CMD ARGS... Run CMD ARGS... in a system shell\n"
2242 ".tables ?TABLE? List names of tables\n"
@@ -2423,14 +3364,10 @@
2423 static void open_db(ShellState *p, int keepAlive){
2424 if( p->db==0 ){
2425 sqlite3_initialize();
2426 sqlite3_open(p->zDbFilename, &p->db);
2427 globalDb = p->db;
2428 if( p->db && sqlite3_errcode(p->db)==SQLITE_OK ){
2429 sqlite3_create_function(p->db, "shellstatic", 0, SQLITE_UTF8, 0,
2430 shellstaticFunc, 0, 0);
2431 }
2432 if( p->db==0 || SQLITE_OK!=sqlite3_errcode(p->db) ){
2433 utf8_printf(stderr,"Error: unable to open database \"%s\": %s\n",
2434 p->zDbFilename, sqlite3_errmsg(p->db));
2435 if( keepAlive ) return;
2436 exit(1);
@@ -2440,10 +3377,18 @@
2440 #endif
2441 sqlite3_create_function(p->db, "readfile", 1, SQLITE_UTF8, 0,
2442 readfileFunc, 0, 0);
2443 sqlite3_create_function(p->db, "writefile", 2, SQLITE_UTF8, 0,
2444 writefileFunc, 0, 0);
 
 
 
 
 
 
 
 
2445 }
2446 }
2447
2448 /*
2449 ** Do C-language style dequoting.
@@ -2564,11 +3509,11 @@
2564
2565 /*
2566 ** Interpret zArg as either an integer or a boolean value. Return 1 or 0
2567 ** for TRUE and FALSE. Return the integer value if appropriate.
2568 */
2569 static int booleanValue(char *zArg){
2570 int i;
2571 if( zArg[0]=='0' && zArg[1]=='x' ){
2572 for(i=2; hexDigitValue(zArg[i])>=0; i++){}
2573 }else{
2574 for(i=0; zArg[i]>='0' && zArg[i]<='9'; i++){}
@@ -2582,10 +3527,21 @@
2582 }
2583 utf8_printf(stderr, "ERROR: Not a boolean value: \"%s\". Assuming \"no\".\n",
2584 zArg);
2585 return 0;
2586 }
 
 
 
 
 
 
 
 
 
 
 
2587
2588 /*
2589 ** Close an output file, assuming it is not stderr or stdout
2590 */
2591 static void output_file_close(FILE *f){
@@ -3656,11 +4612,11 @@
3656 test_breakpoint();
3657 }else
3658
3659 if( c=='c' && n>=3 && strncmp(azArg[0], "changes", n)==0 ){
3660 if( nArg==2 ){
3661 p->countChanges = booleanValue(azArg[1]);
3662 }else{
3663 raw_printf(stderr, "Usage: .changes on|off\n");
3664 rc = 1;
3665 }
3666 }else
@@ -3720,25 +4676,46 @@
3720 if( c=='d' && strncmp(azArg[0], "dbinfo", n)==0 ){
3721 rc = shell_dbinfo_command(p, nArg, azArg);
3722 }else
3723
3724 if( c=='d' && strncmp(azArg[0], "dump", n)==0 ){
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3725 open_db(p, 0);
3726 /* When playing back a "dump", the content might appear in an order
3727 ** which causes immediate foreign key constraints to be violated.
3728 ** So disable foreign-key constraint enforcement to prevent problems. */
3729 if( nArg!=1 && nArg!=2 ){
3730 raw_printf(stderr, "Usage: .dump ?LIKE-PATTERN?\n");
3731 rc = 1;
3732 goto meta_command_exit;
3733 }
3734 raw_printf(p->out, "PRAGMA foreign_keys=OFF;\n");
3735 raw_printf(p->out, "BEGIN TRANSACTION;\n");
3736 p->writableSchema = 0;
 
 
 
3737 sqlite3_exec(p->db, "SAVEPOINT dump; PRAGMA writable_schema=ON", 0, 0, 0);
3738 p->nErr = 0;
3739 if( nArg==1 ){
3740 run_schema_dump_query(p,
3741 "SELECT name, type, sql FROM sqlite_master "
3742 "WHERE sql NOT NULL AND type=='table' AND name!='sqlite_sequence'"
3743 );
3744 run_schema_dump_query(p,
@@ -3748,25 +4725,24 @@
3748 run_table_dump_query(p,
3749 "SELECT sql FROM sqlite_master "
3750 "WHERE sql NOT NULL AND type IN ('index','trigger','view')", 0
3751 );
3752 }else{
3753 int i;
3754 for(i=1; i<nArg; i++){
3755 zShellStatic = azArg[i];
3756 run_schema_dump_query(p,
3757 "SELECT name, type, sql FROM sqlite_master "
3758 "WHERE tbl_name LIKE shellstatic() AND type=='table'"
3759 " AND sql NOT NULL");
3760 run_table_dump_query(p,
3761 "SELECT sql FROM sqlite_master "
3762 "WHERE sql NOT NULL"
3763 " AND type IN ('index','trigger','view')"
3764 " AND tbl_name LIKE shellstatic()", 0
3765 );
3766 zShellStatic = 0;
3767 }
3768 }
3769 if( p->writableSchema ){
3770 raw_printf(p->out, "PRAGMA writable_schema=OFF;\n");
3771 p->writableSchema = 0;
3772 }
@@ -3775,11 +4751,11 @@
3775 raw_printf(p->out, p->nErr ? "ROLLBACK; -- due to errors\n" : "COMMIT;\n");
3776 }else
3777
3778 if( c=='e' && strncmp(azArg[0], "echo", n)==0 ){
3779 if( nArg==2 ){
3780 p->echoOn = booleanValue(azArg[1]);
3781 }else{
3782 raw_printf(stderr, "Usage: .echo on|off\n");
3783 rc = 1;
3784 }
3785 }else
@@ -4572,21 +5548,21 @@
4572 new_colv[0] = "sql";
4573 new_colv[1] = 0;
4574 callback(&data, 1, new_argv, new_colv);
4575 rc = SQLITE_OK;
4576 }else{
4577 zShellStatic = azArg[1];
4578 rc = sqlite3_exec(p->db,
4579 "SELECT sql FROM "
4580 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
4581 " FROM sqlite_master UNION ALL"
4582 " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
4583 "WHERE lower(tbl_name) LIKE shellstatic()"
4584 " AND type!='meta' AND sql NOTNULL "
4585 "ORDER BY rowid",
4586 callback, &data, &zErrMsg);
4587 zShellStatic = 0;
4588 }
4589 }else if( nArg==1 ){
4590 rc = sqlite3_exec(p->db,
4591 "SELECT sql FROM "
4592 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
@@ -4835,10 +5811,123 @@
4835 utf8_printf(p->out, "%s", zBuf);
4836 }
4837 }
4838 }else
4839 #endif
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4840
4841 if( c=='s' && strncmp(azArg[0], "separator", n)==0 ){
4842 if( nArg<2 || nArg>3 ){
4843 raw_printf(stderr, "Usage: .separator COL ?ROW?\n");
4844 rc = 1;
@@ -4850,10 +5939,126 @@
4850 if( nArg>=3 ){
4851 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator,
4852 "%.*s", (int)ArraySize(p->rowSeparator)-1, azArg[2]);
4853 }
4854 }else
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4855
4856 if( c=='s'
4857 && (strncmp(azArg[0], "shell", n)==0 || strncmp(azArg[0],"system",n)==0)
4858 ){
4859 char *zCmd;
@@ -4879,11 +6084,12 @@
4879 if( nArg!=1 ){
4880 raw_printf(stderr, "Usage: .show\n");
4881 rc = 1;
4882 goto meta_command_exit;
4883 }
4884 utf8_printf(p->out, "%12.12s: %s\n","echo", azBool[p->echoOn!=0]);
 
4885 utf8_printf(p->out, "%12.12s: %s\n","eqp", azBool[p->autoEQP&3]);
4886 utf8_printf(p->out, "%12.12s: %s\n","explain",
4887 p->mode==MODE_Explain ? "on" : p->autoExplain ? "auto" : "off");
4888 utf8_printf(p->out,"%12.12s: %s\n","headers", azBool[p->showHeader!=0]);
4889 utf8_printf(p->out, "%12.12s: %s\n","mode", modeDescr[p->mode]);
@@ -5444,11 +6650,11 @@
5444 static int runOneSqlLine(ShellState *p, char *zSql, FILE *in, int startline){
5445 int rc;
5446 char *zErrMsg = 0;
5447
5448 open_db(p, 0);
5449 if( p->backslashOn ) resolve_backslashes(zSql);
5450 BEGIN_TIMER;
5451 rc = shell_exec(p->db, zSql, shell_callback, p, &zErrMsg);
5452 END_TIMER;
5453 if( rc || zErrMsg ){
5454 char zPrefix[100];
@@ -5464,11 +6670,11 @@
5464 zErrMsg = 0;
5465 }else{
5466 utf8_printf(stderr, "%s %s\n", zPrefix, sqlite3_errmsg(p->db));
5467 }
5468 return 1;
5469 }else if( p->countChanges ){
5470 raw_printf(p->out, "changes: %3d total_changes: %d\n",
5471 sqlite3_changes(p->db), sqlite3_total_changes(p->db));
5472 }
5473 return 0;
5474 }
@@ -5507,15 +6713,15 @@
5507 if( in!=0 ) break;
5508 seenInterrupt = 0;
5509 }
5510 lineno++;
5511 if( nSql==0 && _all_whitespace(zLine) ){
5512 if( p->echoOn ) printf("%s\n", zLine);
5513 continue;
5514 }
5515 if( zLine && zLine[0]=='.' && nSql==0 ){
5516 if( p->echoOn ) printf("%s\n", zLine);
5517 rc = do_meta_command(zLine, p);
5518 if( rc==2 ){ /* exit requested */
5519 break;
5520 }else if( rc ){
5521 errCnt++;
@@ -5554,11 +6760,11 @@
5554 if( p->outCount ){
5555 output_reset(p);
5556 p->outCount = 0;
5557 }
5558 }else if( nSql && _all_whitespace(zSql) ){
5559 if( p->echoOn ) printf("%s\n", zSql);
5560 nSql = 0;
5561 }
5562 }
5563 if( nSql && !_all_whitespace(zSql) ){
5564 runOneSqlLine(p, zSql, in, startline);
@@ -6023,11 +7229,11 @@
6023 }else if( strcmp(z,"-header")==0 ){
6024 data.showHeader = 1;
6025 }else if( strcmp(z,"-noheader")==0 ){
6026 data.showHeader = 0;
6027 }else if( strcmp(z,"-echo")==0 ){
6028 data.echoOn = 1;
6029 }else if( strcmp(z,"-eqp")==0 ){
6030 data.autoEQP = 1;
6031 }else if( strcmp(z,"-eqpfull")==0 ){
6032 data.autoEQP = 2;
6033 }else if( strcmp(z,"-stats")==0 ){
@@ -6038,11 +7244,11 @@
6038 /* Undocumented command-line option: -backslash
6039 ** Causes C-style backslash escapes to be evaluated in SQL statements
6040 ** prior to sending the SQL into SQLite. Useful for injecting
6041 ** crazy bytes in the middle of SQL statements for testing and debugging.
6042 */
6043 data.backslashOn = 1;
6044 }else if( strcmp(z,"-bail")==0 ){
6045 bail_on_error = 1;
6046 }else if( strcmp(z,"-version")==0 ){
6047 printf("%s %s\n", sqlite3_libversion(), sqlite3_sourceid());
6048 return 0;
6049
--- src/shell.c
+++ src/shell.c
@@ -452,32 +452,10 @@
452 while( IsDigit(*z) ){ z++; }
453 if( realnum ) *realnum = 1;
454 }
455 return *z==0;
456 }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
457
458 /*
459 ** Compute a string length that is limited to what can be stored in
460 ** lower 30 bits of a 32-bit signed integer.
461 */
@@ -575,10 +553,783 @@
553 if( zResult && *zResult ) shell_add_history(zResult);
554 #endif
555 }
556 return zResult;
557 }
558 /*
559 ** A variable length string to which one can append text.
560 */
561 typedef struct ShellText ShellText;
562 struct ShellText {
563 char *z;
564 int n;
565 int nAlloc;
566 };
567
568 /*
569 ** Initialize and destroy a ShellText object
570 */
571 static void initText(ShellText *p){
572 memset(p, 0, sizeof(*p));
573 }
574 static void freeText(ShellText *p){
575 free(p->z);
576 initText(p);
577 }
578
579 /* zIn is either a pointer to a NULL-terminated string in memory obtained
580 ** from malloc(), or a NULL pointer. The string pointed to by zAppend is
581 ** added to zIn, and the result returned in memory obtained from malloc().
582 ** zIn, if it was not NULL, is freed.
583 **
584 ** If the third argument, quote, is not '\0', then it is used as a
585 ** quote character for zAppend.
586 */
587 static void appendText(ShellText *p, char const *zAppend, char quote){
588 int len;
589 int i;
590 int nAppend = strlen30(zAppend);
591
592 len = nAppend+p->n+1;
593 if( quote ){
594 len += 2;
595 for(i=0; i<nAppend; i++){
596 if( zAppend[i]==quote ) len++;
597 }
598 }
599
600 if( p->n+len>=p->nAlloc ){
601 p->nAlloc = p->nAlloc*2 + len + 20;
602 p->z = realloc(p->z, p->nAlloc);
603 if( p->z==0 ){
604 memset(p, 0, sizeof(*p));
605 return;
606 }
607 }
608
609 if( quote ){
610 char *zCsr = p->z+p->n;
611 *zCsr++ = quote;
612 for(i=0; i<nAppend; i++){
613 *zCsr++ = zAppend[i];
614 if( zAppend[i]==quote ) *zCsr++ = quote;
615 }
616 *zCsr++ = quote;
617 p->n = (int)(zCsr - p->z);
618 *zCsr = '\0';
619 }else{
620 memcpy(p->z+p->n, zAppend, nAppend);
621 p->n += nAppend;
622 p->z[p->n] = '\0';
623 }
624 }
625
626 /*
627 ** Attempt to determine if identifier zName needs to be quoted, either
628 ** because it contains non-alphanumeric characters, or because it is an
629 ** SQLite keyword. Be conservative in this estimate: When in doubt assume
630 ** that quoting is required.
631 **
632 ** Return '"' if quoting is required. Return 0 if no quoting is required.
633 */
634 static char quoteChar(const char *zName){
635 /* All SQLite keywords, in alphabetical order */
636 static const char *azKeywords[] = {
637 "ABORT", "ACTION", "ADD", "AFTER", "ALL", "ALTER", "ANALYZE", "AND", "AS",
638 "ASC", "ATTACH", "AUTOINCREMENT", "BEFORE", "BEGIN", "BETWEEN", "BY",
639 "CASCADE", "CASE", "CAST", "CHECK", "COLLATE", "COLUMN", "COMMIT",
640 "CONFLICT", "CONSTRAINT", "CREATE", "CROSS", "CURRENT_DATE",
641 "CURRENT_TIME", "CURRENT_TIMESTAMP", "DATABASE", "DEFAULT", "DEFERRABLE",
642 "DEFERRED", "DELETE", "DESC", "DETACH", "DISTINCT", "DROP", "EACH",
643 "ELSE", "END", "ESCAPE", "EXCEPT", "EXCLUSIVE", "EXISTS", "EXPLAIN",
644 "FAIL", "FOR", "FOREIGN", "FROM", "FULL", "GLOB", "GROUP", "HAVING", "IF",
645 "IGNORE", "IMMEDIATE", "IN", "INDEX", "INDEXED", "INITIALLY", "INNER",
646 "INSERT", "INSTEAD", "INTERSECT", "INTO", "IS", "ISNULL", "JOIN", "KEY",
647 "LEFT", "LIKE", "LIMIT", "MATCH", "NATURAL", "NO", "NOT", "NOTNULL",
648 "NULL", "OF", "OFFSET", "ON", "OR", "ORDER", "OUTER", "PLAN", "PRAGMA",
649 "PRIMARY", "QUERY", "RAISE", "RECURSIVE", "REFERENCES", "REGEXP",
650 "REINDEX", "RELEASE", "RENAME", "REPLACE", "RESTRICT", "RIGHT",
651 "ROLLBACK", "ROW", "SAVEPOINT", "SELECT", "SET", "TABLE", "TEMP",
652 "TEMPORARY", "THEN", "TO", "TRANSACTION", "TRIGGER", "UNION", "UNIQUE",
653 "UPDATE", "USING", "VACUUM", "VALUES", "VIEW", "VIRTUAL", "WHEN", "WHERE",
654 "WITH", "WITHOUT",
655 };
656 int i, lwr, upr, mid, c;
657 if( !isalpha((unsigned char)zName[0]) && zName[0]!='_' ) return '"';
658 for(i=0; zName[i]; i++){
659 if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ) return '"';
660 }
661 lwr = 0;
662 upr = sizeof(azKeywords)/sizeof(azKeywords[0]) - 1;
663 while( lwr<=upr ){
664 mid = (lwr+upr)/2;
665 c = sqlite3_stricmp(azKeywords[mid], zName);
666 if( c==0 ) return '"';
667 if( c<0 ){
668 lwr = mid+1;
669 }else{
670 upr = mid-1;
671 }
672 }
673 return 0;
674 }
675
676 /******************************************************************************
677 ** SHA3 hash implementation copied from ../ext/misc/shathree.c
678 */
679 typedef sqlite3_uint64 u64;
680 /*
681 ** Macros to determine whether the machine is big or little endian,
682 ** and whether or not that determination is run-time or compile-time.
683 **
684 ** For best performance, an attempt is made to guess at the byte-order
685 ** using C-preprocessor macros. If that is unsuccessful, or if
686 ** -DSHA3_BYTEORDER=0 is set, then byte-order is determined
687 ** at run-time.
688 */
689 #ifndef SHA3_BYTEORDER
690 # if defined(i386) || defined(__i386__) || defined(_M_IX86) || \
691 defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) || \
692 defined(_M_AMD64) || defined(_M_ARM) || defined(__x86) || \
693 defined(__arm__)
694 # define SHA3_BYTEORDER 1234
695 # elif defined(sparc) || defined(__ppc__)
696 # define SHA3_BYTEORDER 4321
697 # else
698 # define SHA3_BYTEORDER 0
699 # endif
700 #endif
701
702
703 /*
704 ** State structure for a SHA3 hash in progress
705 */
706 typedef struct SHA3Context SHA3Context;
707 struct SHA3Context {
708 union {
709 u64 s[25]; /* Keccak state. 5x5 lines of 64 bits each */
710 unsigned char x[1600]; /* ... or 1600 bytes */
711 } u;
712 unsigned nRate; /* Bytes of input accepted per Keccak iteration */
713 unsigned nLoaded; /* Input bytes loaded into u.x[] so far this cycle */
714 unsigned ixMask; /* Insert next input into u.x[nLoaded^ixMask]. */
715 };
716
717 /*
718 ** A single step of the Keccak mixing function for a 1600-bit state
719 */
720 static void KeccakF1600Step(SHA3Context *p){
721 int i;
722 u64 B0, B1, B2, B3, B4;
723 u64 C0, C1, C2, C3, C4;
724 u64 D0, D1, D2, D3, D4;
725 static const u64 RC[] = {
726 0x0000000000000001ULL, 0x0000000000008082ULL,
727 0x800000000000808aULL, 0x8000000080008000ULL,
728 0x000000000000808bULL, 0x0000000080000001ULL,
729 0x8000000080008081ULL, 0x8000000000008009ULL,
730 0x000000000000008aULL, 0x0000000000000088ULL,
731 0x0000000080008009ULL, 0x000000008000000aULL,
732 0x000000008000808bULL, 0x800000000000008bULL,
733 0x8000000000008089ULL, 0x8000000000008003ULL,
734 0x8000000000008002ULL, 0x8000000000000080ULL,
735 0x000000000000800aULL, 0x800000008000000aULL,
736 0x8000000080008081ULL, 0x8000000000008080ULL,
737 0x0000000080000001ULL, 0x8000000080008008ULL
738 };
739 # define A00 (p->u.s[0])
740 # define A01 (p->u.s[1])
741 # define A02 (p->u.s[2])
742 # define A03 (p->u.s[3])
743 # define A04 (p->u.s[4])
744 # define A10 (p->u.s[5])
745 # define A11 (p->u.s[6])
746 # define A12 (p->u.s[7])
747 # define A13 (p->u.s[8])
748 # define A14 (p->u.s[9])
749 # define A20 (p->u.s[10])
750 # define A21 (p->u.s[11])
751 # define A22 (p->u.s[12])
752 # define A23 (p->u.s[13])
753 # define A24 (p->u.s[14])
754 # define A30 (p->u.s[15])
755 # define A31 (p->u.s[16])
756 # define A32 (p->u.s[17])
757 # define A33 (p->u.s[18])
758 # define A34 (p->u.s[19])
759 # define A40 (p->u.s[20])
760 # define A41 (p->u.s[21])
761 # define A42 (p->u.s[22])
762 # define A43 (p->u.s[23])
763 # define A44 (p->u.s[24])
764 # define ROL64(a,x) ((a<<x)|(a>>(64-x)))
765
766 for(i=0; i<24; i+=4){
767 C0 = A00^A10^A20^A30^A40;
768 C1 = A01^A11^A21^A31^A41;
769 C2 = A02^A12^A22^A32^A42;
770 C3 = A03^A13^A23^A33^A43;
771 C4 = A04^A14^A24^A34^A44;
772 D0 = C4^ROL64(C1, 1);
773 D1 = C0^ROL64(C2, 1);
774 D2 = C1^ROL64(C3, 1);
775 D3 = C2^ROL64(C4, 1);
776 D4 = C3^ROL64(C0, 1);
777
778 B0 = (A00^D0);
779 B1 = ROL64((A11^D1), 44);
780 B2 = ROL64((A22^D2), 43);
781 B3 = ROL64((A33^D3), 21);
782 B4 = ROL64((A44^D4), 14);
783 A00 = B0 ^((~B1)& B2 );
784 A00 ^= RC[i];
785 A11 = B1 ^((~B2)& B3 );
786 A22 = B2 ^((~B3)& B4 );
787 A33 = B3 ^((~B4)& B0 );
788 A44 = B4 ^((~B0)& B1 );
789
790 B2 = ROL64((A20^D0), 3);
791 B3 = ROL64((A31^D1), 45);
792 B4 = ROL64((A42^D2), 61);
793 B0 = ROL64((A03^D3), 28);
794 B1 = ROL64((A14^D4), 20);
795 A20 = B0 ^((~B1)& B2 );
796 A31 = B1 ^((~B2)& B3 );
797 A42 = B2 ^((~B3)& B4 );
798 A03 = B3 ^((~B4)& B0 );
799 A14 = B4 ^((~B0)& B1 );
800
801 B4 = ROL64((A40^D0), 18);
802 B0 = ROL64((A01^D1), 1);
803 B1 = ROL64((A12^D2), 6);
804 B2 = ROL64((A23^D3), 25);
805 B3 = ROL64((A34^D4), 8);
806 A40 = B0 ^((~B1)& B2 );
807 A01 = B1 ^((~B2)& B3 );
808 A12 = B2 ^((~B3)& B4 );
809 A23 = B3 ^((~B4)& B0 );
810 A34 = B4 ^((~B0)& B1 );
811
812 B1 = ROL64((A10^D0), 36);
813 B2 = ROL64((A21^D1), 10);
814 B3 = ROL64((A32^D2), 15);
815 B4 = ROL64((A43^D3), 56);
816 B0 = ROL64((A04^D4), 27);
817 A10 = B0 ^((~B1)& B2 );
818 A21 = B1 ^((~B2)& B3 );
819 A32 = B2 ^((~B3)& B4 );
820 A43 = B3 ^((~B4)& B0 );
821 A04 = B4 ^((~B0)& B1 );
822
823 B3 = ROL64((A30^D0), 41);
824 B4 = ROL64((A41^D1), 2);
825 B0 = ROL64((A02^D2), 62);
826 B1 = ROL64((A13^D3), 55);
827 B2 = ROL64((A24^D4), 39);
828 A30 = B0 ^((~B1)& B2 );
829 A41 = B1 ^((~B2)& B3 );
830 A02 = B2 ^((~B3)& B4 );
831 A13 = B3 ^((~B4)& B0 );
832 A24 = B4 ^((~B0)& B1 );
833
834 C0 = A00^A20^A40^A10^A30;
835 C1 = A11^A31^A01^A21^A41;
836 C2 = A22^A42^A12^A32^A02;
837 C3 = A33^A03^A23^A43^A13;
838 C4 = A44^A14^A34^A04^A24;
839 D0 = C4^ROL64(C1, 1);
840 D1 = C0^ROL64(C2, 1);
841 D2 = C1^ROL64(C3, 1);
842 D3 = C2^ROL64(C4, 1);
843 D4 = C3^ROL64(C0, 1);
844
845 B0 = (A00^D0);
846 B1 = ROL64((A31^D1), 44);
847 B2 = ROL64((A12^D2), 43);
848 B3 = ROL64((A43^D3), 21);
849 B4 = ROL64((A24^D4), 14);
850 A00 = B0 ^((~B1)& B2 );
851 A00 ^= RC[i+1];
852 A31 = B1 ^((~B2)& B3 );
853 A12 = B2 ^((~B3)& B4 );
854 A43 = B3 ^((~B4)& B0 );
855 A24 = B4 ^((~B0)& B1 );
856
857 B2 = ROL64((A40^D0), 3);
858 B3 = ROL64((A21^D1), 45);
859 B4 = ROL64((A02^D2), 61);
860 B0 = ROL64((A33^D3), 28);
861 B1 = ROL64((A14^D4), 20);
862 A40 = B0 ^((~B1)& B2 );
863 A21 = B1 ^((~B2)& B3 );
864 A02 = B2 ^((~B3)& B4 );
865 A33 = B3 ^((~B4)& B0 );
866 A14 = B4 ^((~B0)& B1 );
867
868 B4 = ROL64((A30^D0), 18);
869 B0 = ROL64((A11^D1), 1);
870 B1 = ROL64((A42^D2), 6);
871 B2 = ROL64((A23^D3), 25);
872 B3 = ROL64((A04^D4), 8);
873 A30 = B0 ^((~B1)& B2 );
874 A11 = B1 ^((~B2)& B3 );
875 A42 = B2 ^((~B3)& B4 );
876 A23 = B3 ^((~B4)& B0 );
877 A04 = B4 ^((~B0)& B1 );
878
879 B1 = ROL64((A20^D0), 36);
880 B2 = ROL64((A01^D1), 10);
881 B3 = ROL64((A32^D2), 15);
882 B4 = ROL64((A13^D3), 56);
883 B0 = ROL64((A44^D4), 27);
884 A20 = B0 ^((~B1)& B2 );
885 A01 = B1 ^((~B2)& B3 );
886 A32 = B2 ^((~B3)& B4 );
887 A13 = B3 ^((~B4)& B0 );
888 A44 = B4 ^((~B0)& B1 );
889
890 B3 = ROL64((A10^D0), 41);
891 B4 = ROL64((A41^D1), 2);
892 B0 = ROL64((A22^D2), 62);
893 B1 = ROL64((A03^D3), 55);
894 B2 = ROL64((A34^D4), 39);
895 A10 = B0 ^((~B1)& B2 );
896 A41 = B1 ^((~B2)& B3 );
897 A22 = B2 ^((~B3)& B4 );
898 A03 = B3 ^((~B4)& B0 );
899 A34 = B4 ^((~B0)& B1 );
900
901 C0 = A00^A40^A30^A20^A10;
902 C1 = A31^A21^A11^A01^A41;
903 C2 = A12^A02^A42^A32^A22;
904 C3 = A43^A33^A23^A13^A03;
905 C4 = A24^A14^A04^A44^A34;
906 D0 = C4^ROL64(C1, 1);
907 D1 = C0^ROL64(C2, 1);
908 D2 = C1^ROL64(C3, 1);
909 D3 = C2^ROL64(C4, 1);
910 D4 = C3^ROL64(C0, 1);
911
912 B0 = (A00^D0);
913 B1 = ROL64((A21^D1), 44);
914 B2 = ROL64((A42^D2), 43);
915 B3 = ROL64((A13^D3), 21);
916 B4 = ROL64((A34^D4), 14);
917 A00 = B0 ^((~B1)& B2 );
918 A00 ^= RC[i+2];
919 A21 = B1 ^((~B2)& B3 );
920 A42 = B2 ^((~B3)& B4 );
921 A13 = B3 ^((~B4)& B0 );
922 A34 = B4 ^((~B0)& B1 );
923
924 B2 = ROL64((A30^D0), 3);
925 B3 = ROL64((A01^D1), 45);
926 B4 = ROL64((A22^D2), 61);
927 B0 = ROL64((A43^D3), 28);
928 B1 = ROL64((A14^D4), 20);
929 A30 = B0 ^((~B1)& B2 );
930 A01 = B1 ^((~B2)& B3 );
931 A22 = B2 ^((~B3)& B4 );
932 A43 = B3 ^((~B4)& B0 );
933 A14 = B4 ^((~B0)& B1 );
934
935 B4 = ROL64((A10^D0), 18);
936 B0 = ROL64((A31^D1), 1);
937 B1 = ROL64((A02^D2), 6);
938 B2 = ROL64((A23^D3), 25);
939 B3 = ROL64((A44^D4), 8);
940 A10 = B0 ^((~B1)& B2 );
941 A31 = B1 ^((~B2)& B3 );
942 A02 = B2 ^((~B3)& B4 );
943 A23 = B3 ^((~B4)& B0 );
944 A44 = B4 ^((~B0)& B1 );
945
946 B1 = ROL64((A40^D0), 36);
947 B2 = ROL64((A11^D1), 10);
948 B3 = ROL64((A32^D2), 15);
949 B4 = ROL64((A03^D3), 56);
950 B0 = ROL64((A24^D4), 27);
951 A40 = B0 ^((~B1)& B2 );
952 A11 = B1 ^((~B2)& B3 );
953 A32 = B2 ^((~B3)& B4 );
954 A03 = B3 ^((~B4)& B0 );
955 A24 = B4 ^((~B0)& B1 );
956
957 B3 = ROL64((A20^D0), 41);
958 B4 = ROL64((A41^D1), 2);
959 B0 = ROL64((A12^D2), 62);
960 B1 = ROL64((A33^D3), 55);
961 B2 = ROL64((A04^D4), 39);
962 A20 = B0 ^((~B1)& B2 );
963 A41 = B1 ^((~B2)& B3 );
964 A12 = B2 ^((~B3)& B4 );
965 A33 = B3 ^((~B4)& B0 );
966 A04 = B4 ^((~B0)& B1 );
967
968 C0 = A00^A30^A10^A40^A20;
969 C1 = A21^A01^A31^A11^A41;
970 C2 = A42^A22^A02^A32^A12;
971 C3 = A13^A43^A23^A03^A33;
972 C4 = A34^A14^A44^A24^A04;
973 D0 = C4^ROL64(C1, 1);
974 D1 = C0^ROL64(C2, 1);
975 D2 = C1^ROL64(C3, 1);
976 D3 = C2^ROL64(C4, 1);
977 D4 = C3^ROL64(C0, 1);
978
979 B0 = (A00^D0);
980 B1 = ROL64((A01^D1), 44);
981 B2 = ROL64((A02^D2), 43);
982 B3 = ROL64((A03^D3), 21);
983 B4 = ROL64((A04^D4), 14);
984 A00 = B0 ^((~B1)& B2 );
985 A00 ^= RC[i+3];
986 A01 = B1 ^((~B2)& B3 );
987 A02 = B2 ^((~B3)& B4 );
988 A03 = B3 ^((~B4)& B0 );
989 A04 = B4 ^((~B0)& B1 );
990
991 B2 = ROL64((A10^D0), 3);
992 B3 = ROL64((A11^D1), 45);
993 B4 = ROL64((A12^D2), 61);
994 B0 = ROL64((A13^D3), 28);
995 B1 = ROL64((A14^D4), 20);
996 A10 = B0 ^((~B1)& B2 );
997 A11 = B1 ^((~B2)& B3 );
998 A12 = B2 ^((~B3)& B4 );
999 A13 = B3 ^((~B4)& B0 );
1000 A14 = B4 ^((~B0)& B1 );
1001
1002 B4 = ROL64((A20^D0), 18);
1003 B0 = ROL64((A21^D1), 1);
1004 B1 = ROL64((A22^D2), 6);
1005 B2 = ROL64((A23^D3), 25);
1006 B3 = ROL64((A24^D4), 8);
1007 A20 = B0 ^((~B1)& B2 );
1008 A21 = B1 ^((~B2)& B3 );
1009 A22 = B2 ^((~B3)& B4 );
1010 A23 = B3 ^((~B4)& B0 );
1011 A24 = B4 ^((~B0)& B1 );
1012
1013 B1 = ROL64((A30^D0), 36);
1014 B2 = ROL64((A31^D1), 10);
1015 B3 = ROL64((A32^D2), 15);
1016 B4 = ROL64((A33^D3), 56);
1017 B0 = ROL64((A34^D4), 27);
1018 A30 = B0 ^((~B1)& B2 );
1019 A31 = B1 ^((~B2)& B3 );
1020 A32 = B2 ^((~B3)& B4 );
1021 A33 = B3 ^((~B4)& B0 );
1022 A34 = B4 ^((~B0)& B1 );
1023
1024 B3 = ROL64((A40^D0), 41);
1025 B4 = ROL64((A41^D1), 2);
1026 B0 = ROL64((A42^D2), 62);
1027 B1 = ROL64((A43^D3), 55);
1028 B2 = ROL64((A44^D4), 39);
1029 A40 = B0 ^((~B1)& B2 );
1030 A41 = B1 ^((~B2)& B3 );
1031 A42 = B2 ^((~B3)& B4 );
1032 A43 = B3 ^((~B4)& B0 );
1033 A44 = B4 ^((~B0)& B1 );
1034 }
1035 }
1036
1037 /*
1038 ** Initialize a new hash. iSize determines the size of the hash
1039 ** in bits and should be one of 224, 256, 384, or 512. Or iSize
1040 ** can be zero to use the default hash size of 256 bits.
1041 */
1042 static void SHA3Init(SHA3Context *p, int iSize){
1043 memset(p, 0, sizeof(*p));
1044 if( iSize>=128 && iSize<=512 ){
1045 p->nRate = (1600 - ((iSize + 31)&~31)*2)/8;
1046 }else{
1047 p->nRate = (1600 - 2*256)/8;
1048 }
1049 #if SHA3_BYTEORDER==1234
1050 /* Known to be little-endian at compile-time. No-op */
1051 #elif SHA3_BYTEORDER==4321
1052 p->ixMask = 7; /* Big-endian */
1053 #else
1054 {
1055 static unsigned int one = 1;
1056 if( 1==*(unsigned char*)&one ){
1057 /* Little endian. No byte swapping. */
1058 p->ixMask = 0;
1059 }else{
1060 /* Big endian. Byte swap. */
1061 p->ixMask = 7;
1062 }
1063 }
1064 #endif
1065 }
1066
1067 /*
1068 ** Make consecutive calls to the SHA3Update function to add new content
1069 ** to the hash
1070 */
1071 static void SHA3Update(
1072 SHA3Context *p,
1073 const unsigned char *aData,
1074 unsigned int nData
1075 ){
1076 unsigned int i = 0;
1077 #if SHA3_BYTEORDER==1234
1078 if( (p->nLoaded % 8)==0 && ((aData - (const unsigned char*)0)&7)==0 ){
1079 for(; i+7<nData; i+=8){
1080 p->u.s[p->nLoaded/8] ^= *(u64*)&aData[i];
1081 p->nLoaded += 8;
1082 if( p->nLoaded>=p->nRate ){
1083 KeccakF1600Step(p);
1084 p->nLoaded = 0;
1085 }
1086 }
1087 }
1088 #endif
1089 for(; i<nData; i++){
1090 #if SHA3_BYTEORDER==1234
1091 p->u.x[p->nLoaded] ^= aData[i];
1092 #elif SHA3_BYTEORDER==4321
1093 p->u.x[p->nLoaded^0x07] ^= aData[i];
1094 #else
1095 p->u.x[p->nLoaded^p->ixMask] ^= aData[i];
1096 #endif
1097 p->nLoaded++;
1098 if( p->nLoaded==p->nRate ){
1099 KeccakF1600Step(p);
1100 p->nLoaded = 0;
1101 }
1102 }
1103 }
1104
1105 /*
1106 ** After all content has been added, invoke SHA3Final() to compute
1107 ** the final hash. The function returns a pointer to the binary
1108 ** hash value.
1109 */
1110 static unsigned char *SHA3Final(SHA3Context *p){
1111 unsigned int i;
1112 if( p->nLoaded==p->nRate-1 ){
1113 const unsigned char c1 = 0x86;
1114 SHA3Update(p, &c1, 1);
1115 }else{
1116 const unsigned char c2 = 0x06;
1117 const unsigned char c3 = 0x80;
1118 SHA3Update(p, &c2, 1);
1119 p->nLoaded = p->nRate - 1;
1120 SHA3Update(p, &c3, 1);
1121 }
1122 for(i=0; i<p->nRate; i++){
1123 p->u.x[i+p->nRate] = p->u.x[i^p->ixMask];
1124 }
1125 return &p->u.x[p->nRate];
1126 }
1127
1128 /*
1129 ** Implementation of the sha3(X,SIZE) function.
1130 **
1131 ** Return a BLOB which is the SIZE-bit SHA3 hash of X. The default
1132 ** size is 256. If X is a BLOB, it is hashed as is.
1133 ** For all other non-NULL types of input, X is converted into a UTF-8 string
1134 ** and the string is hashed without the trailing 0x00 terminator. The hash
1135 ** of a NULL value is NULL.
1136 */
1137 static void sha3Func(
1138 sqlite3_context *context,
1139 int argc,
1140 sqlite3_value **argv
1141 ){
1142 SHA3Context cx;
1143 int eType = sqlite3_value_type(argv[0]);
1144 int nByte = sqlite3_value_bytes(argv[0]);
1145 int iSize;
1146 if( argc==1 ){
1147 iSize = 256;
1148 }else{
1149 iSize = sqlite3_value_int(argv[1]);
1150 if( iSize!=224 && iSize!=256 && iSize!=384 && iSize!=512 ){
1151 sqlite3_result_error(context, "SHA3 size should be one of: 224 256 "
1152 "384 512", -1);
1153 return;
1154 }
1155 }
1156 if( eType==SQLITE_NULL ) return;
1157 SHA3Init(&cx, iSize);
1158 if( eType==SQLITE_BLOB ){
1159 SHA3Update(&cx, sqlite3_value_blob(argv[0]), nByte);
1160 }else{
1161 SHA3Update(&cx, sqlite3_value_text(argv[0]), nByte);
1162 }
1163 sqlite3_result_blob(context, SHA3Final(&cx), iSize/8, SQLITE_TRANSIENT);
1164 }
1165
1166 /* Compute a string using sqlite3_vsnprintf() with a maximum length
1167 ** of 50 bytes and add it to the hash.
1168 */
1169 static void hash_step_vformat(
1170 SHA3Context *p, /* Add content to this context */
1171 const char *zFormat,
1172 ...
1173 ){
1174 va_list ap;
1175 int n;
1176 char zBuf[50];
1177 va_start(ap, zFormat);
1178 sqlite3_vsnprintf(sizeof(zBuf),zBuf,zFormat,ap);
1179 va_end(ap);
1180 n = (int)strlen(zBuf);
1181 SHA3Update(p, (unsigned char*)zBuf, n);
1182 }
1183
1184 /*
1185 ** Implementation of the sha3_query(SQL,SIZE) function.
1186 **
1187 ** This function compiles and runs the SQL statement(s) given in the
1188 ** argument. The results are hashed using a SIZE-bit SHA3. The default
1189 ** size is 256.
1190 **
1191 ** The format of the byte stream that is hashed is summarized as follows:
1192 **
1193 ** S<n>:<sql>
1194 ** R
1195 ** N
1196 ** I<int>
1197 ** F<ieee-float>
1198 ** B<size>:<bytes>
1199 ** T<size>:<text>
1200 **
1201 ** <sql> is the original SQL text for each statement run and <n> is
1202 ** the size of that text. The SQL text is UTF-8. A single R character
1203 ** occurs before the start of each row. N means a NULL value.
1204 ** I mean an 8-byte little-endian integer <int>. F is a floating point
1205 ** number with an 8-byte little-endian IEEE floating point value <ieee-float>.
1206 ** B means blobs of <size> bytes. T means text rendered as <size>
1207 ** bytes of UTF-8. The <n> and <size> values are expressed as an ASCII
1208 ** text integers.
1209 **
1210 ** For each SQL statement in the X input, there is one S segment. Each
1211 ** S segment is followed by zero or more R segments, one for each row in the
1212 ** result set. After each R, there are one or more N, I, F, B, or T segments,
1213 ** one for each column in the result set. Segments are concatentated directly
1214 ** with no delimiters of any kind.
1215 */
1216 static void sha3QueryFunc(
1217 sqlite3_context *context,
1218 int argc,
1219 sqlite3_value **argv
1220 ){
1221 sqlite3 *db = sqlite3_context_db_handle(context);
1222 const char *zSql = (const char*)sqlite3_value_text(argv[0]);
1223 sqlite3_stmt *pStmt = 0;
1224 int nCol; /* Number of columns in the result set */
1225 int i; /* Loop counter */
1226 int rc;
1227 int n;
1228 const char *z;
1229 SHA3Context cx;
1230 int iSize;
1231
1232 if( argc==1 ){
1233 iSize = 256;
1234 }else{
1235 iSize = sqlite3_value_int(argv[1]);
1236 if( iSize!=224 && iSize!=256 && iSize!=384 && iSize!=512 ){
1237 sqlite3_result_error(context, "SHA3 size should be one of: 224 256 "
1238 "384 512", -1);
1239 return;
1240 }
1241 }
1242 if( zSql==0 ) return;
1243 SHA3Init(&cx, iSize);
1244 while( zSql[0] ){
1245 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zSql);
1246 if( rc ){
1247 char *zMsg = sqlite3_mprintf("error SQL statement [%s]: %s",
1248 zSql, sqlite3_errmsg(db));
1249 sqlite3_finalize(pStmt);
1250 sqlite3_result_error(context, zMsg, -1);
1251 sqlite3_free(zMsg);
1252 return;
1253 }
1254 if( !sqlite3_stmt_readonly(pStmt) ){
1255 char *zMsg = sqlite3_mprintf("non-query: [%s]", sqlite3_sql(pStmt));
1256 sqlite3_finalize(pStmt);
1257 sqlite3_result_error(context, zMsg, -1);
1258 sqlite3_free(zMsg);
1259 return;
1260 }
1261 nCol = sqlite3_column_count(pStmt);
1262 z = sqlite3_sql(pStmt);
1263 if( z==0 ){
1264 sqlite3_finalize(pStmt);
1265 continue;
1266 }
1267 n = (int)strlen(z);
1268 hash_step_vformat(&cx,"S%d:",n);
1269 SHA3Update(&cx,(unsigned char*)z,n);
1270
1271 /* Compute a hash over the result of the query */
1272 while( SQLITE_ROW==sqlite3_step(pStmt) ){
1273 SHA3Update(&cx,(const unsigned char*)"R",1);
1274 for(i=0; i<nCol; i++){
1275 switch( sqlite3_column_type(pStmt,i) ){
1276 case SQLITE_NULL: {
1277 SHA3Update(&cx, (const unsigned char*)"N",1);
1278 break;
1279 }
1280 case SQLITE_INTEGER: {
1281 sqlite3_uint64 u;
1282 int j;
1283 unsigned char x[9];
1284 sqlite3_int64 v = sqlite3_column_int64(pStmt,i);
1285 memcpy(&u, &v, 8);
1286 for(j=8; j>=1; j--){
1287 x[j] = u & 0xff;
1288 u >>= 8;
1289 }
1290 x[0] = 'I';
1291 SHA3Update(&cx, x, 9);
1292 break;
1293 }
1294 case SQLITE_FLOAT: {
1295 sqlite3_uint64 u;
1296 int j;
1297 unsigned char x[9];
1298 double r = sqlite3_column_double(pStmt,i);
1299 memcpy(&u, &r, 8);
1300 for(j=8; j>=1; j--){
1301 x[j] = u & 0xff;
1302 u >>= 8;
1303 }
1304 x[0] = 'F';
1305 SHA3Update(&cx,x,9);
1306 break;
1307 }
1308 case SQLITE_TEXT: {
1309 int n2 = sqlite3_column_bytes(pStmt, i);
1310 const unsigned char *z2 = sqlite3_column_text(pStmt, i);
1311 hash_step_vformat(&cx,"T%d:",n2);
1312 SHA3Update(&cx, z2, n2);
1313 break;
1314 }
1315 case SQLITE_BLOB: {
1316 int n2 = sqlite3_column_bytes(pStmt, i);
1317 const unsigned char *z2 = sqlite3_column_blob(pStmt, i);
1318 hash_step_vformat(&cx,"B%d:",n2);
1319 SHA3Update(&cx, z2, n2);
1320 break;
1321 }
1322 }
1323 }
1324 }
1325 sqlite3_finalize(pStmt);
1326 }
1327 sqlite3_result_blob(context, SHA3Final(&cx), iSize/8, SQLITE_TRANSIENT);
1328 }
1329 /* End of SHA3 hashing logic copy/pasted from ../ext/misc/shathree.c
1330 ********************************************************************************/
1331
1332 #if defined(SQLITE_ENABLE_SESSION)
1333 /*
1334 ** State information for a single open session
1335 */
@@ -608,17 +1359,14 @@
1359 ** instance of the following structure.
1360 */
1361 typedef struct ShellState ShellState;
1362 struct ShellState {
1363 sqlite3 *db; /* The database */
 
1364 int autoExplain; /* Automatically turn on .explain mode */
1365 int autoEQP; /* Run EXPLAIN QUERY PLAN prior to seach SQL stmt */
1366 int statsOn; /* True to display memory stats before each finalize */
1367 int scanstatsOn; /* True to display scan stats before each finalize */
 
 
1368 int outCount; /* Revert to stdout when reaching zero */
1369 int cnt; /* Number of records displayed so far */
1370 FILE *out; /* Write results here */
1371 FILE *traceOut; /* Output for sqlite3_trace() */
1372 int nErr; /* Number of errors seen */
@@ -653,13 +1401,24 @@
1401 };
1402
1403 /*
1404 ** These are the allowed shellFlgs values
1405 */
1406 #define SHFLG_Scratch 0x00000001 /* The --scratch option is used */
1407 #define SHFLG_Pagecache 0x00000002 /* The --pagecache option is used */
1408 #define SHFLG_Lookaside 0x00000004 /* Lookaside memory is used */
1409 #define SHFLG_Backslash 0x00000008 /* The --backslash option is used */
1410 #define SHFLG_PreserveRowid 0x00000010 /* .dump preserves rowid values */
1411 #define SHFLG_CountChanges 0x00000020 /* .changes setting */
1412 #define SHFLG_Echo 0x00000040 /* .echo or --echo setting */
1413
1414 /*
1415 ** Macros for testing and setting shellFlgs
1416 */
1417 #define ShellHasFlag(P,X) (((P)->shellFlgs & (X))!=0)
1418 #define ShellSetFlag(P,X) ((P)->shellFlgs|=(X))
1419 #define ShellClearFlag(P,X) ((P)->shellFlgs&=(~(X)))
1420
1421 /*
1422 ** These are the allowed modes.
1423 */
1424 #define MODE_Line 0 /* One column per line. Blank line between records */
@@ -729,36 +1488,56 @@
1488 raw_printf(out,"'");
1489 }
1490
1491 /*
1492 ** Output the given string as a quoted string using SQL quoting conventions.
1493 **
1494 ** The "\n" and "\r" characters are converted to char(10) and char(13)
1495 ** to prevent them from being transformed by end-of-line translators.
1496 */
1497 static void output_quoted_string(FILE *out, const char *z){
1498 int i;
1499 char c;
1500 setBinaryMode(out, 1);
1501 for(i=0; (c = z[i])!=0 && c!='\'' && c!='\n' && c!='\r'; i++){}
1502 if( c==0 ){
 
 
1503 utf8_printf(out,"'%s'",z);
1504 }else{
1505 int inQuote = 0;
1506 int bStarted = 0;
1507 while( *z ){
1508 for(i=0; (c = z[i])!=0 && c!='\n' && c!='\r' && c!='\''; i++){}
1509 if( c=='\'' ) i++;
1510 if( i ){
1511 if( !inQuote ){
1512 if( bStarted ) raw_printf(out, "||");
1513 raw_printf(out, "'");
1514 inQuote = 1;
1515 }
1516 utf8_printf(out, "%.*s", i, z);
1517 z += i;
1518 bStarted = 1;
1519 }
1520 if( c=='\'' ){
1521 raw_printf(out, "'");
1522 continue;
1523 }
1524 if( inQuote ){
1525 raw_printf(out, "'");
1526 inQuote = 0;
1527 }
1528 if( c==0 ){
1529 break;
1530 }
1531 for(i=0; (c = z[i])=='\r' || c=='\n'; i++){
1532 if( bStarted ) raw_printf(out, "||");
1533 raw_printf(out, "char(%d)", c);
1534 bStarted = 1;
1535 }
1536 z += i;
1537 }
1538 if( inQuote ) raw_printf(out, "'");
1539 }
1540 setTextMode(out, 1);
1541 }
1542
1543 /*
@@ -1246,13 +2025,17 @@
2025 if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){
2026 utf8_printf(p->out,"%sNULL",zSep);
2027 }else if( aiType && aiType[i]==SQLITE_TEXT ){
2028 if( zSep[0] ) utf8_printf(p->out,"%s",zSep);
2029 output_quoted_string(p->out, azArg[i]);
2030 }else if( aiType && aiType[i]==SQLITE_INTEGER ){
 
2031 utf8_printf(p->out,"%s%s",zSep, azArg[i]);
2032 }else if( aiType && aiType[i]==SQLITE_FLOAT ){
2033 char z[50];
2034 double r = sqlite3_column_double(p->pStmt, i);
2035 sqlite3_snprintf(50,z,"%!.20g", r);
2036 raw_printf(p->out, "%s%s", zSep, z);
2037 }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){
2038 const void *pBlob = sqlite3_column_blob(p->pStmt, i);
2039 int nBlob = sqlite3_column_bytes(p->pStmt, i);
2040 if( zSep[0] ) utf8_printf(p->out,"%s",zSep);
2041 output_hex_blob(p->out, pBlob, nBlob);
@@ -1292,92 +2075,106 @@
2075 */
2076 static int callback(void *pArg, int nArg, char **azArg, char **azCol){
2077 /* since we don't have type info, call the shell_callback with a NULL value */
2078 return shell_callback(pArg, nArg, azArg, azCol, NULL);
2079 }
2080
2081 /*
2082 ** This is the callback routine from sqlite3_exec() that appends all
2083 ** output onto the end of a ShellText object.
2084 */
2085 static int captureOutputCallback(void *pArg, int nArg, char **azArg, char **az){
2086 ShellText *p = (ShellText*)pArg;
2087 int i;
2088 if( p->n ) appendText(p, "|", 0);
2089 for(i=0; i<nArg; i++){
2090 if( i ) appendText(p, ",", 0);
2091 if( azArg[i] ) appendText(p, azArg[i], 0);
2092 }
2093 return 0;
2094 }
2095
2096 /*
2097 ** Generate an appropriate SELFTEST table in the main database.
2098 */
2099 static void createSelftestTable(ShellState *p){
2100 char *zErrMsg = 0;
2101 sqlite3_exec(p->db,
2102 "SAVEPOINT selftest_init;\n"
2103 "CREATE TABLE IF NOT EXISTS selftest(\n"
2104 " tno INTEGER PRIMARY KEY,\n" /* Test number */
2105 " op TEXT,\n" /* Operator: memo run */
2106 " cmd TEXT,\n" /* Command text */
2107 " ans TEXT\n" /* Desired answer */
2108 ");"
2109 "CREATE TEMP TABLE [_shell$self](op,cmd,ans);\n"
2110 "INSERT INTO [_shell$self](rowid,op,cmd)\n"
2111 " VALUES(coalesce((SELECT (max(tno)+100)/10 FROM selftest),10),\n"
2112 " 'memo','Tests generated by --init');\n"
2113 "INSERT INTO [_shell$self]\n"
2114 " SELECT 'run',\n"
2115 " 'SELECT hex(sha3_query(''SELECT type,name,tbl_name,sql "
2116 "FROM sqlite_master ORDER BY 2'',224))',\n"
2117 " hex(sha3_query('SELECT type,name,tbl_name,sql "
2118 "FROM sqlite_master ORDER BY 2',224));\n"
2119 "INSERT INTO [_shell$self]\n"
2120 " SELECT 'run',"
2121 " 'SELECT hex(sha3_query(''SELECT * FROM \"' ||"
2122 " printf('%w',name) || '\" NOT INDEXED'',224))',\n"
2123 " hex(sha3_query(printf('SELECT * FROM \"%w\" NOT INDEXED',name),224))\n"
2124 " FROM (\n"
2125 " SELECT name FROM sqlite_master\n"
2126 " WHERE type='table'\n"
2127 " AND name<>'selftest'\n"
2128 " AND coalesce(rootpage,0)>0\n"
2129 " )\n"
2130 " ORDER BY name;\n"
2131 "INSERT INTO [_shell$self]\n"
2132 " VALUES('run','PRAGMA integrity_check','ok');\n"
2133 "INSERT INTO selftest(tno,op,cmd,ans)"
2134 " SELECT rowid*10,op,cmd,ans FROM [_shell$self];\n"
2135 "DROP TABLE [_shell$self];"
2136 ,0,0,&zErrMsg);
2137 if( zErrMsg ){
2138 utf8_printf(stderr, "SELFTEST initialization failure: %s\n", zErrMsg);
2139 sqlite3_free(zErrMsg);
2140 }
2141 sqlite3_exec(p->db, "RELEASE selftest_init",0,0,0);
2142 }
2143
2144
2145 /*
2146 ** Set the destination table field of the ShellState structure to
2147 ** the name of the table given. Escape any quote characters in the
2148 ** table name.
2149 */
2150 static void set_table_name(ShellState *p, const char *zName){
2151 int i, n;
2152 int cQuote;
2153 char *z;
2154
2155 if( p->zDestTable ){
2156 free(p->zDestTable);
2157 p->zDestTable = 0;
2158 }
2159 if( zName==0 ) return;
2160 cQuote = quoteChar(zName);
2161 n = strlen30(zName);
2162 if( cQuote ) n += 2;
 
 
 
 
 
2163 z = p->zDestTable = malloc( n+1 );
2164 if( z==0 ){
2165 raw_printf(stderr,"Error: out of memory\n");
2166 exit(1);
2167 }
2168 n = 0;
2169 if( cQuote ) z[n++] = cQuote;
2170 for(i=0; zName[i]; i++){
2171 z[n++] = zName[i];
2172 if( zName[i]==cQuote ) z[n++] = cQuote;
2173 }
2174 if( cQuote ) z[n++] = cQuote;
2175 z[n] = 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2176 }
2177
2178
2179 /*
2180 ** Execute a query statement that will generate SQL output. Print
@@ -1484,10 +2281,35 @@
2281 }
2282 fclose(in);
2283 }
2284 #endif
2285
2286 /*
2287 ** Display a single line of status using 64-bit values.
2288 */
2289 static void displayStatLine(
2290 ShellState *p, /* The shell context */
2291 char *zLabel, /* Label for this one line */
2292 char *zFormat, /* Format for the result */
2293 int iStatusCtrl, /* Which status to display */
2294 int bReset /* True to reset the stats */
2295 ){
2296 sqlite3_int64 iCur = -1;
2297 sqlite3_int64 iHiwtr = -1;
2298 int i, nPercent;
2299 char zLine[200];
2300 sqlite3_status64(iStatusCtrl, &iCur, &iHiwtr, bReset);
2301 for(i=0, nPercent=0; zFormat[i]; i++){
2302 if( zFormat[i]=='%' ) nPercent++;
2303 }
2304 if( nPercent>1 ){
2305 sqlite3_snprintf(sizeof(zLine), zLine, zFormat, iCur, iHiwtr);
2306 }else{
2307 sqlite3_snprintf(sizeof(zLine), zLine, zFormat, iHiwtr);
2308 }
2309 raw_printf(p->out, "%-36s %s\n", zLabel, zLine);
2310 }
2311
2312 /*
2313 ** Display memory stats.
2314 */
2315 static int display_stats(
@@ -1497,61 +2319,35 @@
2319 ){
2320 int iCur;
2321 int iHiwtr;
2322
2323 if( pArg && pArg->out ){
2324 displayStatLine(pArg, "Memory Used:",
2325 "%lld (max %lld) bytes", SQLITE_STATUS_MEMORY_USED, bReset);
2326 displayStatLine(pArg, "Number of Outstanding Allocations:",
2327 "%lld (max %lld)", SQLITE_STATUS_MALLOC_COUNT, bReset);
 
 
 
 
 
 
2328 if( pArg->shellFlgs & SHFLG_Pagecache ){
2329 displayStatLine(pArg, "Number of Pcache Pages Used:",
2330 "%lld (max %lld) pages", SQLITE_STATUS_PAGECACHE_USED, bReset);
2331 }
2332 displayStatLine(pArg, "Number of Pcache Overflow Bytes:",
2333 "%lld (max %lld) bytes", SQLITE_STATUS_PAGECACHE_OVERFLOW, bReset);
 
 
 
 
 
 
2334 if( pArg->shellFlgs & SHFLG_Scratch ){
2335 displayStatLine(pArg, "Number of Scratch Allocations Used:",
2336 "%lld (max %lld)", SQLITE_STATUS_SCRATCH_USED, bReset);
2337 }
2338 displayStatLine(pArg, "Number of Scratch Overflow Bytes:",
2339 "%lld (max %lld) bytes", SQLITE_STATUS_SCRATCH_OVERFLOW, bReset);
2340 displayStatLine(pArg, "Largest Allocation:",
2341 "%lld bytes", SQLITE_STATUS_MALLOC_SIZE, bReset);
2342 displayStatLine(pArg, "Largest Pcache Allocation:",
2343 "%lld bytes", SQLITE_STATUS_PAGECACHE_SIZE, bReset);
2344 displayStatLine(pArg, "Largest Scratch Allocation:",
2345 "%lld bytes", SQLITE_STATUS_SCRATCH_SIZE, bReset);
 
 
 
 
 
 
 
 
 
 
 
 
2346 #ifdef YYTRACKMAXSTACKDEPTH
2347 displayStatLine(pArg, "Deepest Parser Stack:",
2348 "%lld (max %lld)", SQLITE_STATUS_PARSER_STACK, bReset);
 
 
2349 #endif
2350 }
2351
2352 if( pArg && pArg->out && db ){
2353 if( pArg->shellFlgs & SHFLG_Lookaside ){
@@ -1934,11 +2730,11 @@
2730 pArg->pStmt = pStmt;
2731 pArg->cnt = 0;
2732 }
2733
2734 /* echo the sql statement if echo on */
2735 if( pArg && ShellHasFlag(pArg, SHFLG_Echo) ){
2736 utf8_printf(pArg->out, "%s\n", zStmtSql ? zStmtSql : zSql);
2737 }
2738
2739 /* Show the EXPLAIN QUERY PLAN if .eqp is on */
2740 if( pArg && pArg->autoEQP && sqlite3_strlike("EXPLAIN%",zStmtSql,0)!=0 ){
@@ -2022,10 +2818,142 @@
2818 } /* end while */
2819
2820 return rc;
2821 }
2822
2823 /*
2824 ** Release memory previously allocated by tableColumnList().
2825 */
2826 static void freeColumnList(char **azCol){
2827 int i;
2828 for(i=1; azCol[i]; i++){
2829 sqlite3_free(azCol[i]);
2830 }
2831 /* azCol[0] is a static string */
2832 sqlite3_free(azCol);
2833 }
2834
2835 /*
2836 ** Return a list of pointers to strings which are the names of all
2837 ** columns in table zTab. The memory to hold the names is dynamically
2838 ** allocated and must be released by the caller using a subsequent call
2839 ** to freeColumnList().
2840 **
2841 ** The azCol[0] entry is usually NULL. However, if zTab contains a rowid
2842 ** value that needs to be preserved, then azCol[0] is filled in with the
2843 ** name of the rowid column.
2844 **
2845 ** The first regular column in the table is azCol[1]. The list is terminated
2846 ** by an entry with azCol[i]==0.
2847 */
2848 static char **tableColumnList(ShellState *p, const char *zTab){
2849 char **azCol = 0;
2850 sqlite3_stmt *pStmt;
2851 char *zSql;
2852 int nCol = 0;
2853 int nAlloc = 0;
2854 int nPK = 0; /* Number of PRIMARY KEY columns seen */
2855 int isIPK = 0; /* True if one PRIMARY KEY column of type INTEGER */
2856 int preserveRowid = ShellHasFlag(p, SHFLG_PreserveRowid);
2857 int rc;
2858
2859 zSql = sqlite3_mprintf("PRAGMA table_info=%Q", zTab);
2860 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
2861 sqlite3_free(zSql);
2862 if( rc ) return 0;
2863 while( sqlite3_step(pStmt)==SQLITE_ROW ){
2864 if( nCol>=nAlloc-2 ){
2865 nAlloc = nAlloc*2 + nCol + 10;
2866 azCol = sqlite3_realloc(azCol, nAlloc*sizeof(azCol[0]));
2867 if( azCol==0 ){
2868 raw_printf(stderr, "Error: out of memory\n");
2869 exit(1);
2870 }
2871 }
2872 azCol[++nCol] = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 1));
2873 if( sqlite3_column_int(pStmt, 5) ){
2874 nPK++;
2875 if( nPK==1
2876 && sqlite3_stricmp((const char*)sqlite3_column_text(pStmt,2),
2877 "INTEGER")==0
2878 ){
2879 isIPK = 1;
2880 }else{
2881 isIPK = 0;
2882 }
2883 }
2884 }
2885 sqlite3_finalize(pStmt);
2886 azCol[0] = 0;
2887 azCol[nCol+1] = 0;
2888
2889 /* The decision of whether or not a rowid really needs to be preserved
2890 ** is tricky. We never need to preserve a rowid for a WITHOUT ROWID table
2891 ** or a table with an INTEGER PRIMARY KEY. We are unable to preserve
2892 ** rowids on tables where the rowid is inaccessible because there are other
2893 ** columns in the table named "rowid", "_rowid_", and "oid".
2894 */
2895 if( preserveRowid && isIPK ){
2896 /* If a single PRIMARY KEY column with type INTEGER was seen, then it
2897 ** might be an alise for the ROWID. But it might also be a WITHOUT ROWID
2898 ** table or a INTEGER PRIMARY KEY DESC column, neither of which are
2899 ** ROWID aliases. To distinguish these cases, check to see if
2900 ** there is a "pk" entry in "PRAGMA index_list". There will be
2901 ** no "pk" index if the PRIMARY KEY really is an alias for the ROWID.
2902 */
2903 zSql = sqlite3_mprintf("SELECT 1 FROM pragma_index_list(%Q)"
2904 " WHERE origin='pk'", zTab);
2905 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
2906 sqlite3_free(zSql);
2907 if( rc ){
2908 freeColumnList(azCol);
2909 return 0;
2910 }
2911 rc = sqlite3_step(pStmt);
2912 sqlite3_finalize(pStmt);
2913 preserveRowid = rc==SQLITE_ROW;
2914 }
2915 if( preserveRowid ){
2916 /* Only preserve the rowid if we can find a name to use for the
2917 ** rowid */
2918 static char *azRowid[] = { "rowid", "_rowid_", "oid" };
2919 int i, j;
2920 for(j=0; j<3; j++){
2921 for(i=1; i<=nCol; i++){
2922 if( sqlite3_stricmp(azRowid[j],azCol[i])==0 ) break;
2923 }
2924 if( i>nCol ){
2925 /* At this point, we know that azRowid[j] is not the name of any
2926 ** ordinary column in the table. Verify that azRowid[j] is a valid
2927 ** name for the rowid before adding it to azCol[0]. WITHOUT ROWID
2928 ** tables will fail this last check */
2929 int rc;
2930 rc = sqlite3_table_column_metadata(p->db,0,zTab,azRowid[j],0,0,0,0,0);
2931 if( rc==SQLITE_OK ) azCol[0] = azRowid[j];
2932 break;
2933 }
2934 }
2935 }
2936 return azCol;
2937 }
2938
2939 /*
2940 ** Toggle the reverse_unordered_selects setting.
2941 */
2942 static void toggleSelectOrder(sqlite3 *db){
2943 sqlite3_stmt *pStmt = 0;
2944 int iSetting = 0;
2945 char zStmt[100];
2946 sqlite3_prepare_v2(db, "PRAGMA reverse_unordered_selects", -1, &pStmt, 0);
2947 if( sqlite3_step(pStmt)==SQLITE_ROW ){
2948 iSetting = sqlite3_column_int(pStmt, 0);
2949 }
2950 sqlite3_finalize(pStmt);
2951 sqlite3_snprintf(sizeof(zStmt), zStmt,
2952 "PRAGMA reverse_unordered_selects(%d)", !iSetting);
2953 sqlite3_exec(db, zStmt, 0, 0, 0);
2954 }
2955
2956 /*
2957 ** This is a different callback routine used for dumping the database.
2958 ** Each row received by this callback consists of a table name,
2959 ** the table type ("index" or "table") and SQL to create the table.
@@ -2034,21 +2962,20 @@
2962 static int dump_callback(void *pArg, int nArg, char **azArg, char **azCol){
2963 int rc;
2964 const char *zTable;
2965 const char *zType;
2966 const char *zSql;
 
2967 ShellState *p = (ShellState *)pArg;
2968
2969 UNUSED_PARAMETER(azCol);
2970 if( nArg!=3 ) return 1;
2971 zTable = azArg[0];
2972 zType = azArg[1];
2973 zSql = azArg[2];
2974
2975 if( strcmp(zTable, "sqlite_sequence")==0 ){
2976 raw_printf(p->out, "DELETE FROM sqlite_sequence;\n");
2977 }else if( sqlite3_strglob("sqlite_stat?", zTable)==0 ){
2978 raw_printf(p->out, "ANALYZE sqlite_master;\n");
2979 }else if( strncmp(zTable, "sqlite_", 7)==0 ){
2980 return 0;
2981 }else if( strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){
@@ -2067,62 +2994,74 @@
2994 }else{
2995 printSchemaLine(p->out, zSql, ";\n");
2996 }
2997
2998 if( strcmp(zType, "table")==0 ){
2999 ShellText sSelect;
3000 ShellText sTable;
3001 char **azCol;
3002 int i;
3003 char *savedDestTable;
3004 int savedMode;
3005
3006 azCol = tableColumnList(p, zTable);
3007 if( azCol==0 ){
3008 p->nErr++;
3009 return 0;
3010 }
3011
 
 
 
 
3012 /* Always quote the table name, even if it appears to be pure ascii,
3013 ** in case it is a keyword. Ex: INSERT INTO "table" ... */
3014 initText(&sTable);
3015 appendText(&sTable, zTable, quoteChar(zTable));
3016 /* If preserving the rowid, add a column list after the table name.
3017 ** In other words: "INSERT INTO tab(rowid,a,b,c,...) VALUES(...)"
3018 ** instead of the usual "INSERT INTO tab VALUES(...)".
3019 */
3020 if( azCol[0] ){
3021 appendText(&sTable, "(", 0);
3022 appendText(&sTable, azCol[0], 0);
3023 for(i=1; azCol[i]; i++){
3024 appendText(&sTable, ",", 0);
3025 appendText(&sTable, azCol[i], quoteChar(azCol[i]));
3026 }
3027 appendText(&sTable, ")", 0);
3028 }
3029
3030 /* Build an appropriate SELECT statement */
3031 initText(&sSelect);
3032 appendText(&sSelect, "SELECT ", 0);
3033 if( azCol[0] ){
3034 appendText(&sSelect, azCol[0], 0);
3035 appendText(&sSelect, ",", 0);
3036 }
3037 for(i=1; azCol[i]; i++){
3038 appendText(&sSelect, azCol[i], quoteChar(azCol[i]));
3039 if( azCol[i+1] ){
3040 appendText(&sSelect, ",", 0);
3041 }
3042 }
3043 freeColumnList(azCol);
3044 appendText(&sSelect, " FROM ", 0);
3045 appendText(&sSelect, zTable, quoteChar(zTable));
3046
3047 savedDestTable = p->zDestTable;
3048 savedMode = p->mode;
3049 p->zDestTable = sTable.z;
3050 p->mode = p->cMode = MODE_Insert;
3051 rc = shell_exec(p->db, sSelect.z, shell_callback, p, 0);
3052 if( (rc&0xff)==SQLITE_CORRUPT ){
3053 raw_printf(p->out, "/****** CORRUPTION ERROR *******/\n");
3054 toggleSelectOrder(p->db);
3055 shell_exec(p->db, sSelect.z, shell_callback, p, 0);
3056 toggleSelectOrder(p->db);
3057 }
3058 p->zDestTable = savedDestTable;
3059 p->mode = savedMode;
3060 freeText(&sTable);
3061 freeText(&sSelect);
3062 if( rc ) p->nErr++;
3063 }
3064 return 0;
3065 }
3066
3067 /*
@@ -2228,15 +3167,17 @@
3167 ".restore ?DB? FILE Restore content of DB (default \"main\") from FILE\n"
3168 ".save FILE Write in-memory database into FILE\n"
3169 ".scanstats on|off Turn sqlite3_stmt_scanstatus() metrics on or off\n"
3170 ".schema ?PATTERN? Show the CREATE statements matching PATTERN\n"
3171 " Add --indent for pretty-printing\n"
3172 ".selftest ?--init? Run tests defined in the SELFTEST table\n"
3173 ".separator COL ?ROW? Change the column separator and optionally the row\n"
3174 " separator for both the output mode and .import\n"
3175 #if defined(SQLITE_ENABLE_SESSION)
3176 ".session CMD ... Create or control sessions\n"
3177 #endif
3178 ".sha3sum ?OPTIONS...? Compute a SHA3 hash of database content\n"
3179 ".shell CMD ARGS... Run CMD ARGS... in a system shell\n"
3180 ".show Show the current values for various settings\n"
3181 ".stats ?on|off? Show stats or turn stats on or off\n"
3182 ".system CMD ARGS... Run CMD ARGS... in a system shell\n"
3183 ".tables ?TABLE? List names of tables\n"
@@ -2423,14 +3364,10 @@
3364 static void open_db(ShellState *p, int keepAlive){
3365 if( p->db==0 ){
3366 sqlite3_initialize();
3367 sqlite3_open(p->zDbFilename, &p->db);
3368 globalDb = p->db;
 
 
 
 
3369 if( p->db==0 || SQLITE_OK!=sqlite3_errcode(p->db) ){
3370 utf8_printf(stderr,"Error: unable to open database \"%s\": %s\n",
3371 p->zDbFilename, sqlite3_errmsg(p->db));
3372 if( keepAlive ) return;
3373 exit(1);
@@ -2440,10 +3377,18 @@
3377 #endif
3378 sqlite3_create_function(p->db, "readfile", 1, SQLITE_UTF8, 0,
3379 readfileFunc, 0, 0);
3380 sqlite3_create_function(p->db, "writefile", 2, SQLITE_UTF8, 0,
3381 writefileFunc, 0, 0);
3382 sqlite3_create_function(p->db, "sha3", 1, SQLITE_UTF8, 0,
3383 sha3Func, 0, 0);
3384 sqlite3_create_function(p->db, "sha3", 2, SQLITE_UTF8, 0,
3385 sha3Func, 0, 0);
3386 sqlite3_create_function(p->db, "sha3_query", 1, SQLITE_UTF8, 0,
3387 sha3QueryFunc, 0, 0);
3388 sqlite3_create_function(p->db, "sha3_query", 2, SQLITE_UTF8, 0,
3389 sha3QueryFunc, 0, 0);
3390 }
3391 }
3392
3393 /*
3394 ** Do C-language style dequoting.
@@ -2564,11 +3509,11 @@
3509
3510 /*
3511 ** Interpret zArg as either an integer or a boolean value. Return 1 or 0
3512 ** for TRUE and FALSE. Return the integer value if appropriate.
3513 */
3514 static int booleanValue(const char *zArg){
3515 int i;
3516 if( zArg[0]=='0' && zArg[1]=='x' ){
3517 for(i=2; hexDigitValue(zArg[i])>=0; i++){}
3518 }else{
3519 for(i=0; zArg[i]>='0' && zArg[i]<='9'; i++){}
@@ -2582,10 +3527,21 @@
3527 }
3528 utf8_printf(stderr, "ERROR: Not a boolean value: \"%s\". Assuming \"no\".\n",
3529 zArg);
3530 return 0;
3531 }
3532
3533 /*
3534 ** Set or clear a shell flag according to a boolean value.
3535 */
3536 static void setOrClearFlag(ShellState *p, unsigned mFlag, const char *zArg){
3537 if( booleanValue(zArg) ){
3538 ShellSetFlag(p, mFlag);
3539 }else{
3540 ShellClearFlag(p, mFlag);
3541 }
3542 }
3543
3544 /*
3545 ** Close an output file, assuming it is not stderr or stdout
3546 */
3547 static void output_file_close(FILE *f){
@@ -3656,11 +4612,11 @@
4612 test_breakpoint();
4613 }else
4614
4615 if( c=='c' && n>=3 && strncmp(azArg[0], "changes", n)==0 ){
4616 if( nArg==2 ){
4617 setOrClearFlag(p, SHFLG_CountChanges, azArg[1]);
4618 }else{
4619 raw_printf(stderr, "Usage: .changes on|off\n");
4620 rc = 1;
4621 }
4622 }else
@@ -3720,25 +4676,46 @@
4676 if( c=='d' && strncmp(azArg[0], "dbinfo", n)==0 ){
4677 rc = shell_dbinfo_command(p, nArg, azArg);
4678 }else
4679
4680 if( c=='d' && strncmp(azArg[0], "dump", n)==0 ){
4681 const char *zLike = 0;
4682 int i;
4683 ShellClearFlag(p, SHFLG_PreserveRowid);
4684 for(i=1; i<nArg; i++){
4685 if( azArg[i][0]=='-' ){
4686 const char *z = azArg[i]+1;
4687 if( z[0]=='-' ) z++;
4688 if( strcmp(z,"preserve-rowids")==0 ){
4689 ShellSetFlag(p, SHFLG_PreserveRowid);
4690 }else
4691 {
4692 raw_printf(stderr, "Unknown option \"%s\" on \".dump\"\n", azArg[i]);
4693 rc = 1;
4694 goto meta_command_exit;
4695 }
4696 }else if( zLike ){
4697 raw_printf(stderr, "Usage: .dump ?--preserve-rowids? ?LIKE-PATTERN?\n");
4698 rc = 1;
4699 goto meta_command_exit;
4700 }else{
4701 zLike = azArg[i];
4702 }
4703 }
4704 open_db(p, 0);
4705 /* When playing back a "dump", the content might appear in an order
4706 ** which causes immediate foreign key constraints to be violated.
4707 ** So disable foreign-key constraint enforcement to prevent problems. */
 
 
 
 
 
4708 raw_printf(p->out, "PRAGMA foreign_keys=OFF;\n");
4709 raw_printf(p->out, "BEGIN TRANSACTION;\n");
4710 p->writableSchema = 0;
4711 /* Set writable_schema=ON since doing so forces SQLite to initialize
4712 ** as much of the schema as it can even if the sqlite_master table is
4713 ** corrupt. */
4714 sqlite3_exec(p->db, "SAVEPOINT dump; PRAGMA writable_schema=ON", 0, 0, 0);
4715 p->nErr = 0;
4716 if( zLike==0 ){
4717 run_schema_dump_query(p,
4718 "SELECT name, type, sql FROM sqlite_master "
4719 "WHERE sql NOT NULL AND type=='table' AND name!='sqlite_sequence'"
4720 );
4721 run_schema_dump_query(p,
@@ -3748,25 +4725,24 @@
4725 run_table_dump_query(p,
4726 "SELECT sql FROM sqlite_master "
4727 "WHERE sql NOT NULL AND type IN ('index','trigger','view')", 0
4728 );
4729 }else{
4730 char *zSql;
4731 zSql = sqlite3_mprintf(
4732 "SELECT name, type, sql FROM sqlite_master "
4733 "WHERE tbl_name LIKE %Q AND type=='table'"
4734 " AND sql NOT NULL", zLike);
4735 run_schema_dump_query(p,zSql);
4736 sqlite3_free(zSql);
4737 zSql = sqlite3_mprintf(
4738 "SELECT sql FROM sqlite_master "
4739 "WHERE sql NOT NULL"
4740 " AND type IN ('index','trigger','view')"
4741 " AND tbl_name LIKE %Q", zLike);
4742 run_table_dump_query(p, zSql, 0);
4743 sqlite3_free(zSql);
 
4744 }
4745 if( p->writableSchema ){
4746 raw_printf(p->out, "PRAGMA writable_schema=OFF;\n");
4747 p->writableSchema = 0;
4748 }
@@ -3775,11 +4751,11 @@
4751 raw_printf(p->out, p->nErr ? "ROLLBACK; -- due to errors\n" : "COMMIT;\n");
4752 }else
4753
4754 if( c=='e' && strncmp(azArg[0], "echo", n)==0 ){
4755 if( nArg==2 ){
4756 setOrClearFlag(p, SHFLG_Echo, azArg[1]);
4757 }else{
4758 raw_printf(stderr, "Usage: .echo on|off\n");
4759 rc = 1;
4760 }
4761 }else
@@ -4572,21 +5548,21 @@
5548 new_colv[0] = "sql";
5549 new_colv[1] = 0;
5550 callback(&data, 1, new_argv, new_colv);
5551 rc = SQLITE_OK;
5552 }else{
5553 char *zSql;
5554 zSql = sqlite3_mprintf(
5555 "SELECT sql FROM "
5556 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
5557 " FROM sqlite_master UNION ALL"
5558 " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
5559 "WHERE lower(tbl_name) LIKE %Q"
5560 " AND type!='meta' AND sql NOTNULL "
5561 "ORDER BY rowid", azArg[1]);
5562 rc = sqlite3_exec(p->db, zSql, callback, &data, &zErrMsg);
5563 sqlite3_free(zSql);
5564 }
5565 }else if( nArg==1 ){
5566 rc = sqlite3_exec(p->db,
5567 "SELECT sql FROM "
5568 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
@@ -4835,10 +5811,123 @@
5811 utf8_printf(p->out, "%s", zBuf);
5812 }
5813 }
5814 }else
5815 #endif
5816
5817 if( c=='s' && n>=4 && strncmp(azArg[0],"selftest",n)==0 ){
5818 int bIsInit = 0; /* True to initialize the SELFTEST table */
5819 int bVerbose = 0; /* Verbose output */
5820 int bSelftestExists; /* True if SELFTEST already exists */
5821 char **azTest = 0; /* Content of the SELFTEST table */
5822 int nRow = 0; /* Number of rows in the SELFTEST table */
5823 int nCol = 4; /* Number of columns in the SELFTEST table */
5824 int i; /* Loop counter */
5825 int nTest = 0; /* Number of tests runs */
5826 int nErr = 0; /* Number of errors seen */
5827 ShellText str; /* Answer for a query */
5828 static char *azDefaultTest[] = {
5829 0, 0, 0, 0,
5830 "0", "memo", "Missing SELFTEST table - default checks only", "",
5831 "1", "run", "PRAGMA integrity_check", "ok"
5832 };
5833 static const int nDefaultRow = 2;
5834
5835 open_db(p,0);
5836 for(i=1; i<nArg; i++){
5837 const char *z = azArg[i];
5838 if( z[0]=='-' && z[1]=='-' ) z++;
5839 if( strcmp(z,"-init")==0 ){
5840 bIsInit = 1;
5841 }else
5842 if( strcmp(z,"-v")==0 ){
5843 bVerbose++;
5844 }else
5845 {
5846 utf8_printf(stderr, "Unknown option \"%s\" on \"%s\"\n",
5847 azArg[i], azArg[0]);
5848 raw_printf(stderr, "Should be one of: --init -v\n");
5849 rc = 1;
5850 goto meta_command_exit;
5851 }
5852 }
5853 if( sqlite3_table_column_metadata(p->db,"main","selftest",0,0,0,0,0,0)
5854 != SQLITE_OK ){
5855 bSelftestExists = 0;
5856 }else{
5857 bSelftestExists = 1;
5858 }
5859 if( bIsInit ){
5860 createSelftestTable(p);
5861 bSelftestExists = 1;
5862 }
5863 if( bSelftestExists ){
5864 rc = sqlite3_get_table(p->db,
5865 "SELECT tno,op,cmd,ans FROM selftest ORDER BY tno",
5866 &azTest, &nRow, &nCol, 0);
5867 if( rc ){
5868 raw_printf(stderr, "Error querying the selftest table\n");
5869 rc = 1;
5870 sqlite3_free_table(azTest);
5871 goto meta_command_exit;
5872 }else if( nRow==0 ){
5873 sqlite3_free_table(azTest);
5874 azTest = azDefaultTest;
5875 nRow = nDefaultRow;
5876 }
5877 }else{
5878 azTest = azDefaultTest;
5879 nRow = nDefaultRow;
5880 }
5881 initText(&str);
5882 appendText(&str, "x", 0);
5883 for(i=1; i<=nRow; i++){
5884 int tno = atoi(azTest[i*nCol]);
5885 const char *zOp = azTest[i*nCol+1];
5886 const char *zSql = azTest[i*nCol+2];
5887 const char *zAns = azTest[i*nCol+3];
5888
5889 if( bVerbose>0 ){
5890 char *zQuote = sqlite3_mprintf("%q", zSql);
5891 printf("%d: %s %s\n", tno, zOp, zSql);
5892 sqlite3_free(zQuote);
5893 }
5894 if( strcmp(zOp,"memo")==0 ){
5895 utf8_printf(p->out, "%s\n", zSql);
5896 }else
5897 if( strcmp(zOp,"run")==0 ){
5898 char *zErrMsg = 0;
5899 str.n = 0;
5900 str.z[0] = 0;
5901 rc = sqlite3_exec(p->db, zSql, captureOutputCallback, &str, &zErrMsg);
5902 nTest++;
5903 if( bVerbose ){
5904 utf8_printf(p->out, "Result: %s\n", str.z);
5905 }
5906 if( rc || zErrMsg ){
5907 nErr++;
5908 rc = 1;
5909 utf8_printf(p->out, "%d: error-code-%d: %s\n", tno, rc, zErrMsg);
5910 sqlite3_free(zErrMsg);
5911 }else if( strcmp(zAns,str.z)!=0 ){
5912 nErr++;
5913 rc = 1;
5914 utf8_printf(p->out, "%d: Expected: [%s]\n", tno, zAns);
5915 utf8_printf(p->out, "%d: Got: [%s]\n", tno, str.z);
5916 }
5917 }else
5918 {
5919 utf8_printf(stderr,
5920 "Unknown operation \"%s\" on selftest line %d\n", zOp, tno);
5921 rc = 1;
5922 break;
5923 }
5924 }
5925 freeText(&str);
5926 if( azTest!=azDefaultTest ) sqlite3_free_table(azTest);
5927 utf8_printf(p->out, "%d errors out of %d tests\n", nErr, nTest);
5928 }else
5929
5930 if( c=='s' && strncmp(azArg[0], "separator", n)==0 ){
5931 if( nArg<2 || nArg>3 ){
5932 raw_printf(stderr, "Usage: .separator COL ?ROW?\n");
5933 rc = 1;
@@ -4850,10 +5939,126 @@
5939 if( nArg>=3 ){
5940 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator,
5941 "%.*s", (int)ArraySize(p->rowSeparator)-1, azArg[2]);
5942 }
5943 }else
5944
5945 if( c=='s' && n>=4 && strncmp(azArg[0],"sha3sum",n)==0 ){
5946 const char *zLike = 0; /* Which table to checksum. 0 means everything */
5947 int i; /* Loop counter */
5948 int bSchema = 0; /* Also hash the schema */
5949 int bSeparate = 0; /* Hash each table separately */
5950 int iSize = 224; /* Hash algorithm to use */
5951 int bDebug = 0; /* Only show the query that would have run */
5952 sqlite3_stmt *pStmt; /* For querying tables names */
5953 char *zSql; /* SQL to be run */
5954 char *zSep; /* Separator */
5955 ShellText sSql; /* Complete SQL for the query to run the hash */
5956 ShellText sQuery; /* Set of queries used to read all content */
5957 open_db(p, 0);
5958 for(i=1; i<nArg; i++){
5959 const char *z = azArg[i];
5960 if( z[0]=='-' ){
5961 z++;
5962 if( z[0]=='-' ) z++;
5963 if( strcmp(z,"schema")==0 ){
5964 bSchema = 1;
5965 }else
5966 if( strcmp(z,"sha3-224")==0 || strcmp(z,"sha3-256")==0
5967 || strcmp(z,"sha3-384")==0 || strcmp(z,"sha3-512")==0
5968 ){
5969 iSize = atoi(&z[5]);
5970 }else
5971 if( strcmp(z,"debug")==0 ){
5972 bDebug = 1;
5973 }else
5974 {
5975 utf8_printf(stderr, "Unknown option \"%s\" on \"%s\"\n",
5976 azArg[i], azArg[0]);
5977 raw_printf(stderr, "Should be one of: --schema"
5978 " --sha3-224 --sha3-255 --sha3-384 --sha3-512\n");
5979 rc = 1;
5980 goto meta_command_exit;
5981 }
5982 }else if( zLike ){
5983 raw_printf(stderr, "Usage: .sha3sum ?OPTIONS? ?LIKE-PATTERN?\n");
5984 rc = 1;
5985 goto meta_command_exit;
5986 }else{
5987 zLike = z;
5988 bSeparate = 1;
5989 if( sqlite3_strlike("sqlite_%", zLike, 0)==0 ) bSchema = 1;
5990 }
5991 }
5992 if( bSchema ){
5993 zSql = "SELECT lower(name) FROM sqlite_master"
5994 " WHERE type='table' AND coalesce(rootpage,0)>1"
5995 " UNION ALL SELECT 'sqlite_master'"
5996 " ORDER BY 1 collate nocase";
5997 }else{
5998 zSql = "SELECT lower(name) FROM sqlite_master"
5999 " WHERE type='table' AND coalesce(rootpage,0)>1"
6000 " AND name NOT LIKE 'sqlite_%'"
6001 " ORDER BY 1 collate nocase";
6002 }
6003 sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
6004 initText(&sQuery);
6005 initText(&sSql);
6006 appendText(&sSql, "WITH [sha3sum$query](a,b) AS(",0);
6007 zSep = "VALUES(";
6008 while( SQLITE_ROW==sqlite3_step(pStmt) ){
6009 const char *zTab = (const char*)sqlite3_column_text(pStmt,0);
6010 if( zLike && sqlite3_strlike(zLike, zTab, 0)!=0 ) continue;
6011 if( strncmp(zTab, "sqlite_",7)!=0 ){
6012 appendText(&sQuery,"SELECT * FROM ", 0);
6013 appendText(&sQuery,zTab,'"');
6014 appendText(&sQuery," NOT INDEXED;", 0);
6015 }else if( strcmp(zTab, "sqlite_master")==0 ){
6016 appendText(&sQuery,"SELECT type,name,tbl_name,sql FROM sqlite_master"
6017 " ORDER BY name;", 0);
6018 }else if( strcmp(zTab, "sqlite_sequence")==0 ){
6019 appendText(&sQuery,"SELECT name,seq FROM sqlite_sequence"
6020 " ORDER BY name;", 0);
6021 }else if( strcmp(zTab, "sqlite_stat1")==0 ){
6022 appendText(&sQuery,"SELECT tbl,idx,stat FROM sqlite_stat1"
6023 " ORDER BY tbl,idx;", 0);
6024 }else if( strcmp(zTab, "sqlite_stat3")==0
6025 || strcmp(zTab, "sqlite_stat4")==0 ){
6026 appendText(&sQuery, "SELECT * FROM ", 0);
6027 appendText(&sQuery, zTab, 0);
6028 appendText(&sQuery, " ORDER BY tbl, idx, rowid;\n", 0);
6029 }
6030 appendText(&sSql, zSep, 0);
6031 appendText(&sSql, sQuery.z, '\'');
6032 sQuery.n = 0;
6033 appendText(&sSql, ",", 0);
6034 appendText(&sSql, zTab, '\'');
6035 zSep = "),(";
6036 }
6037 sqlite3_finalize(pStmt);
6038 if( bSeparate ){
6039 zSql = sqlite3_mprintf(
6040 "%s))"
6041 " SELECT lower(hex(sha3_query(a,%d))) AS hash, b AS label"
6042 " FROM [sha3sum$query]",
6043 sSql.z, iSize);
6044 }else{
6045 zSql = sqlite3_mprintf(
6046 "%s))"
6047 " SELECT lower(hex(sha3_query(group_concat(a,''),%d))) AS hash"
6048 " FROM [sha3sum$query]",
6049 sSql.z, iSize);
6050 }
6051 freeText(&sQuery);
6052 freeText(&sSql);
6053 if( bDebug ){
6054 utf8_printf(p->out, "%s\n", zSql);
6055 }else{
6056 shell_exec(p->db, zSql, shell_callback, p, 0);
6057 }
6058 sqlite3_free(zSql);
6059 }else
6060
6061 if( c=='s'
6062 && (strncmp(azArg[0], "shell", n)==0 || strncmp(azArg[0],"system",n)==0)
6063 ){
6064 char *zCmd;
@@ -4879,11 +6084,12 @@
6084 if( nArg!=1 ){
6085 raw_printf(stderr, "Usage: .show\n");
6086 rc = 1;
6087 goto meta_command_exit;
6088 }
6089 utf8_printf(p->out, "%12.12s: %s\n","echo",
6090 azBool[ShellHasFlag(p, SHFLG_Echo)]);
6091 utf8_printf(p->out, "%12.12s: %s\n","eqp", azBool[p->autoEQP&3]);
6092 utf8_printf(p->out, "%12.12s: %s\n","explain",
6093 p->mode==MODE_Explain ? "on" : p->autoExplain ? "auto" : "off");
6094 utf8_printf(p->out,"%12.12s: %s\n","headers", azBool[p->showHeader!=0]);
6095 utf8_printf(p->out, "%12.12s: %s\n","mode", modeDescr[p->mode]);
@@ -5444,11 +6650,11 @@
6650 static int runOneSqlLine(ShellState *p, char *zSql, FILE *in, int startline){
6651 int rc;
6652 char *zErrMsg = 0;
6653
6654 open_db(p, 0);
6655 if( ShellHasFlag(p,SHFLG_Backslash) ) resolve_backslashes(zSql);
6656 BEGIN_TIMER;
6657 rc = shell_exec(p->db, zSql, shell_callback, p, &zErrMsg);
6658 END_TIMER;
6659 if( rc || zErrMsg ){
6660 char zPrefix[100];
@@ -5464,11 +6670,11 @@
6670 zErrMsg = 0;
6671 }else{
6672 utf8_printf(stderr, "%s %s\n", zPrefix, sqlite3_errmsg(p->db));
6673 }
6674 return 1;
6675 }else if( ShellHasFlag(p, SHFLG_CountChanges) ){
6676 raw_printf(p->out, "changes: %3d total_changes: %d\n",
6677 sqlite3_changes(p->db), sqlite3_total_changes(p->db));
6678 }
6679 return 0;
6680 }
@@ -5507,15 +6713,15 @@
6713 if( in!=0 ) break;
6714 seenInterrupt = 0;
6715 }
6716 lineno++;
6717 if( nSql==0 && _all_whitespace(zLine) ){
6718 if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zLine);
6719 continue;
6720 }
6721 if( zLine && zLine[0]=='.' && nSql==0 ){
6722 if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zLine);
6723 rc = do_meta_command(zLine, p);
6724 if( rc==2 ){ /* exit requested */
6725 break;
6726 }else if( rc ){
6727 errCnt++;
@@ -5554,11 +6760,11 @@
6760 if( p->outCount ){
6761 output_reset(p);
6762 p->outCount = 0;
6763 }
6764 }else if( nSql && _all_whitespace(zSql) ){
6765 if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zSql);
6766 nSql = 0;
6767 }
6768 }
6769 if( nSql && !_all_whitespace(zSql) ){
6770 runOneSqlLine(p, zSql, in, startline);
@@ -6023,11 +7229,11 @@
7229 }else if( strcmp(z,"-header")==0 ){
7230 data.showHeader = 1;
7231 }else if( strcmp(z,"-noheader")==0 ){
7232 data.showHeader = 0;
7233 }else if( strcmp(z,"-echo")==0 ){
7234 ShellSetFlag(&data, SHFLG_Echo);
7235 }else if( strcmp(z,"-eqp")==0 ){
7236 data.autoEQP = 1;
7237 }else if( strcmp(z,"-eqpfull")==0 ){
7238 data.autoEQP = 2;
7239 }else if( strcmp(z,"-stats")==0 ){
@@ -6038,11 +7244,11 @@
7244 /* Undocumented command-line option: -backslash
7245 ** Causes C-style backslash escapes to be evaluated in SQL statements
7246 ** prior to sending the SQL into SQLite. Useful for injecting
7247 ** crazy bytes in the middle of SQL statements for testing and debugging.
7248 */
7249 ShellSetFlag(&data, SHFLG_Backslash);
7250 }else if( strcmp(z,"-bail")==0 ){
7251 bail_on_error = 1;
7252 }else if( strcmp(z,"-version")==0 ){
7253 printf("%s %s\n", sqlite3_libversion(), sqlite3_sourceid());
7254 return 0;
7255
M src/shell.c
+1454 -248
--- src/shell.c
+++ src/shell.c
@@ -452,32 +452,10 @@
452452
 while( IsDigit(*z) ){ z++; }
453453
 if( realnum ) *realnum = 1;
454454
 }
455455
 return *z==0;
456456
 }
457
-
458
-/*
459
-** A global char* and an SQL function to access its current value
460
-** from within an SQL statement. This program used to use the
461
-** sqlite_exec_printf() API to substitue a string into an SQL statement.
462
-** The correct way to do this with sqlite3 is to use the bind API, but
463
-** since the shell is built around the callback paradigm it would be a lot
464
-** of work. Instead just use this hack, which is quite harmless.
465
-*/
466
-static const char *zShellStatic = 0;
467
-static void shellstaticFunc(
468
- sqlite3_context *context,
469
- int argc,
470
- sqlite3_value **argv
471
-){
472
- assert( 0==argc );
473
- assert( zShellStatic );
474
- UNUSED_PARAMETER(argc);
475
- UNUSED_PARAMETER(argv);
476
- sqlite3_result_text(context, zShellStatic, -1, SQLITE_STATIC);
477
-}
478
-
479457
480458
 /*
481459
 ** Compute a string length that is limited to what can be stored in
482460
 ** lower 30 bits of a 32-bit signed integer.
483461
 */
@@ -575,10 +553,783 @@
575553
 if( zResult && *zResult ) shell_add_history(zResult);
576554
 #endif
577555
 }
578556
 return zResult;
579557
 }
558
+/*
559
+** A variable length string to which one can append text.
560
+*/
561
+typedef struct ShellText ShellText;
562
+struct ShellText {
563
+ char *z;
564
+ int n;
565
+ int nAlloc;
566
+};
567
+
568
+/*
569
+** Initialize and destroy a ShellText object
570
+*/
571
+static void initText(ShellText *p){
572
+ memset(p, 0, sizeof(*p));
573
+}
574
+static void freeText(ShellText *p){
575
+ free(p->z);
576
+ initText(p);
577
+}
578
+
579
+/* zIn is either a pointer to a NULL-terminated string in memory obtained
580
+** from malloc(), or a NULL pointer. The string pointed to by zAppend is
581
+** added to zIn, and the result returned in memory obtained from malloc().
582
+** zIn, if it was not NULL, is freed.
583
+**
584
+** If the third argument, quote, is not '\0', then it is used as a
585
+** quote character for zAppend.
586
+*/
587
+static void appendText(ShellText *p, char const *zAppend, char quote){
588
+ int len;
589
+ int i;
590
+ int nAppend = strlen30(zAppend);
591
+
592
+ len = nAppend+p->n+1;
593
+ if( quote ){
594
+ len += 2;
595
+ for(i=0; i<nAppend; i++){
596
+ if( zAppend[i]==quote ) len++;
597
+ }
598
+ }
599
+
600
+ if( p->n+len>=p->nAlloc ){
601
+ p->nAlloc = p->nAlloc*2 + len + 20;
602
+ p->z = realloc(p->z, p->nAlloc);
603
+ if( p->z==0 ){
604
+ memset(p, 0, sizeof(*p));
605
+ return;
606
+ }
607
+ }
608
+
609
+ if( quote ){
610
+ char *zCsr = p->z+p->n;
611
+ *zCsr++ = quote;
612
+ for(i=0; i<nAppend; i++){
613
+ *zCsr++ = zAppend[i];
614
+ if( zAppend[i]==quote ) *zCsr++ = quote;
615
+ }
616
+ *zCsr++ = quote;
617
+ p->n = (int)(zCsr - p->z);
618
+ *zCsr = '\0';
619
+ }else{
620
+ memcpy(p->z+p->n, zAppend, nAppend);
621
+ p->n += nAppend;
622
+ p->z[p->n] = '\0';
623
+ }
624
+}
625
+
626
+/*
627
+** Attempt to determine if identifier zName needs to be quoted, either
628
+** because it contains non-alphanumeric characters, or because it is an
629
+** SQLite keyword. Be conservative in this estimate: When in doubt assume
630
+** that quoting is required.
631
+**
632
+** Return '"' if quoting is required. Return 0 if no quoting is required.
633
+*/
634
+static char quoteChar(const char *zName){
635
+ /* All SQLite keywords, in alphabetical order */
636
+ static const char *azKeywords[] = {
637
+ "ABORT", "ACTION", "ADD", "AFTER", "ALL", "ALTER", "ANALYZE", "AND", "AS",
638
+ "ASC", "ATTACH", "AUTOINCREMENT", "BEFORE", "BEGIN", "BETWEEN", "BY",
639
+ "CASCADE", "CASE", "CAST", "CHECK", "COLLATE", "COLUMN", "COMMIT",
640
+ "CONFLICT", "CONSTRAINT", "CREATE", "CROSS", "CURRENT_DATE",
641
+ "CURRENT_TIME", "CURRENT_TIMESTAMP", "DATABASE", "DEFAULT", "DEFERRABLE",
642
+ "DEFERRED", "DELETE", "DESC", "DETACH", "DISTINCT", "DROP", "EACH",
643
+ "ELSE", "END", "ESCAPE", "EXCEPT", "EXCLUSIVE", "EXISTS", "EXPLAIN",
644
+ "FAIL", "FOR", "FOREIGN", "FROM", "FULL", "GLOB", "GROUP", "HAVING", "IF",
645
+ "IGNORE", "IMMEDIATE", "IN", "INDEX", "INDEXED", "INITIALLY", "INNER",
646
+ "INSERT", "INSTEAD", "INTERSECT", "INTO", "IS", "ISNULL", "JOIN", "KEY",
647
+ "LEFT", "LIKE", "LIMIT", "MATCH", "NATURAL", "NO", "NOT", "NOTNULL",
648
+ "NULL", "OF", "OFFSET", "ON", "OR", "ORDER", "OUTER", "PLAN", "PRAGMA",
649
+ "PRIMARY", "QUERY", "RAISE", "RECURSIVE", "REFERENCES", "REGEXP",
650
+ "REINDEX", "RELEASE", "RENAME", "REPLACE", "RESTRICT", "RIGHT",
651
+ "ROLLBACK", "ROW", "SAVEPOINT", "SELECT", "SET", "TABLE", "TEMP",
652
+ "TEMPORARY", "THEN", "TO", "TRANSACTION", "TRIGGER", "UNION", "UNIQUE",
653
+ "UPDATE", "USING", "VACUUM", "VALUES", "VIEW", "VIRTUAL", "WHEN", "WHERE",
654
+ "WITH", "WITHOUT",
655
+ };
656
+ int i, lwr, upr, mid, c;
657
+ if( !isalpha((unsigned char)zName[0]) && zName[0]!='_' ) return '"';
658
+ for(i=0; zName[i]; i++){
659
+ if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ) return '"';
660
+ }
661
+ lwr = 0;
662
+ upr = sizeof(azKeywords)/sizeof(azKeywords[0]) - 1;
663
+ while( lwr<=upr ){
664
+ mid = (lwr+upr)/2;
665
+ c = sqlite3_stricmp(azKeywords[mid], zName);
666
+ if( c==0 ) return '"';
667
+ if( c<0 ){
668
+ lwr = mid+1;
669
+ }else{
670
+ upr = mid-1;
671
+ }
672
+ }
673
+ return 0;
674
+}
675
+
676
+/******************************************************************************
677
+** SHA3 hash implementation copied from ../ext/misc/shathree.c
678
+*/
679
+typedef sqlite3_uint64 u64;
680
+/*
681
+** Macros to determine whether the machine is big or little endian,
682
+** and whether or not that determination is run-time or compile-time.
683
+**
684
+** For best performance, an attempt is made to guess at the byte-order
685
+** using C-preprocessor macros. If that is unsuccessful, or if
686
+** -DSHA3_BYTEORDER=0 is set, then byte-order is determined
687
+** at run-time.
688
+*/
689
+#ifndef SHA3_BYTEORDER
690
+# if defined(i386) || defined(__i386__) || defined(_M_IX86) || \
691
+ defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) || \
692
+ defined(_M_AMD64) || defined(_M_ARM) || defined(__x86) || \
693
+ defined(__arm__)
694
+# define SHA3_BYTEORDER 1234
695
+# elif defined(sparc) || defined(__ppc__)
696
+# define SHA3_BYTEORDER 4321
697
+# else
698
+# define SHA3_BYTEORDER 0
699
+# endif
700
+#endif
701
+
702
+
703
+/*
704
+** State structure for a SHA3 hash in progress
705
+*/
706
+typedef struct SHA3Context SHA3Context;
707
+struct SHA3Context {
708
+ union {
709
+ u64 s[25]; /* Keccak state. 5x5 lines of 64 bits each */
710
+ unsigned char x[1600]; /* ... or 1600 bytes */
711
+ } u;
712
+ unsigned nRate; /* Bytes of input accepted per Keccak iteration */
713
+ unsigned nLoaded; /* Input bytes loaded into u.x[] so far this cycle */
714
+ unsigned ixMask; /* Insert next input into u.x[nLoaded^ixMask]. */
715
+};
716
+
717
+/*
718
+** A single step of the Keccak mixing function for a 1600-bit state
719
+*/
720
+static void KeccakF1600Step(SHA3Context *p){
721
+ int i;
722
+ u64 B0, B1, B2, B3, B4;
723
+ u64 C0, C1, C2, C3, C4;
724
+ u64 D0, D1, D2, D3, D4;
725
+ static const u64 RC[] = {
726
+ 0x0000000000000001ULL, 0x0000000000008082ULL,
727
+ 0x800000000000808aULL, 0x8000000080008000ULL,
728
+ 0x000000000000808bULL, 0x0000000080000001ULL,
729
+ 0x8000000080008081ULL, 0x8000000000008009ULL,
730
+ 0x000000000000008aULL, 0x0000000000000088ULL,
731
+ 0x0000000080008009ULL, 0x000000008000000aULL,
732
+ 0x000000008000808bULL, 0x800000000000008bULL,
733
+ 0x8000000000008089ULL, 0x8000000000008003ULL,
734
+ 0x8000000000008002ULL, 0x8000000000000080ULL,
735
+ 0x000000000000800aULL, 0x800000008000000aULL,
736
+ 0x8000000080008081ULL, 0x8000000000008080ULL,
737
+ 0x0000000080000001ULL, 0x8000000080008008ULL
738
+ };
739
+# define A00 (p->u.s[0])
740
+# define A01 (p->u.s[1])
741
+# define A02 (p->u.s[2])
742
+# define A03 (p->u.s[3])
743
+# define A04 (p->u.s[4])
744
+# define A10 (p->u.s[5])
745
+# define A11 (p->u.s[6])
746
+# define A12 (p->u.s[7])
747
+# define A13 (p->u.s[8])
748
+# define A14 (p->u.s[9])
749
+# define A20 (p->u.s[10])
750
+# define A21 (p->u.s[11])
751
+# define A22 (p->u.s[12])
752
+# define A23 (p->u.s[13])
753
+# define A24 (p->u.s[14])
754
+# define A30 (p->u.s[15])
755
+# define A31 (p->u.s[16])
756
+# define A32 (p->u.s[17])
757
+# define A33 (p->u.s[18])
758
+# define A34 (p->u.s[19])
759
+# define A40 (p->u.s[20])
760
+# define A41 (p->u.s[21])
761
+# define A42 (p->u.s[22])
762
+# define A43 (p->u.s[23])
763
+# define A44 (p->u.s[24])
764
+# define ROL64(a,x) ((a<<x)|(a>>(64-x)))
765
+
766
+ for(i=0; i<24; i+=4){
767
+ C0 = A00^A10^A20^A30^A40;
768
+ C1 = A01^A11^A21^A31^A41;
769
+ C2 = A02^A12^A22^A32^A42;
770
+ C3 = A03^A13^A23^A33^A43;
771
+ C4 = A04^A14^A24^A34^A44;
772
+ D0 = C4^ROL64(C1, 1);
773
+ D1 = C0^ROL64(C2, 1);
774
+ D2 = C1^ROL64(C3, 1);
775
+ D3 = C2^ROL64(C4, 1);
776
+ D4 = C3^ROL64(C0, 1);
777
+
778
+ B0 = (A00^D0);
779
+ B1 = ROL64((A11^D1), 44);
780
+ B2 = ROL64((A22^D2), 43);
781
+ B3 = ROL64((A33^D3), 21);
782
+ B4 = ROL64((A44^D4), 14);
783
+ A00 = B0 ^((~B1)& B2 );
784
+ A00 ^= RC[i];
785
+ A11 = B1 ^((~B2)& B3 );
786
+ A22 = B2 ^((~B3)& B4 );
787
+ A33 = B3 ^((~B4)& B0 );
788
+ A44 = B4 ^((~B0)& B1 );
789
+
790
+ B2 = ROL64((A20^D0), 3);
791
+ B3 = ROL64((A31^D1), 45);
792
+ B4 = ROL64((A42^D2), 61);
793
+ B0 = ROL64((A03^D3), 28);
794
+ B1 = ROL64((A14^D4), 20);
795
+ A20 = B0 ^((~B1)& B2 );
796
+ A31 = B1 ^((~B2)& B3 );
797
+ A42 = B2 ^((~B3)& B4 );
798
+ A03 = B3 ^((~B4)& B0 );
799
+ A14 = B4 ^((~B0)& B1 );
800
+
801
+ B4 = ROL64((A40^D0), 18);
802
+ B0 = ROL64((A01^D1), 1);
803
+ B1 = ROL64((A12^D2), 6);
804
+ B2 = ROL64((A23^D3), 25);
805
+ B3 = ROL64((A34^D4), 8);
806
+ A40 = B0 ^((~B1)& B2 );
807
+ A01 = B1 ^((~B2)& B3 );
808
+ A12 = B2 ^((~B3)& B4 );
809
+ A23 = B3 ^((~B4)& B0 );
810
+ A34 = B4 ^((~B0)& B1 );
811
+
812
+ B1 = ROL64((A10^D0), 36);
813
+ B2 = ROL64((A21^D1), 10);
814
+ B3 = ROL64((A32^D2), 15);
815
+ B4 = ROL64((A43^D3), 56);
816
+ B0 = ROL64((A04^D4), 27);
817
+ A10 = B0 ^((~B1)& B2 );
818
+ A21 = B1 ^((~B2)& B3 );
819
+ A32 = B2 ^((~B3)& B4 );
820
+ A43 = B3 ^((~B4)& B0 );
821
+ A04 = B4 ^((~B0)& B1 );
822
+
823
+ B3 = ROL64((A30^D0), 41);
824
+ B4 = ROL64((A41^D1), 2);
825
+ B0 = ROL64((A02^D2), 62);
826
+ B1 = ROL64((A13^D3), 55);
827
+ B2 = ROL64((A24^D4), 39);
828
+ A30 = B0 ^((~B1)& B2 );
829
+ A41 = B1 ^((~B2)& B3 );
830
+ A02 = B2 ^((~B3)& B4 );
831
+ A13 = B3 ^((~B4)& B0 );
832
+ A24 = B4 ^((~B0)& B1 );
833
+
834
+ C0 = A00^A20^A40^A10^A30;
835
+ C1 = A11^A31^A01^A21^A41;
836
+ C2 = A22^A42^A12^A32^A02;
837
+ C3 = A33^A03^A23^A43^A13;
838
+ C4 = A44^A14^A34^A04^A24;
839
+ D0 = C4^ROL64(C1, 1);
840
+ D1 = C0^ROL64(C2, 1);
841
+ D2 = C1^ROL64(C3, 1);
842
+ D3 = C2^ROL64(C4, 1);
843
+ D4 = C3^ROL64(C0, 1);
844
+
845
+ B0 = (A00^D0);
846
+ B1 = ROL64((A31^D1), 44);
847
+ B2 = ROL64((A12^D2), 43);
848
+ B3 = ROL64((A43^D3), 21);
849
+ B4 = ROL64((A24^D4), 14);
850
+ A00 = B0 ^((~B1)& B2 );
851
+ A00 ^= RC[i+1];
852
+ A31 = B1 ^((~B2)& B3 );
853
+ A12 = B2 ^((~B3)& B4 );
854
+ A43 = B3 ^((~B4)& B0 );
855
+ A24 = B4 ^((~B0)& B1 );
856
+
857
+ B2 = ROL64((A40^D0), 3);
858
+ B3 = ROL64((A21^D1), 45);
859
+ B4 = ROL64((A02^D2), 61);
860
+ B0 = ROL64((A33^D3), 28);
861
+ B1 = ROL64((A14^D4), 20);
862
+ A40 = B0 ^((~B1)& B2 );
863
+ A21 = B1 ^((~B2)& B3 );
864
+ A02 = B2 ^((~B3)& B4 );
865
+ A33 = B3 ^((~B4)& B0 );
866
+ A14 = B4 ^((~B0)& B1 );
867
+
868
+ B4 = ROL64((A30^D0), 18);
869
+ B0 = ROL64((A11^D1), 1);
870
+ B1 = ROL64((A42^D2), 6);
871
+ B2 = ROL64((A23^D3), 25);
872
+ B3 = ROL64((A04^D4), 8);
873
+ A30 = B0 ^((~B1)& B2 );
874
+ A11 = B1 ^((~B2)& B3 );
875
+ A42 = B2 ^((~B3)& B4 );
876
+ A23 = B3 ^((~B4)& B0 );
877
+ A04 = B4 ^((~B0)& B1 );
878
+
879
+ B1 = ROL64((A20^D0), 36);
880
+ B2 = ROL64((A01^D1), 10);
881
+ B3 = ROL64((A32^D2), 15);
882
+ B4 = ROL64((A13^D3), 56);
883
+ B0 = ROL64((A44^D4), 27);
884
+ A20 = B0 ^((~B1)& B2 );
885
+ A01 = B1 ^((~B2)& B3 );
886
+ A32 = B2 ^((~B3)& B4 );
887
+ A13 = B3 ^((~B4)& B0 );
888
+ A44 = B4 ^((~B0)& B1 );
889
+
890
+ B3 = ROL64((A10^D0), 41);
891
+ B4 = ROL64((A41^D1), 2);
892
+ B0 = ROL64((A22^D2), 62);
893
+ B1 = ROL64((A03^D3), 55);
894
+ B2 = ROL64((A34^D4), 39);
895
+ A10 = B0 ^((~B1)& B2 );
896
+ A41 = B1 ^((~B2)& B3 );
897
+ A22 = B2 ^((~B3)& B4 );
898
+ A03 = B3 ^((~B4)& B0 );
899
+ A34 = B4 ^((~B0)& B1 );
900
+
901
+ C0 = A00^A40^A30^A20^A10;
902
+ C1 = A31^A21^A11^A01^A41;
903
+ C2 = A12^A02^A42^A32^A22;
904
+ C3 = A43^A33^A23^A13^A03;
905
+ C4 = A24^A14^A04^A44^A34;
906
+ D0 = C4^ROL64(C1, 1);
907
+ D1 = C0^ROL64(C2, 1);
908
+ D2 = C1^ROL64(C3, 1);
909
+ D3 = C2^ROL64(C4, 1);
910
+ D4 = C3^ROL64(C0, 1);
911
+
912
+ B0 = (A00^D0);
913
+ B1 = ROL64((A21^D1), 44);
914
+ B2 = ROL64((A42^D2), 43);
915
+ B3 = ROL64((A13^D3), 21);
916
+ B4 = ROL64((A34^D4), 14);
917
+ A00 = B0 ^((~B1)& B2 );
918
+ A00 ^= RC[i+2];
919
+ A21 = B1 ^((~B2)& B3 );
920
+ A42 = B2 ^((~B3)& B4 );
921
+ A13 = B3 ^((~B4)& B0 );
922
+ A34 = B4 ^((~B0)& B1 );
923
+
924
+ B2 = ROL64((A30^D0), 3);
925
+ B3 = ROL64((A01^D1), 45);
926
+ B4 = ROL64((A22^D2), 61);
927
+ B0 = ROL64((A43^D3), 28);
928
+ B1 = ROL64((A14^D4), 20);
929
+ A30 = B0 ^((~B1)& B2 );
930
+ A01 = B1 ^((~B2)& B3 );
931
+ A22 = B2 ^((~B3)& B4 );
932
+ A43 = B3 ^((~B4)& B0 );
933
+ A14 = B4 ^((~B0)& B1 );
934
+
935
+ B4 = ROL64((A10^D0), 18);
936
+ B0 = ROL64((A31^D1), 1);
937
+ B1 = ROL64((A02^D2), 6);
938
+ B2 = ROL64((A23^D3), 25);
939
+ B3 = ROL64((A44^D4), 8);
940
+ A10 = B0 ^((~B1)& B2 );
941
+ A31 = B1 ^((~B2)& B3 );
942
+ A02 = B2 ^((~B3)& B4 );
943
+ A23 = B3 ^((~B4)& B0 );
944
+ A44 = B4 ^((~B0)& B1 );
945
+
946
+ B1 = ROL64((A40^D0), 36);
947
+ B2 = ROL64((A11^D1), 10);
948
+ B3 = ROL64((A32^D2), 15);
949
+ B4 = ROL64((A03^D3), 56);
950
+ B0 = ROL64((A24^D4), 27);
951
+ A40 = B0 ^((~B1)& B2 );
952
+ A11 = B1 ^((~B2)& B3 );
953
+ A32 = B2 ^((~B3)& B4 );
954
+ A03 = B3 ^((~B4)& B0 );
955
+ A24 = B4 ^((~B0)& B1 );
956
+
957
+ B3 = ROL64((A20^D0), 41);
958
+ B4 = ROL64((A41^D1), 2);
959
+ B0 = ROL64((A12^D2), 62);
960
+ B1 = ROL64((A33^D3), 55);
961
+ B2 = ROL64((A04^D4), 39);
962
+ A20 = B0 ^((~B1)& B2 );
963
+ A41 = B1 ^((~B2)& B3 );
964
+ A12 = B2 ^((~B3)& B4 );
965
+ A33 = B3 ^((~B4)& B0 );
966
+ A04 = B4 ^((~B0)& B1 );
967
+
968
+ C0 = A00^A30^A10^A40^A20;
969
+ C1 = A21^A01^A31^A11^A41;
970
+ C2 = A42^A22^A02^A32^A12;
971
+ C3 = A13^A43^A23^A03^A33;
972
+ C4 = A34^A14^A44^A24^A04;
973
+ D0 = C4^ROL64(C1, 1);
974
+ D1 = C0^ROL64(C2, 1);
975
+ D2 = C1^ROL64(C3, 1);
976
+ D3 = C2^ROL64(C4, 1);
977
+ D4 = C3^ROL64(C0, 1);
978
+
979
+ B0 = (A00^D0);
980
+ B1 = ROL64((A01^D1), 44);
981
+ B2 = ROL64((A02^D2), 43);
982
+ B3 = ROL64((A03^D3), 21);
983
+ B4 = ROL64((A04^D4), 14);
984
+ A00 = B0 ^((~B1)& B2 );
985
+ A00 ^= RC[i+3];
986
+ A01 = B1 ^((~B2)& B3 );
987
+ A02 = B2 ^((~B3)& B4 );
988
+ A03 = B3 ^((~B4)& B0 );
989
+ A04 = B4 ^((~B0)& B1 );
990
+
991
+ B2 = ROL64((A10^D0), 3);
992
+ B3 = ROL64((A11^D1), 45);
993
+ B4 = ROL64((A12^D2), 61);
994
+ B0 = ROL64((A13^D3), 28);
995
+ B1 = ROL64((A14^D4), 20);
996
+ A10 = B0 ^((~B1)& B2 );
997
+ A11 = B1 ^((~B2)& B3 );
998
+ A12 = B2 ^((~B3)& B4 );
999
+ A13 = B3 ^((~B4)& B0 );
1000
+ A14 = B4 ^((~B0)& B1 );
1001
+
1002
+ B4 = ROL64((A20^D0), 18);
1003
+ B0 = ROL64((A21^D1), 1);
1004
+ B1 = ROL64((A22^D2), 6);
1005
+ B2 = ROL64((A23^D3), 25);
1006
+ B3 = ROL64((A24^D4), 8);
1007
+ A20 = B0 ^((~B1)& B2 );
1008
+ A21 = B1 ^((~B2)& B3 );
1009
+ A22 = B2 ^((~B3)& B4 );
1010
+ A23 = B3 ^((~B4)& B0 );
1011
+ A24 = B4 ^((~B0)& B1 );
1012
+
1013
+ B1 = ROL64((A30^D0), 36);
1014
+ B2 = ROL64((A31^D1), 10);
1015
+ B3 = ROL64((A32^D2), 15);
1016
+ B4 = ROL64((A33^D3), 56);
1017
+ B0 = ROL64((A34^D4), 27);
1018
+ A30 = B0 ^((~B1)& B2 );
1019
+ A31 = B1 ^((~B2)& B3 );
1020
+ A32 = B2 ^((~B3)& B4 );
1021
+ A33 = B3 ^((~B4)& B0 );
1022
+ A34 = B4 ^((~B0)& B1 );
1023
+
1024
+ B3 = ROL64((A40^D0), 41);
1025
+ B4 = ROL64((A41^D1), 2);
1026
+ B0 = ROL64((A42^D2), 62);
1027
+ B1 = ROL64((A43^D3), 55);
1028
+ B2 = ROL64((A44^D4), 39);
1029
+ A40 = B0 ^((~B1)& B2 );
1030
+ A41 = B1 ^((~B2)& B3 );
1031
+ A42 = B2 ^((~B3)& B4 );
1032
+ A43 = B3 ^((~B4)& B0 );
1033
+ A44 = B4 ^((~B0)& B1 );
1034
+ }
1035
+}
1036
+
1037
+/*
1038
+** Initialize a new hash. iSize determines the size of the hash
1039
+** in bits and should be one of 224, 256, 384, or 512. Or iSize
1040
+** can be zero to use the default hash size of 256 bits.
1041
+*/
1042
+static void SHA3Init(SHA3Context *p, int iSize){
1043
+ memset(p, 0, sizeof(*p));
1044
+ if( iSize>=128 && iSize<=512 ){
1045
+ p->nRate = (1600 - ((iSize + 31)&~31)*2)/8;
1046
+ }else{
1047
+ p->nRate = (1600 - 2*256)/8;
1048
+ }
1049
+#if SHA3_BYTEORDER==1234
1050
+ /* Known to be little-endian at compile-time. No-op */
1051
+#elif SHA3_BYTEORDER==4321
1052
+ p->ixMask = 7; /* Big-endian */
1053
+#else
1054
+ {
1055
+ static unsigned int one = 1;
1056
+ if( 1==*(unsigned char*)&one ){
1057
+ /* Little endian. No byte swapping. */
1058
+ p->ixMask = 0;
1059
+ }else{
1060
+ /* Big endian. Byte swap. */
1061
+ p->ixMask = 7;
1062
+ }
1063
+ }
1064
+#endif
1065
+}
1066
+
1067
+/*
1068
+** Make consecutive calls to the SHA3Update function to add new content
1069
+** to the hash
1070
+*/
1071
+static void SHA3Update(
1072
+ SHA3Context *p,
1073
+ const unsigned char *aData,
1074
+ unsigned int nData
1075
+){
1076
+ unsigned int i = 0;
1077
+#if SHA3_BYTEORDER==1234
1078
+ if( (p->nLoaded % 8)==0 && ((aData - (const unsigned char*)0)&7)==0 ){
1079
+ for(; i+7<nData; i+=8){
1080
+ p->u.s[p->nLoaded/8] ^= *(u64*)&aData[i];
1081
+ p->nLoaded += 8;
1082
+ if( p->nLoaded>=p->nRate ){
1083
+ KeccakF1600Step(p);
1084
+ p->nLoaded = 0;
1085
+ }
1086
+ }
1087
+ }
1088
+#endif
1089
+ for(; i<nData; i++){
1090
+#if SHA3_BYTEORDER==1234
1091
+ p->u.x[p->nLoaded] ^= aData[i];
1092
+#elif SHA3_BYTEORDER==4321
1093
+ p->u.x[p->nLoaded^0x07] ^= aData[i];
1094
+#else
1095
+ p->u.x[p->nLoaded^p->ixMask] ^= aData[i];
1096
+#endif
1097
+ p->nLoaded++;
1098
+ if( p->nLoaded==p->nRate ){
1099
+ KeccakF1600Step(p);
1100
+ p->nLoaded = 0;
1101
+ }
1102
+ }
1103
+}
1104
+
1105
+/*
1106
+** After all content has been added, invoke SHA3Final() to compute
1107
+** the final hash. The function returns a pointer to the binary
1108
+** hash value.
1109
+*/
1110
+static unsigned char *SHA3Final(SHA3Context *p){
1111
+ unsigned int i;
1112
+ if( p->nLoaded==p->nRate-1 ){
1113
+ const unsigned char c1 = 0x86;
1114
+ SHA3Update(p, &c1, 1);
1115
+ }else{
1116
+ const unsigned char c2 = 0x06;
1117
+ const unsigned char c3 = 0x80;
1118
+ SHA3Update(p, &c2, 1);
1119
+ p->nLoaded = p->nRate - 1;
1120
+ SHA3Update(p, &c3, 1);
1121
+ }
1122
+ for(i=0; i<p->nRate; i++){
1123
+ p->u.x[i+p->nRate] = p->u.x[i^p->ixMask];
1124
+ }
1125
+ return &p->u.x[p->nRate];
1126
+}
1127
+
1128
+/*
1129
+** Implementation of the sha3(X,SIZE) function.
1130
+**
1131
+** Return a BLOB which is the SIZE-bit SHA3 hash of X. The default
1132
+** size is 256. If X is a BLOB, it is hashed as is.
1133
+** For all other non-NULL types of input, X is converted into a UTF-8 string
1134
+** and the string is hashed without the trailing 0x00 terminator. The hash
1135
+** of a NULL value is NULL.
1136
+*/
1137
+static void sha3Func(
1138
+ sqlite3_context *context,
1139
+ int argc,
1140
+ sqlite3_value **argv
1141
+){
1142
+ SHA3Context cx;
1143
+ int eType = sqlite3_value_type(argv[0]);
1144
+ int nByte = sqlite3_value_bytes(argv[0]);
1145
+ int iSize;
1146
+ if( argc==1 ){
1147
+ iSize = 256;
1148
+ }else{
1149
+ iSize = sqlite3_value_int(argv[1]);
1150
+ if( iSize!=224 && iSize!=256 && iSize!=384 && iSize!=512 ){
1151
+ sqlite3_result_error(context, "SHA3 size should be one of: 224 256 "
1152
+ "384 512", -1);
1153
+ return;
1154
+ }
1155
+ }
1156
+ if( eType==SQLITE_NULL ) return;
1157
+ SHA3Init(&cx, iSize);
1158
+ if( eType==SQLITE_BLOB ){
1159
+ SHA3Update(&cx, sqlite3_value_blob(argv[0]), nByte);
1160
+ }else{
1161
+ SHA3Update(&cx, sqlite3_value_text(argv[0]), nByte);
1162
+ }
1163
+ sqlite3_result_blob(context, SHA3Final(&cx), iSize/8, SQLITE_TRANSIENT);
1164
+}
1165
+
1166
+/* Compute a string using sqlite3_vsnprintf() with a maximum length
1167
+** of 50 bytes and add it to the hash.
1168
+*/
1169
+static void hash_step_vformat(
1170
+ SHA3Context *p, /* Add content to this context */
1171
+ const char *zFormat,
1172
+ ...
1173
+){
1174
+ va_list ap;
1175
+ int n;
1176
+ char zBuf[50];
1177
+ va_start(ap, zFormat);
1178
+ sqlite3_vsnprintf(sizeof(zBuf),zBuf,zFormat,ap);
1179
+ va_end(ap);
1180
+ n = (int)strlen(zBuf);
1181
+ SHA3Update(p, (unsigned char*)zBuf, n);
1182
+}
1183
+
1184
+/*
1185
+** Implementation of the sha3_query(SQL,SIZE) function.
1186
+**
1187
+** This function compiles and runs the SQL statement(s) given in the
1188
+** argument. The results are hashed using a SIZE-bit SHA3. The default
1189
+** size is 256.
1190
+**
1191
+** The format of the byte stream that is hashed is summarized as follows:
1192
+**
1193
+** S<n>:<sql>
1194
+** R
1195
+** N
1196
+** I<int>
1197
+** F<ieee-float>
1198
+** B<size>:<bytes>
1199
+** T<size>:<text>
1200
+**
1201
+** <sql> is the original SQL text for each statement run and <n> is
1202
+** the size of that text. The SQL text is UTF-8. A single R character
1203
+** occurs before the start of each row. N means a NULL value.
1204
+** I mean an 8-byte little-endian integer <int>. F is a floating point
1205
+** number with an 8-byte little-endian IEEE floating point value <ieee-float>.
1206
+** B means blobs of <size> bytes. T means text rendered as <size>
1207
+** bytes of UTF-8. The <n> and <size> values are expressed as an ASCII
1208
+** text integers.
1209
+**
1210
+** For each SQL statement in the X input, there is one S segment. Each
1211
+** S segment is followed by zero or more R segments, one for each row in the
1212
+** result set. After each R, there are one or more N, I, F, B, or T segments,
1213
+** one for each column in the result set. Segments are concatentated directly
1214
+** with no delimiters of any kind.
1215
+*/
1216
+static void sha3QueryFunc(
1217
+ sqlite3_context *context,
1218
+ int argc,
1219
+ sqlite3_value **argv
1220
+){
1221
+ sqlite3 *db = sqlite3_context_db_handle(context);
1222
+ const char *zSql = (const char*)sqlite3_value_text(argv[0]);
1223
+ sqlite3_stmt *pStmt = 0;
1224
+ int nCol; /* Number of columns in the result set */
1225
+ int i; /* Loop counter */
1226
+ int rc;
1227
+ int n;
1228
+ const char *z;
1229
+ SHA3Context cx;
1230
+ int iSize;
1231
+
1232
+ if( argc==1 ){
1233
+ iSize = 256;
1234
+ }else{
1235
+ iSize = sqlite3_value_int(argv[1]);
1236
+ if( iSize!=224 && iSize!=256 && iSize!=384 && iSize!=512 ){
1237
+ sqlite3_result_error(context, "SHA3 size should be one of: 224 256 "
1238
+ "384 512", -1);
1239
+ return;
1240
+ }
1241
+ }
1242
+ if( zSql==0 ) return;
1243
+ SHA3Init(&cx, iSize);
1244
+ while( zSql[0] ){
1245
+ rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zSql);
1246
+ if( rc ){
1247
+ char *zMsg = sqlite3_mprintf("error SQL statement [%s]: %s",
1248
+ zSql, sqlite3_errmsg(db));
1249
+ sqlite3_finalize(pStmt);
1250
+ sqlite3_result_error(context, zMsg, -1);
1251
+ sqlite3_free(zMsg);
1252
+ return;
1253
+ }
1254
+ if( !sqlite3_stmt_readonly(pStmt) ){
1255
+ char *zMsg = sqlite3_mprintf("non-query: [%s]", sqlite3_sql(pStmt));
1256
+ sqlite3_finalize(pStmt);
1257
+ sqlite3_result_error(context, zMsg, -1);
1258
+ sqlite3_free(zMsg);
1259
+ return;
1260
+ }
1261
+ nCol = sqlite3_column_count(pStmt);
1262
+ z = sqlite3_sql(pStmt);
1263
+ if( z==0 ){
1264
+ sqlite3_finalize(pStmt);
1265
+ continue;
1266
+ }
1267
+ n = (int)strlen(z);
1268
+ hash_step_vformat(&cx,"S%d:",n);
1269
+ SHA3Update(&cx,(unsigned char*)z,n);
1270
+
1271
+ /* Compute a hash over the result of the query */
1272
+ while( SQLITE_ROW==sqlite3_step(pStmt) ){
1273
+ SHA3Update(&cx,(const unsigned char*)"R",1);
1274
+ for(i=0; i<nCol; i++){
1275
+ switch( sqlite3_column_type(pStmt,i) ){
1276
+ case SQLITE_NULL: {
1277
+ SHA3Update(&cx, (const unsigned char*)"N",1);
1278
+ break;
1279
+ }
1280
+ case SQLITE_INTEGER: {
1281
+ sqlite3_uint64 u;
1282
+ int j;
1283
+ unsigned char x[9];
1284
+ sqlite3_int64 v = sqlite3_column_int64(pStmt,i);
1285
+ memcpy(&u, &v, 8);
1286
+ for(j=8; j>=1; j--){
1287
+ x[j] = u & 0xff;
1288
+ u >>= 8;
1289
+ }
1290
+ x[0] = 'I';
1291
+ SHA3Update(&cx, x, 9);
1292
+ break;
1293
+ }
1294
+ case SQLITE_FLOAT: {
1295
+ sqlite3_uint64 u;
1296
+ int j;
1297
+ unsigned char x[9];
1298
+ double r = sqlite3_column_double(pStmt,i);
1299
+ memcpy(&u, &r, 8);
1300
+ for(j=8; j>=1; j--){
1301
+ x[j] = u & 0xff;
1302
+ u >>= 8;
1303
+ }
1304
+ x[0] = 'F';
1305
+ SHA3Update(&cx,x,9);
1306
+ break;
1307
+ }
1308
+ case SQLITE_TEXT: {
1309
+ int n2 = sqlite3_column_bytes(pStmt, i);
1310
+ const unsigned char *z2 = sqlite3_column_text(pStmt, i);
1311
+ hash_step_vformat(&cx,"T%d:",n2);
1312
+ SHA3Update(&cx, z2, n2);
1313
+ break;
1314
+ }
1315
+ case SQLITE_BLOB: {
1316
+ int n2 = sqlite3_column_bytes(pStmt, i);
1317
+ const unsigned char *z2 = sqlite3_column_blob(pStmt, i);
1318
+ hash_step_vformat(&cx,"B%d:",n2);
1319
+ SHA3Update(&cx, z2, n2);
1320
+ break;
1321
+ }
1322
+ }
1323
+ }
1324
+ }
1325
+ sqlite3_finalize(pStmt);
1326
+ }
1327
+ sqlite3_result_blob(context, SHA3Final(&cx), iSize/8, SQLITE_TRANSIENT);
1328
+}
1329
+/* End of SHA3 hashing logic copy/pasted from ../ext/misc/shathree.c
1330
+********************************************************************************/
5801331
5811332
 #if defined(SQLITE_ENABLE_SESSION)
5821333
 /*
5831334
 ** State information for a single open session
5841335
 */
@@ -608,17 +1359,14 @@
6081359
 ** instance of the following structure.
6091360
 */
6101361
 typedef struct ShellState ShellState;
6111362
 struct ShellState {
6121363
 sqlite3 *db; /* The database */
613
- int echoOn; /* True to echo input commands */
6141364
 int autoExplain; /* Automatically turn on .explain mode */
6151365
 int autoEQP; /* Run EXPLAIN QUERY PLAN prior to seach SQL stmt */
6161366
 int statsOn; /* True to display memory stats before each finalize */
6171367
 int scanstatsOn; /* True to display scan stats before each finalize */
618
- int countChanges; /* True to display change counts */
619
- int backslashOn; /* Resolve C-style \x escapes in SQL input text */
6201368
 int outCount; /* Revert to stdout when reaching zero */
6211369
 int cnt; /* Number of records displayed so far */
6221370
 FILE *out; /* Write results here */
6231371
 FILE *traceOut; /* Output for sqlite3_trace() */
6241372
 int nErr; /* Number of errors seen */
@@ -653,13 +1401,24 @@
6531401
 };
6541402
6551403
 /*
6561404
 ** These are the allowed shellFlgs values
6571405
 */
658
-#define SHFLG_Scratch 0x00001 /* The --scratch option is used */
659
-#define SHFLG_Pagecache 0x00002 /* The --pagecache option is used */
660
-#define SHFLG_Lookaside 0x00004 /* Lookaside memory is used */
1406
+#define SHFLG_Scratch 0x00000001 /* The --scratch option is used */
1407
+#define SHFLG_Pagecache 0x00000002 /* The --pagecache option is used */
1408
+#define SHFLG_Lookaside 0x00000004 /* Lookaside memory is used */
1409
+#define SHFLG_Backslash 0x00000008 /* The --backslash option is used */
1410
+#define SHFLG_PreserveRowid 0x00000010 /* .dump preserves rowid values */
1411
+#define SHFLG_CountChanges 0x00000020 /* .changes setting */
1412
+#define SHFLG_Echo 0x00000040 /* .echo or --echo setting */
1413
+
1414
+/*
1415
+** Macros for testing and setting shellFlgs
1416
+*/
1417
+#define ShellHasFlag(P,X) (((P)->shellFlgs & (X))!=0)
1418
+#define ShellSetFlag(P,X) ((P)->shellFlgs|=(X))
1419
+#define ShellClearFlag(P,X) ((P)->shellFlgs&=(~(X)))
6611420
6621421
 /*
6631422
 ** These are the allowed modes.
6641423
 */
6651424
 #define MODE_Line 0 /* One column per line. Blank line between records */
@@ -729,36 +1488,56 @@
7291488
 raw_printf(out,"'");
7301489
 }
7311490
7321491
 /*
7331492
 ** Output the given string as a quoted string using SQL quoting conventions.
1493
+**
1494
+** The "\n" and "\r" characters are converted to char(10) and char(13)
1495
+** to prevent them from being transformed by end-of-line translators.
7341496
 */
7351497
 static void output_quoted_string(FILE *out, const char *z){
7361498
 int i;
737
- int nSingle = 0;
1499
+ char c;
7381500
 setBinaryMode(out, 1);
739
- for(i=0; z[i]; i++){
740
- if( z[i]=='\'' ) nSingle++;
741
- }
742
- if( nSingle==0 ){
1501
+ for(i=0; (c = z[i])!=0 && c!='\'' && c!='\n' && c!='\r'; i++){}
1502
+ if( c==0 ){
7431503
 utf8_printf(out,"'%s'",z);
7441504
 }else{
745
- raw_printf(out,"'");
1505
+ int inQuote = 0;
1506
+ int bStarted = 0;
7461507
 while( *z ){
747
- for(i=0; z[i] && z[i]!='\''; i++){}
748
- if( i==0 ){
749
- raw_printf(out,"''");
750
- z++;
751
- }else if( z[i]=='\'' ){
752
- utf8_printf(out,"%.*s''",i,z);
753
- z += i+1;
754
- }else{
755
- utf8_printf(out,"%s",z);
1508
+ for(i=0; (c = z[i])!=0 && c!='\n' && c!='\r' && c!='\''; i++){}
1509
+ if( c=='\'' ) i++;
1510
+ if( i ){
1511
+ if( !inQuote ){
1512
+ if( bStarted ) raw_printf(out, "||");
1513
+ raw_printf(out, "'");
1514
+ inQuote = 1;
1515
+ }
1516
+ utf8_printf(out, "%.*s", i, z);
1517
+ z += i;
1518
+ bStarted = 1;
1519
+ }
1520
+ if( c=='\'' ){
1521
+ raw_printf(out, "'");
1522
+ continue;
1523
+ }
1524
+ if( inQuote ){
1525
+ raw_printf(out, "'");
1526
+ inQuote = 0;
1527
+ }
1528
+ if( c==0 ){
7561529
 break;
7571530
 }
1531
+ for(i=0; (c = z[i])=='\r' || c=='\n'; i++){
1532
+ if( bStarted ) raw_printf(out, "||");
1533
+ raw_printf(out, "char(%d)", c);
1534
+ bStarted = 1;
1535
+ }
1536
+ z += i;
7581537
 }
759
- raw_printf(out,"'");
1538
+ if( inQuote ) raw_printf(out, "'");
7601539
 }
7611540
 setTextMode(out, 1);
7621541
 }
7631542
7641543
 /*
@@ -1246,13 +2025,17 @@
12462025
 if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){
12472026
 utf8_printf(p->out,"%sNULL",zSep);
12482027
 }else if( aiType && aiType[i]==SQLITE_TEXT ){
12492028
 if( zSep[0] ) utf8_printf(p->out,"%s",zSep);
12502029
 output_quoted_string(p->out, azArg[i]);
1251
- }else if( aiType && (aiType[i]==SQLITE_INTEGER
1252
- || aiType[i]==SQLITE_FLOAT) ){
2030
+ }else if( aiType && aiType[i]==SQLITE_INTEGER ){
12532031
 utf8_printf(p->out,"%s%s",zSep, azArg[i]);
2032
+ }else if( aiType && aiType[i]==SQLITE_FLOAT ){
2033
+ char z[50];
2034
+ double r = sqlite3_column_double(p->pStmt, i);
2035
+ sqlite3_snprintf(50,z,"%!.20g", r);
2036
+ raw_printf(p->out, "%s%s", zSep, z);
12542037
 }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){
12552038
 const void *pBlob = sqlite3_column_blob(p->pStmt, i);
12562039
 int nBlob = sqlite3_column_bytes(p->pStmt, i);
12572040
 if( zSep[0] ) utf8_printf(p->out,"%s",zSep);
12582041
 output_hex_blob(p->out, pBlob, nBlob);
@@ -1292,92 +2075,106 @@
12922075
 */
12932076
 static int callback(void *pArg, int nArg, char **azArg, char **azCol){
12942077
 /* since we don't have type info, call the shell_callback with a NULL value */
12952078
 return shell_callback(pArg, nArg, azArg, azCol, NULL);
12962079
 }
2080
+
2081
+/*
2082
+** This is the callback routine from sqlite3_exec() that appends all
2083
+** output onto the end of a ShellText object.
2084
+*/
2085
+static int captureOutputCallback(void *pArg, int nArg, char **azArg, char **az){
2086
+ ShellText *p = (ShellText*)pArg;
2087
+ int i;
2088
+ if( p->n ) appendText(p, "|", 0);
2089
+ for(i=0; i<nArg; i++){
2090
+ if( i ) appendText(p, ",", 0);
2091
+ if( azArg[i] ) appendText(p, azArg[i], 0);
2092
+ }
2093
+ return 0;
2094
+}
2095
+
2096
+/*
2097
+** Generate an appropriate SELFTEST table in the main database.
2098
+*/
2099
+static void createSelftestTable(ShellState *p){
2100
+ char *zErrMsg = 0;
2101
+ sqlite3_exec(p->db,
2102
+ "SAVEPOINT selftest_init;\n"
2103
+ "CREATE TABLE IF NOT EXISTS selftest(\n"
2104
+ " tno INTEGER PRIMARY KEY,\n" /* Test number */
2105
+ " op TEXT,\n" /* Operator: memo run */
2106
+ " cmd TEXT,\n" /* Command text */
2107
+ " ans TEXT\n" /* Desired answer */
2108
+ ");"
2109
+ "CREATE TEMP TABLE [_shell$self](op,cmd,ans);\n"
2110
+ "INSERT INTO [_shell$self](rowid,op,cmd)\n"
2111
+ " VALUES(coalesce((SELECT (max(tno)+100)/10 FROM selftest),10),\n"
2112
+ " 'memo','Tests generated by --init');\n"
2113
+ "INSERT INTO [_shell$self]\n"
2114
+ " SELECT 'run',\n"
2115
+ " 'SELECT hex(sha3_query(''SELECT type,name,tbl_name,sql "
2116
+ "FROM sqlite_master ORDER BY 2'',224))',\n"
2117
+ " hex(sha3_query('SELECT type,name,tbl_name,sql "
2118
+ "FROM sqlite_master ORDER BY 2',224));\n"
2119
+ "INSERT INTO [_shell$self]\n"
2120
+ " SELECT 'run',"
2121
+ " 'SELECT hex(sha3_query(''SELECT * FROM \"' ||"
2122
+ " printf('%w',name) || '\" NOT INDEXED'',224))',\n"
2123
+ " hex(sha3_query(printf('SELECT * FROM \"%w\" NOT INDEXED',name),224))\n"
2124
+ " FROM (\n"
2125
+ " SELECT name FROM sqlite_master\n"
2126
+ " WHERE type='table'\n"
2127
+ " AND name<>'selftest'\n"
2128
+ " AND coalesce(rootpage,0)>0\n"
2129
+ " )\n"
2130
+ " ORDER BY name;\n"
2131
+ "INSERT INTO [_shell$self]\n"
2132
+ " VALUES('run','PRAGMA integrity_check','ok');\n"
2133
+ "INSERT INTO selftest(tno,op,cmd,ans)"
2134
+ " SELECT rowid*10,op,cmd,ans FROM [_shell$self];\n"
2135
+ "DROP TABLE [_shell$self];"
2136
+ ,0,0,&zErrMsg);
2137
+ if( zErrMsg ){
2138
+ utf8_printf(stderr, "SELFTEST initialization failure: %s\n", zErrMsg);
2139
+ sqlite3_free(zErrMsg);
2140
+ }
2141
+ sqlite3_exec(p->db, "RELEASE selftest_init",0,0,0);
2142
+}
2143
+
12972144
12982145
 /*
12992146
 ** Set the destination table field of the ShellState structure to
13002147
 ** the name of the table given. Escape any quote characters in the
13012148
 ** table name.
13022149
 */
13032150
 static void set_table_name(ShellState *p, const char *zName){
13042151
 int i, n;
1305
- int needQuote;
2152
+ int cQuote;
13062153
 char *z;
13072154
13082155
 if( p->zDestTable ){
13092156
 free(p->zDestTable);
13102157
 p->zDestTable = 0;
13112158
 }
13122159
 if( zName==0 ) return;
1313
- needQuote = !isalpha((unsigned char)*zName) && *zName!='_';
1314
- for(i=n=0; zName[i]; i++, n++){
1315
- if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ){
1316
- needQuote = 1;
1317
- if( zName[i]=='\'' ) n++;
1318
- }
1319
- }
1320
- if( needQuote ) n += 2;
2160
+ cQuote = quoteChar(zName);
2161
+ n = strlen30(zName);
2162
+ if( cQuote ) n += 2;
13212163
 z = p->zDestTable = malloc( n+1 );
13222164
 if( z==0 ){
13232165
 raw_printf(stderr,"Error: out of memory\n");
13242166
 exit(1);
13252167
 }
13262168
 n = 0;
1327
- if( needQuote ) z[n++] = '\'';
2169
+ if( cQuote ) z[n++] = cQuote;
13282170
 for(i=0; zName[i]; i++){
13292171
 z[n++] = zName[i];
1330
- if( zName[i]=='\'' ) z[n++] = '\'';
1331
- }
1332
- if( needQuote ) z[n++] = '\'';
1333
- z[n] = 0;
1334
-}
1335
-
1336
-/* zIn is either a pointer to a NULL-terminated string in memory obtained
1337
-** from malloc(), or a NULL pointer. The string pointed to by zAppend is
1338
-** added to zIn, and the result returned in memory obtained from malloc().
1339
-** zIn, if it was not NULL, is freed.
1340
-**
1341
-** If the third argument, quote, is not '\0', then it is used as a
1342
-** quote character for zAppend.
1343
-*/
1344
-static char *appendText(char *zIn, char const *zAppend, char quote){
1345
- int len;
1346
- int i;
1347
- int nAppend = strlen30(zAppend);
1348
- int nIn = (zIn?strlen30(zIn):0);
1349
-
1350
- len = nAppend+nIn+1;
1351
- if( quote ){
1352
- len += 2;
1353
- for(i=0; i<nAppend; i++){
1354
- if( zAppend[i]==quote ) len++;
1355
- }
1356
- }
1357
-
1358
- zIn = (char *)realloc(zIn, len);
1359
- if( !zIn ){
1360
- return 0;
1361
- }
1362
-
1363
- if( quote ){
1364
- char *zCsr = &zIn[nIn];
1365
- *zCsr++ = quote;
1366
- for(i=0; i<nAppend; i++){
1367
- *zCsr++ = zAppend[i];
1368
- if( zAppend[i]==quote ) *zCsr++ = quote;
1369
- }
1370
- *zCsr++ = quote;
1371
- *zCsr++ = '\0';
1372
- assert( (zCsr-zIn)==len );
1373
- }else{
1374
- memcpy(&zIn[nIn], zAppend, nAppend);
1375
- zIn[len-1] = '\0';
1376
- }
1377
-
1378
- return zIn;
2172
+ if( zName[i]==cQuote ) z[n++] = cQuote;
2173
+ }
2174
+ if( cQuote ) z[n++] = cQuote;
2175
+ z[n] = 0;
13792176
 }
13802177
13812178
13822179
 /*
13832180
 ** Execute a query statement that will generate SQL output. Print
@@ -1484,10 +2281,35 @@
14842281
 }
14852282
 fclose(in);
14862283
 }
14872284
 #endif
14882285
2286
+/*
2287
+** Display a single line of status using 64-bit values.
2288
+*/
2289
+static void displayStatLine(
2290
+ ShellState *p, /* The shell context */
2291
+ char *zLabel, /* Label for this one line */
2292
+ char *zFormat, /* Format for the result */
2293
+ int iStatusCtrl, /* Which status to display */
2294
+ int bReset /* True to reset the stats */
2295
+){
2296
+ sqlite3_int64 iCur = -1;
2297
+ sqlite3_int64 iHiwtr = -1;
2298
+ int i, nPercent;
2299
+ char zLine[200];
2300
+ sqlite3_status64(iStatusCtrl, &iCur, &iHiwtr, bReset);
2301
+ for(i=0, nPercent=0; zFormat[i]; i++){
2302
+ if( zFormat[i]=='%' ) nPercent++;
2303
+ }
2304
+ if( nPercent>1 ){
2305
+ sqlite3_snprintf(sizeof(zLine), zLine, zFormat, iCur, iHiwtr);
2306
+ }else{
2307
+ sqlite3_snprintf(sizeof(zLine), zLine, zFormat, iHiwtr);
2308
+ }
2309
+ raw_printf(p->out, "%-36s %s\n", zLabel, zLine);
2310
+}
14892311
14902312
 /*
14912313
 ** Display memory stats.
14922314
 */
14932315
 static int display_stats(
@@ -1497,61 +2319,35 @@
14972319
 ){
14982320
 int iCur;
14992321
 int iHiwtr;
15002322
15012323
 if( pArg && pArg->out ){
1502
-
1503
- iHiwtr = iCur = -1;
1504
- sqlite3_status(SQLITE_STATUS_MEMORY_USED, &iCur, &iHiwtr, bReset);
1505
- raw_printf(pArg->out,
1506
- "Memory Used: %d (max %d) bytes\n",
1507
- iCur, iHiwtr);
1508
- iHiwtr = iCur = -1;
1509
- sqlite3_status(SQLITE_STATUS_MALLOC_COUNT, &iCur, &iHiwtr, bReset);
1510
- raw_printf(pArg->out, "Number of Outstanding Allocations: %d (max %d)\n",
1511
- iCur, iHiwtr);
2324
+ displayStatLine(pArg, "Memory Used:",
2325
+ "%lld (max %lld) bytes", SQLITE_STATUS_MEMORY_USED, bReset);
2326
+ displayStatLine(pArg, "Number of Outstanding Allocations:",
2327
+ "%lld (max %lld)", SQLITE_STATUS_MALLOC_COUNT, bReset);
15122328
 if( pArg->shellFlgs & SHFLG_Pagecache ){
1513
- iHiwtr = iCur = -1;
1514
- sqlite3_status(SQLITE_STATUS_PAGECACHE_USED, &iCur, &iHiwtr, bReset);
1515
- raw_printf(pArg->out,
1516
- "Number of Pcache Pages Used: %d (max %d) pages\n",
1517
- iCur, iHiwtr);
1518
- }
1519
- iHiwtr = iCur = -1;
1520
- sqlite3_status(SQLITE_STATUS_PAGECACHE_OVERFLOW, &iCur, &iHiwtr, bReset);
1521
- raw_printf(pArg->out,
1522
- "Number of Pcache Overflow Bytes: %d (max %d) bytes\n",
1523
- iCur, iHiwtr);
2329
+ displayStatLine(pArg, "Number of Pcache Pages Used:",
2330
+ "%lld (max %lld) pages", SQLITE_STATUS_PAGECACHE_USED, bReset);
2331
+ }
2332
+ displayStatLine(pArg, "Number of Pcache Overflow Bytes:",
2333
+ "%lld (max %lld) bytes", SQLITE_STATUS_PAGECACHE_OVERFLOW, bReset);
15242334
 if( pArg->shellFlgs & SHFLG_Scratch ){
1525
- iHiwtr = iCur = -1;
1526
- sqlite3_status(SQLITE_STATUS_SCRATCH_USED, &iCur, &iHiwtr, bReset);
1527
- raw_printf(pArg->out,
1528
- "Number of Scratch Allocations Used: %d (max %d)\n",
1529
- iCur, iHiwtr);
1530
- }
1531
- iHiwtr = iCur = -1;
1532
- sqlite3_status(SQLITE_STATUS_SCRATCH_OVERFLOW, &iCur, &iHiwtr, bReset);
1533
- raw_printf(pArg->out,
1534
- "Number of Scratch Overflow Bytes: %d (max %d) bytes\n",
1535
- iCur, iHiwtr);
1536
- iHiwtr = iCur = -1;
1537
- sqlite3_status(SQLITE_STATUS_MALLOC_SIZE, &iCur, &iHiwtr, bReset);
1538
- raw_printf(pArg->out, "Largest Allocation: %d bytes\n",
1539
- iHiwtr);
1540
- iHiwtr = iCur = -1;
1541
- sqlite3_status(SQLITE_STATUS_PAGECACHE_SIZE, &iCur, &iHiwtr, bReset);
1542
- raw_printf(pArg->out, "Largest Pcache Allocation: %d bytes\n",
1543
- iHiwtr);
1544
- iHiwtr = iCur = -1;
1545
- sqlite3_status(SQLITE_STATUS_SCRATCH_SIZE, &iCur, &iHiwtr, bReset);
1546
- raw_printf(pArg->out, "Largest Scratch Allocation: %d bytes\n",
1547
- iHiwtr);
2335
+ displayStatLine(pArg, "Number of Scratch Allocations Used:",
2336
+ "%lld (max %lld)", SQLITE_STATUS_SCRATCH_USED, bReset);
2337
+ }
2338
+ displayStatLine(pArg, "Number of Scratch Overflow Bytes:",
2339
+ "%lld (max %lld) bytes", SQLITE_STATUS_SCRATCH_OVERFLOW, bReset);
2340
+ displayStatLine(pArg, "Largest Allocation:",
2341
+ "%lld bytes", SQLITE_STATUS_MALLOC_SIZE, bReset);
2342
+ displayStatLine(pArg, "Largest Pcache Allocation:",
2343
+ "%lld bytes", SQLITE_STATUS_PAGECACHE_SIZE, bReset);
2344
+ displayStatLine(pArg, "Largest Scratch Allocation:",
2345
+ "%lld bytes", SQLITE_STATUS_SCRATCH_SIZE, bReset);
15482346
 #ifdef YYTRACKMAXSTACKDEPTH
1549
- iHiwtr = iCur = -1;
1550
- sqlite3_status(SQLITE_STATUS_PARSER_STACK, &iCur, &iHiwtr, bReset);
1551
- raw_printf(pArg->out, "Deepest Parser Stack: %d (max %d)\n",
1552
- iCur, iHiwtr);
2347
+ displayStatLine(pArg, "Deepest Parser Stack:",
2348
+ "%lld (max %lld)", SQLITE_STATUS_PARSER_STACK, bReset);
15532349
 #endif
15542350
 }
15552351
15562352
 if( pArg && pArg->out && db ){
15572353
 if( pArg->shellFlgs & SHFLG_Lookaside ){
@@ -1934,11 +2730,11 @@
19342730
 pArg->pStmt = pStmt;
19352731
 pArg->cnt = 0;
19362732
 }
19372733
19382734
 /* echo the sql statement if echo on */
1939
- if( pArg && pArg->echoOn ){
2735
+ if( pArg && ShellHasFlag(pArg, SHFLG_Echo) ){
19402736
 utf8_printf(pArg->out, "%s\n", zStmtSql ? zStmtSql : zSql);
19412737
 }
19422738
19432739
 /* Show the EXPLAIN QUERY PLAN if .eqp is on */
19442740
 if( pArg && pArg->autoEQP && sqlite3_strlike("EXPLAIN%",zStmtSql,0)!=0 ){
@@ -2022,10 +2818,142 @@
20222818
 } /* end while */
20232819
20242820
 return rc;
20252821
 }
20262822
2823
+/*
2824
+** Release memory previously allocated by tableColumnList().
2825
+*/
2826
+static void freeColumnList(char **azCol){
2827
+ int i;
2828
+ for(i=1; azCol[i]; i++){
2829
+ sqlite3_free(azCol[i]);
2830
+ }
2831
+ /* azCol[0] is a static string */
2832
+ sqlite3_free(azCol);
2833
+}
2834
+
2835
+/*
2836
+** Return a list of pointers to strings which are the names of all
2837
+** columns in table zTab. The memory to hold the names is dynamically
2838
+** allocated and must be released by the caller using a subsequent call
2839
+** to freeColumnList().
2840
+**
2841
+** The azCol[0] entry is usually NULL. However, if zTab contains a rowid
2842
+** value that needs to be preserved, then azCol[0] is filled in with the
2843
+** name of the rowid column.
2844
+**
2845
+** The first regular column in the table is azCol[1]. The list is terminated
2846
+** by an entry with azCol[i]==0.
2847
+*/
2848
+static char **tableColumnList(ShellState *p, const char *zTab){
2849
+ char **azCol = 0;
2850
+ sqlite3_stmt *pStmt;
2851
+ char *zSql;
2852
+ int nCol = 0;
2853
+ int nAlloc = 0;
2854
+ int nPK = 0; /* Number of PRIMARY KEY columns seen */
2855
+ int isIPK = 0; /* True if one PRIMARY KEY column of type INTEGER */
2856
+ int preserveRowid = ShellHasFlag(p, SHFLG_PreserveRowid);
2857
+ int rc;
2858
+
2859
+ zSql = sqlite3_mprintf("PRAGMA table_info=%Q", zTab);
2860
+ rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
2861
+ sqlite3_free(zSql);
2862
+ if( rc ) return 0;
2863
+ while( sqlite3_step(pStmt)==SQLITE_ROW ){
2864
+ if( nCol>=nAlloc-2 ){
2865
+ nAlloc = nAlloc*2 + nCol + 10;
2866
+ azCol = sqlite3_realloc(azCol, nAlloc*sizeof(azCol[0]));
2867
+ if( azCol==0 ){
2868
+ raw_printf(stderr, "Error: out of memory\n");
2869
+ exit(1);
2870
+ }
2871
+ }
2872
+ azCol[++nCol] = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 1));
2873
+ if( sqlite3_column_int(pStmt, 5) ){
2874
+ nPK++;
2875
+ if( nPK==1
2876
+ && sqlite3_stricmp((const char*)sqlite3_column_text(pStmt,2),
2877
+ "INTEGER")==0
2878
+ ){
2879
+ isIPK = 1;
2880
+ }else{
2881
+ isIPK = 0;
2882
+ }
2883
+ }
2884
+ }
2885
+ sqlite3_finalize(pStmt);
2886
+ azCol[0] = 0;
2887
+ azCol[nCol+1] = 0;
2888
+
2889
+ /* The decision of whether or not a rowid really needs to be preserved
2890
+ ** is tricky. We never need to preserve a rowid for a WITHOUT ROWID table
2891
+ ** or a table with an INTEGER PRIMARY KEY. We are unable to preserve
2892
+ ** rowids on tables where the rowid is inaccessible because there are other
2893
+ ** columns in the table named "rowid", "_rowid_", and "oid".
2894
+ */
2895
+ if( preserveRowid && isIPK ){
2896
+ /* If a single PRIMARY KEY column with type INTEGER was seen, then it
2897
+ ** might be an alise for the ROWID. But it might also be a WITHOUT ROWID
2898
+ ** table or a INTEGER PRIMARY KEY DESC column, neither of which are
2899
+ ** ROWID aliases. To distinguish these cases, check to see if
2900
+ ** there is a "pk" entry in "PRAGMA index_list". There will be
2901
+ ** no "pk" index if the PRIMARY KEY really is an alias for the ROWID.
2902
+ */
2903
+ zSql = sqlite3_mprintf("SELECT 1 FROM pragma_index_list(%Q)"
2904
+ " WHERE origin='pk'", zTab);
2905
+ rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
2906
+ sqlite3_free(zSql);
2907
+ if( rc ){
2908
+ freeColumnList(azCol);
2909
+ return 0;
2910
+ }
2911
+ rc = sqlite3_step(pStmt);
2912
+ sqlite3_finalize(pStmt);
2913
+ preserveRowid = rc==SQLITE_ROW;
2914
+ }
2915
+ if( preserveRowid ){
2916
+ /* Only preserve the rowid if we can find a name to use for the
2917
+ ** rowid */
2918
+ static char *azRowid[] = { "rowid", "_rowid_", "oid" };
2919
+ int i, j;
2920
+ for(j=0; j<3; j++){
2921
+ for(i=1; i<=nCol; i++){
2922
+ if( sqlite3_stricmp(azRowid[j],azCol[i])==0 ) break;
2923
+ }
2924
+ if( i>nCol ){
2925
+ /* At this point, we know that azRowid[j] is not the name of any
2926
+ ** ordinary column in the table. Verify that azRowid[j] is a valid
2927
+ ** name for the rowid before adding it to azCol[0]. WITHOUT ROWID
2928
+ ** tables will fail this last check */
2929
+ int rc;
2930
+ rc = sqlite3_table_column_metadata(p->db,0,zTab,azRowid[j],0,0,0,0,0);
2931
+ if( rc==SQLITE_OK ) azCol[0] = azRowid[j];
2932
+ break;
2933
+ }
2934
+ }
2935
+ }
2936
+ return azCol;
2937
+}
2938
+
2939
+/*
2940
+** Toggle the reverse_unordered_selects setting.
2941
+*/
2942
+static void toggleSelectOrder(sqlite3 *db){
2943
+ sqlite3_stmt *pStmt = 0;
2944
+ int iSetting = 0;
2945
+ char zStmt[100];
2946
+ sqlite3_prepare_v2(db, "PRAGMA reverse_unordered_selects", -1, &pStmt, 0);
2947
+ if( sqlite3_step(pStmt)==SQLITE_ROW ){
2948
+ iSetting = sqlite3_column_int(pStmt, 0);
2949
+ }
2950
+ sqlite3_finalize(pStmt);
2951
+ sqlite3_snprintf(sizeof(zStmt), zStmt,
2952
+ "PRAGMA reverse_unordered_selects(%d)", !iSetting);
2953
+ sqlite3_exec(db, zStmt, 0, 0, 0);
2954
+}
20272955
20282956
 /*
20292957
 ** This is a different callback routine used for dumping the database.
20302958
 ** Each row received by this callback consists of a table name,
20312959
 ** the table type ("index" or "table") and SQL to create the table.
@@ -2034,21 +2962,20 @@
20342962
 static int dump_callback(void *pArg, int nArg, char **azArg, char **azCol){
20352963
 int rc;
20362964
 const char *zTable;
20372965
 const char *zType;
20382966
 const char *zSql;
2039
- const char *zPrepStmt = 0;
20402967
 ShellState *p = (ShellState *)pArg;
20412968
20422969
 UNUSED_PARAMETER(azCol);
20432970
 if( nArg!=3 ) return 1;
20442971
 zTable = azArg[0];
20452972
 zType = azArg[1];
20462973
 zSql = azArg[2];
20472974
20482975
 if( strcmp(zTable, "sqlite_sequence")==0 ){
2049
- zPrepStmt = "DELETE FROM sqlite_sequence;\n";
2976
+ raw_printf(p->out, "DELETE FROM sqlite_sequence;\n");
20502977
 }else if( sqlite3_strglob("sqlite_stat?", zTable)==0 ){
20512978
 raw_printf(p->out, "ANALYZE sqlite_master;\n");
20522979
 }else if( strncmp(zTable, "sqlite_", 7)==0 ){
20532980
 return 0;
20542981
 }else if( strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){
@@ -2067,62 +2994,74 @@
20672994
 }else{
20682995
 printSchemaLine(p->out, zSql, ";\n");
20692996
 }
20702997
20712998
 if( strcmp(zType, "table")==0 ){
2072
- sqlite3_stmt *pTableInfo = 0;
2073
- char *zSelect = 0;
2074
- char *zTableInfo = 0;
2075
- char *zTmp = 0;
2076
- int nRow = 0;
2077
-
2078
- zTableInfo = appendText(zTableInfo, "PRAGMA table_info(", 0);
2079
- zTableInfo = appendText(zTableInfo, zTable, '"');
2080
- zTableInfo = appendText(zTableInfo, ");", 0);
2081
-
2082
- rc = sqlite3_prepare_v2(p->db, zTableInfo, -1, &pTableInfo, 0);
2083
- free(zTableInfo);
2084
- if( rc!=SQLITE_OK || !pTableInfo ){
2085
- return 1;
2086
- }
2087
-
2088
- zSelect = appendText(zSelect, "SELECT 'INSERT INTO ' || ", 0);
2999
+ ShellText sSelect;
3000
+ ShellText sTable;
3001
+ char **azCol;
3002
+ int i;
3003
+ char *savedDestTable;
3004
+ int savedMode;
3005
+
3006
+ azCol = tableColumnList(p, zTable);
3007
+ if( azCol==0 ){
3008
+ p->nErr++;
3009
+ return 0;
3010
+ }
3011
+
20893012
 /* Always quote the table name, even if it appears to be pure ascii,
20903013
 ** in case it is a keyword. Ex: INSERT INTO "table" ... */
2091
- zTmp = appendText(zTmp, zTable, '"');
2092
- if( zTmp ){
2093
- zSelect = appendText(zSelect, zTmp, '\'');
2094
- free(zTmp);
2095
- }
2096
- zSelect = appendText(zSelect, " || ' VALUES(' || ", 0);
2097
- rc = sqlite3_step(pTableInfo);
2098
- while( rc==SQLITE_ROW ){
2099
- const char *zText = (const char *)sqlite3_column_text(pTableInfo, 1);
2100
- zSelect = appendText(zSelect, "quote(", 0);
2101
- zSelect = appendText(zSelect, zText, '"');
2102
- rc = sqlite3_step(pTableInfo);
2103
- if( rc==SQLITE_ROW ){
2104
- zSelect = appendText(zSelect, "), ", 0);
2105
- }else{
2106
- zSelect = appendText(zSelect, ") ", 0);
2107
- }
2108
- nRow++;
2109
- }
2110
- rc = sqlite3_finalize(pTableInfo);
2111
- if( rc!=SQLITE_OK || nRow==0 ){
2112
- free(zSelect);
2113
- return 1;
2114
- }
2115
- zSelect = appendText(zSelect, "|| ')' FROM ", 0);
2116
- zSelect = appendText(zSelect, zTable, '"');
2117
-
2118
- rc = run_table_dump_query(p, zSelect, zPrepStmt);
2119
- if( rc==SQLITE_CORRUPT ){
2120
- zSelect = appendText(zSelect, " ORDER BY rowid DESC", 0);
2121
- run_table_dump_query(p, zSelect, 0);
2122
- }
2123
- free(zSelect);
3014
+ initText(&sTable);
3015
+ appendText(&sTable, zTable, quoteChar(zTable));
3016
+ /* If preserving the rowid, add a column list after the table name.
3017
+ ** In other words: "INSERT INTO tab(rowid,a,b,c,...) VALUES(...)"
3018
+ ** instead of the usual "INSERT INTO tab VALUES(...)".
3019
+ */
3020
+ if( azCol[0] ){
3021
+ appendText(&sTable, "(", 0);
3022
+ appendText(&sTable, azCol[0], 0);
3023
+ for(i=1; azCol[i]; i++){
3024
+ appendText(&sTable, ",", 0);
3025
+ appendText(&sTable, azCol[i], quoteChar(azCol[i]));
3026
+ }
3027
+ appendText(&sTable, ")", 0);
3028
+ }
3029
+
3030
+ /* Build an appropriate SELECT statement */
3031
+ initText(&sSelect);
3032
+ appendText(&sSelect, "SELECT ", 0);
3033
+ if( azCol[0] ){
3034
+ appendText(&sSelect, azCol[0], 0);
3035
+ appendText(&sSelect, ",", 0);
3036
+ }
3037
+ for(i=1; azCol[i]; i++){
3038
+ appendText(&sSelect, azCol[i], quoteChar(azCol[i]));
3039
+ if( azCol[i+1] ){
3040
+ appendText(&sSelect, ",", 0);
3041
+ }
3042
+ }
3043
+ freeColumnList(azCol);
3044
+ appendText(&sSelect, " FROM ", 0);
3045
+ appendText(&sSelect, zTable, quoteChar(zTable));
3046
+
3047
+ savedDestTable = p->zDestTable;
3048
+ savedMode = p->mode;
3049
+ p->zDestTable = sTable.z;
3050
+ p->mode = p->cMode = MODE_Insert;
3051
+ rc = shell_exec(p->db, sSelect.z, shell_callback, p, 0);
3052
+ if( (rc&0xff)==SQLITE_CORRUPT ){
3053
+ raw_printf(p->out, "/****** CORRUPTION ERROR *******/\n");
3054
+ toggleSelectOrder(p->db);
3055
+ shell_exec(p->db, sSelect.z, shell_callback, p, 0);
3056
+ toggleSelectOrder(p->db);
3057
+ }
3058
+ p->zDestTable = savedDestTable;
3059
+ p->mode = savedMode;
3060
+ freeText(&sTable);
3061
+ freeText(&sSelect);
3062
+ if( rc ) p->nErr++;
21243063
 }
21253064
 return 0;
21263065
 }
21273066
21283067
 /*
@@ -2228,15 +3167,17 @@
22283167
 ".restore ?DB? FILE Restore content of DB (default \"main\") from FILE\n"
22293168
 ".save FILE Write in-memory database into FILE\n"
22303169
 ".scanstats on|off Turn sqlite3_stmt_scanstatus() metrics on or off\n"
22313170
 ".schema ?PATTERN? Show the CREATE statements matching PATTERN\n"
22323171
 " Add --indent for pretty-printing\n"
3172
+ ".selftest ?--init? Run tests defined in the SELFTEST table\n"
22333173
 ".separator COL ?ROW? Change the column separator and optionally the row\n"
22343174
 " separator for both the output mode and .import\n"
22353175
 #if defined(SQLITE_ENABLE_SESSION)
22363176
 ".session CMD ... Create or control sessions\n"
22373177
 #endif
3178
+ ".sha3sum ?OPTIONS...? Compute a SHA3 hash of database content\n"
22383179
 ".shell CMD ARGS... Run CMD ARGS... in a system shell\n"
22393180
 ".show Show the current values for various settings\n"
22403181
 ".stats ?on|off? Show stats or turn stats on or off\n"
22413182
 ".system CMD ARGS... Run CMD ARGS... in a system shell\n"
22423183
 ".tables ?TABLE? List names of tables\n"
@@ -2423,14 +3364,10 @@
24233364
 static void open_db(ShellState *p, int keepAlive){
24243365
 if( p->db==0 ){
24253366
 sqlite3_initialize();
24263367
 sqlite3_open(p->zDbFilename, &p->db);
24273368
 globalDb = p->db;
2428
- if( p->db && sqlite3_errcode(p->db)==SQLITE_OK ){
2429
- sqlite3_create_function(p->db, "shellstatic", 0, SQLITE_UTF8, 0,
2430
- shellstaticFunc, 0, 0);
2431
- }
24323369
 if( p->db==0 || SQLITE_OK!=sqlite3_errcode(p->db) ){
24333370
 utf8_printf(stderr,"Error: unable to open database \"%s\": %s\n",
24343371
 p->zDbFilename, sqlite3_errmsg(p->db));
24353372
 if( keepAlive ) return;
24363373
 exit(1);
@@ -2440,10 +3377,18 @@
24403377
 #endif
24413378
 sqlite3_create_function(p->db, "readfile", 1, SQLITE_UTF8, 0,
24423379
 readfileFunc, 0, 0);
24433380
 sqlite3_create_function(p->db, "writefile", 2, SQLITE_UTF8, 0,
24443381
 writefileFunc, 0, 0);
3382
+ sqlite3_create_function(p->db, "sha3", 1, SQLITE_UTF8, 0,
3383
+ sha3Func, 0, 0);
3384
+ sqlite3_create_function(p->db, "sha3", 2, SQLITE_UTF8, 0,
3385
+ sha3Func, 0, 0);
3386
+ sqlite3_create_function(p->db, "sha3_query", 1, SQLITE_UTF8, 0,
3387
+ sha3QueryFunc, 0, 0);
3388
+ sqlite3_create_function(p->db, "sha3_query", 2, SQLITE_UTF8, 0,
3389
+ sha3QueryFunc, 0, 0);
24453390
 }
24463391
 }
24473392
24483393
 /*
24493394
 ** Do C-language style dequoting.
@@ -2564,11 +3509,11 @@
25643509
25653510
 /*
25663511
 ** Interpret zArg as either an integer or a boolean value. Return 1 or 0
25673512
 ** for TRUE and FALSE. Return the integer value if appropriate.
25683513
 */
2569
-static int booleanValue(char *zArg){
3514
+static int booleanValue(const char *zArg){
25703515
 int i;
25713516
 if( zArg[0]=='0' && zArg[1]=='x' ){
25723517
 for(i=2; hexDigitValue(zArg[i])>=0; i++){}
25733518
 }else{
25743519
 for(i=0; zArg[i]>='0' && zArg[i]<='9'; i++){}
@@ -2582,10 +3527,21 @@
25823527
 }
25833528
 utf8_printf(stderr, "ERROR: Not a boolean value: \"%s\". Assuming \"no\".\n",
25843529
 zArg);
25853530
 return 0;
25863531
 }
3532
+
3533
+/*
3534
+** Set or clear a shell flag according to a boolean value.
3535
+*/
3536
+static void setOrClearFlag(ShellState *p, unsigned mFlag, const char *zArg){
3537
+ if( booleanValue(zArg) ){
3538
+ ShellSetFlag(p, mFlag);
3539
+ }else{
3540
+ ShellClearFlag(p, mFlag);
3541
+ }
3542
+}
25873543
25883544
 /*
25893545
 ** Close an output file, assuming it is not stderr or stdout
25903546
 */
25913547
 static void output_file_close(FILE *f){
@@ -3656,11 +4612,11 @@
36564612
 test_breakpoint();
36574613
 }else
36584614
36594615
 if( c=='c' && n>=3 && strncmp(azArg[0], "changes", n)==0 ){
36604616
 if( nArg==2 ){
3661
- p->countChanges = booleanValue(azArg[1]);
4617
+ setOrClearFlag(p, SHFLG_CountChanges, azArg[1]);
36624618
 }else{
36634619
 raw_printf(stderr, "Usage: .changes on|off\n");
36644620
 rc = 1;
36654621
 }
36664622
 }else
@@ -3720,25 +4676,46 @@
37204676
 if( c=='d' && strncmp(azArg[0], "dbinfo", n)==0 ){
37214677
 rc = shell_dbinfo_command(p, nArg, azArg);
37224678
 }else
37234679
37244680
 if( c=='d' && strncmp(azArg[0], "dump", n)==0 ){
4681
+ const char *zLike = 0;
4682
+ int i;
4683
+ ShellClearFlag(p, SHFLG_PreserveRowid);
4684
+ for(i=1; i<nArg; i++){
4685
+ if( azArg[i][0]=='-' ){
4686
+ const char *z = azArg[i]+1;
4687
+ if( z[0]=='-' ) z++;
4688
+ if( strcmp(z,"preserve-rowids")==0 ){
4689
+ ShellSetFlag(p, SHFLG_PreserveRowid);
4690
+ }else
4691
+ {
4692
+ raw_printf(stderr, "Unknown option \"%s\" on \".dump\"\n", azArg[i]);
4693
+ rc = 1;
4694
+ goto meta_command_exit;
4695
+ }
4696
+ }else if( zLike ){
4697
+ raw_printf(stderr, "Usage: .dump ?--preserve-rowids? ?LIKE-PATTERN?\n");
4698
+ rc = 1;
4699
+ goto meta_command_exit;
4700
+ }else{
4701
+ zLike = azArg[i];
4702
+ }
4703
+ }
37254704
 open_db(p, 0);
37264705
 /* When playing back a "dump", the content might appear in an order
37274706
 ** which causes immediate foreign key constraints to be violated.
37284707
 ** So disable foreign-key constraint enforcement to prevent problems. */
3729
- if( nArg!=1 && nArg!=2 ){
3730
- raw_printf(stderr, "Usage: .dump ?LIKE-PATTERN?\n");
3731
- rc = 1;
3732
- goto meta_command_exit;
3733
- }
37344708
 raw_printf(p->out, "PRAGMA foreign_keys=OFF;\n");
37354709
 raw_printf(p->out, "BEGIN TRANSACTION;\n");
37364710
 p->writableSchema = 0;
4711
+ /* Set writable_schema=ON since doing so forces SQLite to initialize
4712
+ ** as much of the schema as it can even if the sqlite_master table is
4713
+ ** corrupt. */
37374714
 sqlite3_exec(p->db, "SAVEPOINT dump; PRAGMA writable_schema=ON", 0, 0, 0);
37384715
 p->nErr = 0;
3739
- if( nArg==1 ){
4716
+ if( zLike==0 ){
37404717
 run_schema_dump_query(p,
37414718
 "SELECT name, type, sql FROM sqlite_master "
37424719
 "WHERE sql NOT NULL AND type=='table' AND name!='sqlite_sequence'"
37434720
 );
37444721
 run_schema_dump_query(p,
@@ -3748,25 +4725,24 @@
37484725
 run_table_dump_query(p,
37494726
 "SELECT sql FROM sqlite_master "
37504727
 "WHERE sql NOT NULL AND type IN ('index','trigger','view')", 0
37514728
 );
37524729
 }else{
3753
- int i;
3754
- for(i=1; i<nArg; i++){
3755
- zShellStatic = azArg[i];
3756
- run_schema_dump_query(p,
3757
- "SELECT name, type, sql FROM sqlite_master "
3758
- "WHERE tbl_name LIKE shellstatic() AND type=='table'"
3759
- " AND sql NOT NULL");
3760
- run_table_dump_query(p,
3761
- "SELECT sql FROM sqlite_master "
3762
- "WHERE sql NOT NULL"
3763
- " AND type IN ('index','trigger','view')"
3764
- " AND tbl_name LIKE shellstatic()", 0
3765
- );
3766
- zShellStatic = 0;
3767
- }
4730
+ char *zSql;
4731
+ zSql = sqlite3_mprintf(
4732
+ "SELECT name, type, sql FROM sqlite_master "
4733
+ "WHERE tbl_name LIKE %Q AND type=='table'"
4734
+ " AND sql NOT NULL", zLike);
4735
+ run_schema_dump_query(p,zSql);
4736
+ sqlite3_free(zSql);
4737
+ zSql = sqlite3_mprintf(
4738
+ "SELECT sql FROM sqlite_master "
4739
+ "WHERE sql NOT NULL"
4740
+ " AND type IN ('index','trigger','view')"
4741
+ " AND tbl_name LIKE %Q", zLike);
4742
+ run_table_dump_query(p, zSql, 0);
4743
+ sqlite3_free(zSql);
37684744
 }
37694745
 if( p->writableSchema ){
37704746
 raw_printf(p->out, "PRAGMA writable_schema=OFF;\n");
37714747
 p->writableSchema = 0;
37724748
 }
@@ -3775,11 +4751,11 @@
37754751
 raw_printf(p->out, p->nErr ? "ROLLBACK; -- due to errors\n" : "COMMIT;\n");
37764752
 }else
37774753
37784754
 if( c=='e' && strncmp(azArg[0], "echo", n)==0 ){
37794755
 if( nArg==2 ){
3780
- p->echoOn = booleanValue(azArg[1]);
4756
+ setOrClearFlag(p, SHFLG_Echo, azArg[1]);
37814757
 }else{
37824758
 raw_printf(stderr, "Usage: .echo on|off\n");
37834759
 rc = 1;
37844760
 }
37854761
 }else
@@ -4572,21 +5548,21 @@
45725548
 new_colv[0] = "sql";
45735549
 new_colv[1] = 0;
45745550
 callback(&data, 1, new_argv, new_colv);
45755551
 rc = SQLITE_OK;
45765552
 }else{
4577
- zShellStatic = azArg[1];
4578
- rc = sqlite3_exec(p->db,
5553
+ char *zSql;
5554
+ zSql = sqlite3_mprintf(
45795555
 "SELECT sql FROM "
45805556
 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
45815557
 " FROM sqlite_master UNION ALL"
45825558
 " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
4583
- "WHERE lower(tbl_name) LIKE shellstatic()"
5559
+ "WHERE lower(tbl_name) LIKE %Q"
45845560
 " AND type!='meta' AND sql NOTNULL "
4585
- "ORDER BY rowid",
4586
- callback, &data, &zErrMsg);
4587
- zShellStatic = 0;
5561
+ "ORDER BY rowid", azArg[1]);
5562
+ rc = sqlite3_exec(p->db, zSql, callback, &data, &zErrMsg);
5563
+ sqlite3_free(zSql);
45885564
 }
45895565
 }else if( nArg==1 ){
45905566
 rc = sqlite3_exec(p->db,
45915567
 "SELECT sql FROM "
45925568
 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
@@ -4835,10 +5811,123 @@
48355811
 utf8_printf(p->out, "%s", zBuf);
48365812
 }
48375813
 }
48385814
 }else
48395815
 #endif
5816
+
5817
+ if( c=='s' && n>=4 && strncmp(azArg[0],"selftest",n)==0 ){
5818
+ int bIsInit = 0; /* True to initialize the SELFTEST table */
5819
+ int bVerbose = 0; /* Verbose output */
5820
+ int bSelftestExists; /* True if SELFTEST already exists */
5821
+ char **azTest = 0; /* Content of the SELFTEST table */
5822
+ int nRow = 0; /* Number of rows in the SELFTEST table */
5823
+ int nCol = 4; /* Number of columns in the SELFTEST table */
5824
+ int i; /* Loop counter */
5825
+ int nTest = 0; /* Number of tests runs */
5826
+ int nErr = 0; /* Number of errors seen */
5827
+ ShellText str; /* Answer for a query */
5828
+ static char *azDefaultTest[] = {
5829
+ 0, 0, 0, 0,
5830
+ "0", "memo", "Missing SELFTEST table - default checks only", "",
5831
+ "1", "run", "PRAGMA integrity_check", "ok"
5832
+ };
5833
+ static const int nDefaultRow = 2;
5834
+
5835
+ open_db(p,0);
5836
+ for(i=1; i<nArg; i++){
5837
+ const char *z = azArg[i];
5838
+ if( z[0]=='-' && z[1]=='-' ) z++;
5839
+ if( strcmp(z,"-init")==0 ){
5840
+ bIsInit = 1;
5841
+ }else
5842
+ if( strcmp(z,"-v")==0 ){
5843
+ bVerbose++;
5844
+ }else
5845
+ {
5846
+ utf8_printf(stderr, "Unknown option \"%s\" on \"%s\"\n",
5847
+ azArg[i], azArg[0]);
5848
+ raw_printf(stderr, "Should be one of: --init -v\n");
5849
+ rc = 1;
5850
+ goto meta_command_exit;
5851
+ }
5852
+ }
5853
+ if( sqlite3_table_column_metadata(p->db,"main","selftest",0,0,0,0,0,0)
5854
+ != SQLITE_OK ){
5855
+ bSelftestExists = 0;
5856
+ }else{
5857
+ bSelftestExists = 1;
5858
+ }
5859
+ if( bIsInit ){
5860
+ createSelftestTable(p);
5861
+ bSelftestExists = 1;
5862
+ }
5863
+ if( bSelftestExists ){
5864
+ rc = sqlite3_get_table(p->db,
5865
+ "SELECT tno,op,cmd,ans FROM selftest ORDER BY tno",
5866
+ &azTest, &nRow, &nCol, 0);
5867
+ if( rc ){
5868
+ raw_printf(stderr, "Error querying the selftest table\n");
5869
+ rc = 1;
5870
+ sqlite3_free_table(azTest);
5871
+ goto meta_command_exit;
5872
+ }else if( nRow==0 ){
5873
+ sqlite3_free_table(azTest);
5874
+ azTest = azDefaultTest;
5875
+ nRow = nDefaultRow;
5876
+ }
5877
+ }else{
5878
+ azTest = azDefaultTest;
5879
+ nRow = nDefaultRow;
5880
+ }
5881
+ initText(&str);
5882
+ appendText(&str, "x", 0);
5883
+ for(i=1; i<=nRow; i++){
5884
+ int tno = atoi(azTest[i*nCol]);
5885
+ const char *zOp = azTest[i*nCol+1];
5886
+ const char *zSql = azTest[i*nCol+2];
5887
+ const char *zAns = azTest[i*nCol+3];
5888
+
5889
+ if( bVerbose>0 ){
5890
+ char *zQuote = sqlite3_mprintf("%q", zSql);
5891
+ printf("%d: %s %s\n", tno, zOp, zSql);
5892
+ sqlite3_free(zQuote);
5893
+ }
5894
+ if( strcmp(zOp,"memo")==0 ){
5895
+ utf8_printf(p->out, "%s\n", zSql);
5896
+ }else
5897
+ if( strcmp(zOp,"run")==0 ){
5898
+ char *zErrMsg = 0;
5899
+ str.n = 0;
5900
+ str.z[0] = 0;
5901
+ rc = sqlite3_exec(p->db, zSql, captureOutputCallback, &str, &zErrMsg);
5902
+ nTest++;
5903
+ if( bVerbose ){
5904
+ utf8_printf(p->out, "Result: %s\n", str.z);
5905
+ }
5906
+ if( rc || zErrMsg ){
5907
+ nErr++;
5908
+ rc = 1;
5909
+ utf8_printf(p->out, "%d: error-code-%d: %s\n", tno, rc, zErrMsg);
5910
+ sqlite3_free(zErrMsg);
5911
+ }else if( strcmp(zAns,str.z)!=0 ){
5912
+ nErr++;
5913
+ rc = 1;
5914
+ utf8_printf(p->out, "%d: Expected: [%s]\n", tno, zAns);
5915
+ utf8_printf(p->out, "%d: Got: [%s]\n", tno, str.z);
5916
+ }
5917
+ }else
5918
+ {
5919
+ utf8_printf(stderr,
5920
+ "Unknown operation \"%s\" on selftest line %d\n", zOp, tno);
5921
+ rc = 1;
5922
+ break;
5923
+ }
5924
+ }
5925
+ freeText(&str);
5926
+ if( azTest!=azDefaultTest ) sqlite3_free_table(azTest);
5927
+ utf8_printf(p->out, "%d errors out of %d tests\n", nErr, nTest);
5928
+ }else
48405929
48415930
 if( c=='s' && strncmp(azArg[0], "separator", n)==0 ){
48425931
 if( nArg<2 || nArg>3 ){
48435932
 raw_printf(stderr, "Usage: .separator COL ?ROW?\n");
48445933
 rc = 1;
@@ -4850,10 +5939,126 @@
48505939
 if( nArg>=3 ){
48515940
 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator,
48525941
 "%.*s", (int)ArraySize(p->rowSeparator)-1, azArg[2]);
48535942
 }
48545943
 }else
5944
+
5945
+ if( c=='s' && n>=4 && strncmp(azArg[0],"sha3sum",n)==0 ){
5946
+ const char *zLike = 0; /* Which table to checksum. 0 means everything */
5947
+ int i; /* Loop counter */
5948
+ int bSchema = 0; /* Also hash the schema */
5949
+ int bSeparate = 0; /* Hash each table separately */
5950
+ int iSize = 224; /* Hash algorithm to use */
5951
+ int bDebug = 0; /* Only show the query that would have run */
5952
+ sqlite3_stmt *pStmt; /* For querying tables names */
5953
+ char *zSql; /* SQL to be run */
5954
+ char *zSep; /* Separator */
5955
+ ShellText sSql; /* Complete SQL for the query to run the hash */
5956
+ ShellText sQuery; /* Set of queries used to read all content */
5957
+ open_db(p, 0);
5958
+ for(i=1; i<nArg; i++){
5959
+ const char *z = azArg[i];
5960
+ if( z[0]=='-' ){
5961
+ z++;
5962
+ if( z[0]=='-' ) z++;
5963
+ if( strcmp(z,"schema")==0 ){
5964
+ bSchema = 1;
5965
+ }else
5966
+ if( strcmp(z,"sha3-224")==0 || strcmp(z,"sha3-256")==0
5967
+ || strcmp(z,"sha3-384")==0 || strcmp(z,"sha3-512")==0
5968
+ ){
5969
+ iSize = atoi(&z[5]);
5970
+ }else
5971
+ if( strcmp(z,"debug")==0 ){
5972
+ bDebug = 1;
5973
+ }else
5974
+ {
5975
+ utf8_printf(stderr, "Unknown option \"%s\" on \"%s\"\n",
5976
+ azArg[i], azArg[0]);
5977
+ raw_printf(stderr, "Should be one of: --schema"
5978
+ " --sha3-224 --sha3-255 --sha3-384 --sha3-512\n");
5979
+ rc = 1;
5980
+ goto meta_command_exit;
5981
+ }
5982
+ }else if( zLike ){
5983
+ raw_printf(stderr, "Usage: .sha3sum ?OPTIONS? ?LIKE-PATTERN?\n");
5984
+ rc = 1;
5985
+ goto meta_command_exit;
5986
+ }else{
5987
+ zLike = z;
5988
+ bSeparate = 1;
5989
+ if( sqlite3_strlike("sqlite_%", zLike, 0)==0 ) bSchema = 1;
5990
+ }
5991
+ }
5992
+ if( bSchema ){
5993
+ zSql = "SELECT lower(name) FROM sqlite_master"
5994
+ " WHERE type='table' AND coalesce(rootpage,0)>1"
5995
+ " UNION ALL SELECT 'sqlite_master'"
5996
+ " ORDER BY 1 collate nocase";
5997
+ }else{
5998
+ zSql = "SELECT lower(name) FROM sqlite_master"
5999
+ " WHERE type='table' AND coalesce(rootpage,0)>1"
6000
+ " AND name NOT LIKE 'sqlite_%'"
6001
+ " ORDER BY 1 collate nocase";
6002
+ }
6003
+ sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
6004
+ initText(&sQuery);
6005
+ initText(&sSql);
6006
+ appendText(&sSql, "WITH [sha3sum$query](a,b) AS(",0);
6007
+ zSep = "VALUES(";
6008
+ while( SQLITE_ROW==sqlite3_step(pStmt) ){
6009
+ const char *zTab = (const char*)sqlite3_column_text(pStmt,0);
6010
+ if( zLike && sqlite3_strlike(zLike, zTab, 0)!=0 ) continue;
6011
+ if( strncmp(zTab, "sqlite_",7)!=0 ){
6012
+ appendText(&sQuery,"SELECT * FROM ", 0);
6013
+ appendText(&sQuery,zTab,'"');
6014
+ appendText(&sQuery," NOT INDEXED;", 0);
6015
+ }else if( strcmp(zTab, "sqlite_master")==0 ){
6016
+ appendText(&sQuery,"SELECT type,name,tbl_name,sql FROM sqlite_master"
6017
+ " ORDER BY name;", 0);
6018
+ }else if( strcmp(zTab, "sqlite_sequence")==0 ){
6019
+ appendText(&sQuery,"SELECT name,seq FROM sqlite_sequence"
6020
+ " ORDER BY name;", 0);
6021
+ }else if( strcmp(zTab, "sqlite_stat1")==0 ){
6022
+ appendText(&sQuery,"SELECT tbl,idx,stat FROM sqlite_stat1"
6023
+ " ORDER BY tbl,idx;", 0);
6024
+ }else if( strcmp(zTab, "sqlite_stat3")==0
6025
+ || strcmp(zTab, "sqlite_stat4")==0 ){
6026
+ appendText(&sQuery, "SELECT * FROM ", 0);
6027
+ appendText(&sQuery, zTab, 0);
6028
+ appendText(&sQuery, " ORDER BY tbl, idx, rowid;\n", 0);
6029
+ }
6030
+ appendText(&sSql, zSep, 0);
6031
+ appendText(&sSql, sQuery.z, '\'');
6032
+ sQuery.n = 0;
6033
+ appendText(&sSql, ",", 0);
6034
+ appendText(&sSql, zTab, '\'');
6035
+ zSep = "),(";
6036
+ }
6037
+ sqlite3_finalize(pStmt);
6038
+ if( bSeparate ){
6039
+ zSql = sqlite3_mprintf(
6040
+ "%s))"
6041
+ " SELECT lower(hex(sha3_query(a,%d))) AS hash, b AS label"
6042
+ " FROM [sha3sum$query]",
6043
+ sSql.z, iSize);
6044
+ }else{
6045
+ zSql = sqlite3_mprintf(
6046
+ "%s))"
6047
+ " SELECT lower(hex(sha3_query(group_concat(a,''),%d))) AS hash"
6048
+ " FROM [sha3sum$query]",
6049
+ sSql.z, iSize);
6050
+ }
6051
+ freeText(&sQuery);
6052
+ freeText(&sSql);
6053
+ if( bDebug ){
6054
+ utf8_printf(p->out, "%s\n", zSql);
6055
+ }else{
6056
+ shell_exec(p->db, zSql, shell_callback, p, 0);
6057
+ }
6058
+ sqlite3_free(zSql);
6059
+ }else
48556060
48566061
 if( c=='s'
48576062
 && (strncmp(azArg[0], "shell", n)==0 || strncmp(azArg[0],"system",n)==0)
48586063
 ){
48596064
 char *zCmd;
@@ -4879,11 +6084,12 @@
48796084
 if( nArg!=1 ){
48806085
 raw_printf(stderr, "Usage: .show\n");
48816086
 rc = 1;
48826087
 goto meta_command_exit;
48836088
 }
4884
- utf8_printf(p->out, "%12.12s: %s\n","echo", azBool[p->echoOn!=0]);
6089
+ utf8_printf(p->out, "%12.12s: %s\n","echo",
6090
+ azBool[ShellHasFlag(p, SHFLG_Echo)]);
48856091
 utf8_printf(p->out, "%12.12s: %s\n","eqp", azBool[p->autoEQP&3]);
48866092
 utf8_printf(p->out, "%12.12s: %s\n","explain",
48876093
 p->mode==MODE_Explain ? "on" : p->autoExplain ? "auto" : "off");
48886094
 utf8_printf(p->out,"%12.12s: %s\n","headers", azBool[p->showHeader!=0]);
48896095
 utf8_printf(p->out, "%12.12s: %s\n","mode", modeDescr[p->mode]);
@@ -5444,11 +6650,11 @@
54446650
 static int runOneSqlLine(ShellState *p, char *zSql, FILE *in, int startline){
54456651
 int rc;
54466652
 char *zErrMsg = 0;
54476653
54486654
 open_db(p, 0);
5449
- if( p->backslashOn ) resolve_backslashes(zSql);
6655
+ if( ShellHasFlag(p,SHFLG_Backslash) ) resolve_backslashes(zSql);
54506656
 BEGIN_TIMER;
54516657
 rc = shell_exec(p->db, zSql, shell_callback, p, &zErrMsg);
54526658
 END_TIMER;
54536659
 if( rc || zErrMsg ){
54546660
 char zPrefix[100];
@@ -5464,11 +6670,11 @@
54646670
 zErrMsg = 0;
54656671
 }else{
54666672
 utf8_printf(stderr, "%s %s\n", zPrefix, sqlite3_errmsg(p->db));
54676673
 }
54686674
 return 1;
5469
- }else if( p->countChanges ){
6675
+ }else if( ShellHasFlag(p, SHFLG_CountChanges) ){
54706676
 raw_printf(p->out, "changes: %3d total_changes: %d\n",
54716677
 sqlite3_changes(p->db), sqlite3_total_changes(p->db));
54726678
 }
54736679
 return 0;
54746680
 }
@@ -5507,15 +6713,15 @@
55076713
 if( in!=0 ) break;
55086714
 seenInterrupt = 0;
55096715
 }
55106716
 lineno++;
55116717
 if( nSql==0 && _all_whitespace(zLine) ){
5512
- if( p->echoOn ) printf("%s\n", zLine);
6718
+ if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zLine);
55136719
 continue;
55146720
 }
55156721
 if( zLine && zLine[0]=='.' && nSql==0 ){
5516
- if( p->echoOn ) printf("%s\n", zLine);
6722
+ if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zLine);
55176723
 rc = do_meta_command(zLine, p);
55186724
 if( rc==2 ){ /* exit requested */
55196725
 break;
55206726
 }else if( rc ){
55216727
 errCnt++;
@@ -5554,11 +6760,11 @@
55546760
 if( p->outCount ){
55556761
 output_reset(p);
55566762
 p->outCount = 0;
55576763
 }
55586764
 }else if( nSql && _all_whitespace(zSql) ){
5559
- if( p->echoOn ) printf("%s\n", zSql);
6765
+ if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zSql);
55606766
 nSql = 0;
55616767
 }
55626768
 }
55636769
 if( nSql && !_all_whitespace(zSql) ){
55646770
 runOneSqlLine(p, zSql, in, startline);
@@ -6023,11 +7229,11 @@
60237229
 }else if( strcmp(z,"-header")==0 ){
60247230
 data.showHeader = 1;
60257231
 }else if( strcmp(z,"-noheader")==0 ){
60267232
 data.showHeader = 0;
60277233
 }else if( strcmp(z,"-echo")==0 ){
6028
- data.echoOn = 1;
7234
+ ShellSetFlag(&data, SHFLG_Echo);
60297235
 }else if( strcmp(z,"-eqp")==0 ){
60307236
 data.autoEQP = 1;
60317237
 }else if( strcmp(z,"-eqpfull")==0 ){
60327238
 data.autoEQP = 2;
60337239
 }else if( strcmp(z,"-stats")==0 ){
@@ -6038,11 +7244,11 @@
60387244
 /* Undocumented command-line option: -backslash
60397245
 ** Causes C-style backslash escapes to be evaluated in SQL statements
60407246
 ** prior to sending the SQL into SQLite. Useful for injecting
60417247
 ** crazy bytes in the middle of SQL statements for testing and debugging.
60427248
 */
6043
- data.backslashOn = 1;
7249
+ ShellSetFlag(&data, SHFLG_Backslash);
60447250
 }else if( strcmp(z,"-bail")==0 ){
60457251
 bail_on_error = 1;
60467252
 }else if( strcmp(z,"-version")==0 ){
60477253
 printf("%s %s\n", sqlite3_libversion(), sqlite3_sourceid());
60487254
 return 0;
60497255
--- src/shell.c
+++ src/shell.c
@@ -452,32 +452,10 @@
452 while( IsDigit(*z) ){ z++; }
453 if( realnum ) *realnum = 1;
454 }
455 return *z==0;
456 }
457
458 /*
459 ** A global char* and an SQL function to access its current value
460 ** from within an SQL statement. This program used to use the
461 ** sqlite_exec_printf() API to substitue a string into an SQL statement.
462 ** The correct way to do this with sqlite3 is to use the bind API, but
463 ** since the shell is built around the callback paradigm it would be a lot
464 ** of work. Instead just use this hack, which is quite harmless.
465 */
466 static const char *zShellStatic = 0;
467 static void shellstaticFunc(
468 sqlite3_context *context,
469 int argc,
470 sqlite3_value **argv
471 ){
472 assert( 0==argc );
473 assert( zShellStatic );
474 UNUSED_PARAMETER(argc);
475 UNUSED_PARAMETER(argv);
476 sqlite3_result_text(context, zShellStatic, -1, SQLITE_STATIC);
477 }
478
479
480 /*
481 ** Compute a string length that is limited to what can be stored in
482 ** lower 30 bits of a 32-bit signed integer.
483 */
@@ -575,10 +553,783 @@
575 if( zResult && *zResult ) shell_add_history(zResult);
576 #endif
577 }
578 return zResult;
579 }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
580
581 #if defined(SQLITE_ENABLE_SESSION)
582 /*
583 ** State information for a single open session
584 */
@@ -608,17 +1359,14 @@
608 ** instance of the following structure.
609 */
610 typedef struct ShellState ShellState;
611 struct ShellState {
612 sqlite3 *db; /* The database */
613 int echoOn; /* True to echo input commands */
614 int autoExplain; /* Automatically turn on .explain mode */
615 int autoEQP; /* Run EXPLAIN QUERY PLAN prior to seach SQL stmt */
616 int statsOn; /* True to display memory stats before each finalize */
617 int scanstatsOn; /* True to display scan stats before each finalize */
618 int countChanges; /* True to display change counts */
619 int backslashOn; /* Resolve C-style \x escapes in SQL input text */
620 int outCount; /* Revert to stdout when reaching zero */
621 int cnt; /* Number of records displayed so far */
622 FILE *out; /* Write results here */
623 FILE *traceOut; /* Output for sqlite3_trace() */
624 int nErr; /* Number of errors seen */
@@ -653,13 +1401,24 @@
653 };
654
655 /*
656 ** These are the allowed shellFlgs values
657 */
658 #define SHFLG_Scratch 0x00001 /* The --scratch option is used */
659 #define SHFLG_Pagecache 0x00002 /* The --pagecache option is used */
660 #define SHFLG_Lookaside 0x00004 /* Lookaside memory is used */
 
 
 
 
 
 
 
 
 
 
 
661
662 /*
663 ** These are the allowed modes.
664 */
665 #define MODE_Line 0 /* One column per line. Blank line between records */
@@ -729,36 +1488,56 @@
729 raw_printf(out,"'");
730 }
731
732 /*
733 ** Output the given string as a quoted string using SQL quoting conventions.
 
 
 
734 */
735 static void output_quoted_string(FILE *out, const char *z){
736 int i;
737 int nSingle = 0;
738 setBinaryMode(out, 1);
739 for(i=0; z[i]; i++){
740 if( z[i]=='\'' ) nSingle++;
741 }
742 if( nSingle==0 ){
743 utf8_printf(out,"'%s'",z);
744 }else{
745 raw_printf(out,"'");
 
746 while( *z ){
747 for(i=0; z[i] && z[i]!='\''; i++){}
748 if( i==0 ){
749 raw_printf(out,"''");
750 z++;
751 }else if( z[i]=='\'' ){
752 utf8_printf(out,"%.*s''",i,z);
753 z += i+1;
754 }else{
755 utf8_printf(out,"%s",z);
 
 
 
 
 
 
 
 
 
 
 
 
756 break;
757 }
 
 
 
 
 
 
758 }
759 raw_printf(out,"'");
760 }
761 setTextMode(out, 1);
762 }
763
764 /*
@@ -1246,13 +2025,17 @@
1246 if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){
1247 utf8_printf(p->out,"%sNULL",zSep);
1248 }else if( aiType && aiType[i]==SQLITE_TEXT ){
1249 if( zSep[0] ) utf8_printf(p->out,"%s",zSep);
1250 output_quoted_string(p->out, azArg[i]);
1251 }else if( aiType && (aiType[i]==SQLITE_INTEGER
1252 || aiType[i]==SQLITE_FLOAT) ){
1253 utf8_printf(p->out,"%s%s",zSep, azArg[i]);
 
 
 
 
 
1254 }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){
1255 const void *pBlob = sqlite3_column_blob(p->pStmt, i);
1256 int nBlob = sqlite3_column_bytes(p->pStmt, i);
1257 if( zSep[0] ) utf8_printf(p->out,"%s",zSep);
1258 output_hex_blob(p->out, pBlob, nBlob);
@@ -1292,92 +2075,106 @@
1292 */
1293 static int callback(void *pArg, int nArg, char **azArg, char **azCol){
1294 /* since we don't have type info, call the shell_callback with a NULL value */
1295 return shell_callback(pArg, nArg, azArg, azCol, NULL);
1296 }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1297
1298 /*
1299 ** Set the destination table field of the ShellState structure to
1300 ** the name of the table given. Escape any quote characters in the
1301 ** table name.
1302 */
1303 static void set_table_name(ShellState *p, const char *zName){
1304 int i, n;
1305 int needQuote;
1306 char *z;
1307
1308 if( p->zDestTable ){
1309 free(p->zDestTable);
1310 p->zDestTable = 0;
1311 }
1312 if( zName==0 ) return;
1313 needQuote = !isalpha((unsigned char)*zName) && *zName!='_';
1314 for(i=n=0; zName[i]; i++, n++){
1315 if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ){
1316 needQuote = 1;
1317 if( zName[i]=='\'' ) n++;
1318 }
1319 }
1320 if( needQuote ) n += 2;
1321 z = p->zDestTable = malloc( n+1 );
1322 if( z==0 ){
1323 raw_printf(stderr,"Error: out of memory\n");
1324 exit(1);
1325 }
1326 n = 0;
1327 if( needQuote ) z[n++] = '\'';
1328 for(i=0; zName[i]; i++){
1329 z[n++] = zName[i];
1330 if( zName[i]=='\'' ) z[n++] = '\'';
1331 }
1332 if( needQuote ) z[n++] = '\'';
1333 z[n] = 0;
1334 }
1335
1336 /* zIn is either a pointer to a NULL-terminated string in memory obtained
1337 ** from malloc(), or a NULL pointer. The string pointed to by zAppend is
1338 ** added to zIn, and the result returned in memory obtained from malloc().
1339 ** zIn, if it was not NULL, is freed.
1340 **
1341 ** If the third argument, quote, is not '\0', then it is used as a
1342 ** quote character for zAppend.
1343 */
1344 static char *appendText(char *zIn, char const *zAppend, char quote){
1345 int len;
1346 int i;
1347 int nAppend = strlen30(zAppend);
1348 int nIn = (zIn?strlen30(zIn):0);
1349
1350 len = nAppend+nIn+1;
1351 if( quote ){
1352 len += 2;
1353 for(i=0; i<nAppend; i++){
1354 if( zAppend[i]==quote ) len++;
1355 }
1356 }
1357
1358 zIn = (char *)realloc(zIn, len);
1359 if( !zIn ){
1360 return 0;
1361 }
1362
1363 if( quote ){
1364 char *zCsr = &zIn[nIn];
1365 *zCsr++ = quote;
1366 for(i=0; i<nAppend; i++){
1367 *zCsr++ = zAppend[i];
1368 if( zAppend[i]==quote ) *zCsr++ = quote;
1369 }
1370 *zCsr++ = quote;
1371 *zCsr++ = '\0';
1372 assert( (zCsr-zIn)==len );
1373 }else{
1374 memcpy(&zIn[nIn], zAppend, nAppend);
1375 zIn[len-1] = '\0';
1376 }
1377
1378 return zIn;
1379 }
1380
1381
1382 /*
1383 ** Execute a query statement that will generate SQL output. Print
@@ -1484,10 +2281,35 @@
1484 }
1485 fclose(in);
1486 }
1487 #endif
1488
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1489
1490 /*
1491 ** Display memory stats.
1492 */
1493 static int display_stats(
@@ -1497,61 +2319,35 @@
1497 ){
1498 int iCur;
1499 int iHiwtr;
1500
1501 if( pArg && pArg->out ){
1502
1503 iHiwtr = iCur = -1;
1504 sqlite3_status(SQLITE_STATUS_MEMORY_USED, &iCur, &iHiwtr, bReset);
1505 raw_printf(pArg->out,
1506 "Memory Used: %d (max %d) bytes\n",
1507 iCur, iHiwtr);
1508 iHiwtr = iCur = -1;
1509 sqlite3_status(SQLITE_STATUS_MALLOC_COUNT, &iCur, &iHiwtr, bReset);
1510 raw_printf(pArg->out, "Number of Outstanding Allocations: %d (max %d)\n",
1511 iCur, iHiwtr);
1512 if( pArg->shellFlgs & SHFLG_Pagecache ){
1513 iHiwtr = iCur = -1;
1514 sqlite3_status(SQLITE_STATUS_PAGECACHE_USED, &iCur, &iHiwtr, bReset);
1515 raw_printf(pArg->out,
1516 "Number of Pcache Pages Used: %d (max %d) pages\n",
1517 iCur, iHiwtr);
1518 }
1519 iHiwtr = iCur = -1;
1520 sqlite3_status(SQLITE_STATUS_PAGECACHE_OVERFLOW, &iCur, &iHiwtr, bReset);
1521 raw_printf(pArg->out,
1522 "Number of Pcache Overflow Bytes: %d (max %d) bytes\n",
1523 iCur, iHiwtr);
1524 if( pArg->shellFlgs & SHFLG_Scratch ){
1525 iHiwtr = iCur = -1;
1526 sqlite3_status(SQLITE_STATUS_SCRATCH_USED, &iCur, &iHiwtr, bReset);
1527 raw_printf(pArg->out,
1528 "Number of Scratch Allocations Used: %d (max %d)\n",
1529 iCur, iHiwtr);
1530 }
1531 iHiwtr = iCur = -1;
1532 sqlite3_status(SQLITE_STATUS_SCRATCH_OVERFLOW, &iCur, &iHiwtr, bReset);
1533 raw_printf(pArg->out,
1534 "Number of Scratch Overflow Bytes: %d (max %d) bytes\n",
1535 iCur, iHiwtr);
1536 iHiwtr = iCur = -1;
1537 sqlite3_status(SQLITE_STATUS_MALLOC_SIZE, &iCur, &iHiwtr, bReset);
1538 raw_printf(pArg->out, "Largest Allocation: %d bytes\n",
1539 iHiwtr);
1540 iHiwtr = iCur = -1;
1541 sqlite3_status(SQLITE_STATUS_PAGECACHE_SIZE, &iCur, &iHiwtr, bReset);
1542 raw_printf(pArg->out, "Largest Pcache Allocation: %d bytes\n",
1543 iHiwtr);
1544 iHiwtr = iCur = -1;
1545 sqlite3_status(SQLITE_STATUS_SCRATCH_SIZE, &iCur, &iHiwtr, bReset);
1546 raw_printf(pArg->out, "Largest Scratch Allocation: %d bytes\n",
1547 iHiwtr);
1548 #ifdef YYTRACKMAXSTACKDEPTH
1549 iHiwtr = iCur = -1;
1550 sqlite3_status(SQLITE_STATUS_PARSER_STACK, &iCur, &iHiwtr, bReset);
1551 raw_printf(pArg->out, "Deepest Parser Stack: %d (max %d)\n",
1552 iCur, iHiwtr);
1553 #endif
1554 }
1555
1556 if( pArg && pArg->out && db ){
1557 if( pArg->shellFlgs & SHFLG_Lookaside ){
@@ -1934,11 +2730,11 @@
1934 pArg->pStmt = pStmt;
1935 pArg->cnt = 0;
1936 }
1937
1938 /* echo the sql statement if echo on */
1939 if( pArg && pArg->echoOn ){
1940 utf8_printf(pArg->out, "%s\n", zStmtSql ? zStmtSql : zSql);
1941 }
1942
1943 /* Show the EXPLAIN QUERY PLAN if .eqp is on */
1944 if( pArg && pArg->autoEQP && sqlite3_strlike("EXPLAIN%",zStmtSql,0)!=0 ){
@@ -2022,10 +2818,142 @@
2022 } /* end while */
2023
2024 return rc;
2025 }
2026
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2027
2028 /*
2029 ** This is a different callback routine used for dumping the database.
2030 ** Each row received by this callback consists of a table name,
2031 ** the table type ("index" or "table") and SQL to create the table.
@@ -2034,21 +2962,20 @@
2034 static int dump_callback(void *pArg, int nArg, char **azArg, char **azCol){
2035 int rc;
2036 const char *zTable;
2037 const char *zType;
2038 const char *zSql;
2039 const char *zPrepStmt = 0;
2040 ShellState *p = (ShellState *)pArg;
2041
2042 UNUSED_PARAMETER(azCol);
2043 if( nArg!=3 ) return 1;
2044 zTable = azArg[0];
2045 zType = azArg[1];
2046 zSql = azArg[2];
2047
2048 if( strcmp(zTable, "sqlite_sequence")==0 ){
2049 zPrepStmt = "DELETE FROM sqlite_sequence;\n";
2050 }else if( sqlite3_strglob("sqlite_stat?", zTable)==0 ){
2051 raw_printf(p->out, "ANALYZE sqlite_master;\n");
2052 }else if( strncmp(zTable, "sqlite_", 7)==0 ){
2053 return 0;
2054 }else if( strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){
@@ -2067,62 +2994,74 @@
2067 }else{
2068 printSchemaLine(p->out, zSql, ";\n");
2069 }
2070
2071 if( strcmp(zType, "table")==0 ){
2072 sqlite3_stmt *pTableInfo = 0;
2073 char *zSelect = 0;
2074 char *zTableInfo = 0;
2075 char *zTmp = 0;
2076 int nRow = 0;
2077
2078 zTableInfo = appendText(zTableInfo, "PRAGMA table_info(", 0);
2079 zTableInfo = appendText(zTableInfo, zTable, '"');
2080 zTableInfo = appendText(zTableInfo, ");", 0);
2081
2082 rc = sqlite3_prepare_v2(p->db, zTableInfo, -1, &pTableInfo, 0);
2083 free(zTableInfo);
2084 if( rc!=SQLITE_OK || !pTableInfo ){
2085 return 1;
2086 }
2087
2088 zSelect = appendText(zSelect, "SELECT 'INSERT INTO ' || ", 0);
2089 /* Always quote the table name, even if it appears to be pure ascii,
2090 ** in case it is a keyword. Ex: INSERT INTO "table" ... */
2091 zTmp = appendText(zTmp, zTable, '"');
2092 if( zTmp ){
2093 zSelect = appendText(zSelect, zTmp, '\'');
2094 free(zTmp);
2095 }
2096 zSelect = appendText(zSelect, " || ' VALUES(' || ", 0);
2097 rc = sqlite3_step(pTableInfo);
2098 while( rc==SQLITE_ROW ){
2099 const char *zText = (const char *)sqlite3_column_text(pTableInfo, 1);
2100 zSelect = appendText(zSelect, "quote(", 0);
2101 zSelect = appendText(zSelect, zText, '"');
2102 rc = sqlite3_step(pTableInfo);
2103 if( rc==SQLITE_ROW ){
2104 zSelect = appendText(zSelect, "), ", 0);
2105 }else{
2106 zSelect = appendText(zSelect, ") ", 0);
2107 }
2108 nRow++;
2109 }
2110 rc = sqlite3_finalize(pTableInfo);
2111 if( rc!=SQLITE_OK || nRow==0 ){
2112 free(zSelect);
2113 return 1;
2114 }
2115 zSelect = appendText(zSelect, "|| ')' FROM ", 0);
2116 zSelect = appendText(zSelect, zTable, '"');
2117
2118 rc = run_table_dump_query(p, zSelect, zPrepStmt);
2119 if( rc==SQLITE_CORRUPT ){
2120 zSelect = appendText(zSelect, " ORDER BY rowid DESC", 0);
2121 run_table_dump_query(p, zSelect, 0);
2122 }
2123 free(zSelect);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2124 }
2125 return 0;
2126 }
2127
2128 /*
@@ -2228,15 +3167,17 @@
2228 ".restore ?DB? FILE Restore content of DB (default \"main\") from FILE\n"
2229 ".save FILE Write in-memory database into FILE\n"
2230 ".scanstats on|off Turn sqlite3_stmt_scanstatus() metrics on or off\n"
2231 ".schema ?PATTERN? Show the CREATE statements matching PATTERN\n"
2232 " Add --indent for pretty-printing\n"
 
2233 ".separator COL ?ROW? Change the column separator and optionally the row\n"
2234 " separator for both the output mode and .import\n"
2235 #if defined(SQLITE_ENABLE_SESSION)
2236 ".session CMD ... Create or control sessions\n"
2237 #endif
 
2238 ".shell CMD ARGS... Run CMD ARGS... in a system shell\n"
2239 ".show Show the current values for various settings\n"
2240 ".stats ?on|off? Show stats or turn stats on or off\n"
2241 ".system CMD ARGS... Run CMD ARGS... in a system shell\n"
2242 ".tables ?TABLE? List names of tables\n"
@@ -2423,14 +3364,10 @@
2423 static void open_db(ShellState *p, int keepAlive){
2424 if( p->db==0 ){
2425 sqlite3_initialize();
2426 sqlite3_open(p->zDbFilename, &p->db);
2427 globalDb = p->db;
2428 if( p->db && sqlite3_errcode(p->db)==SQLITE_OK ){
2429 sqlite3_create_function(p->db, "shellstatic", 0, SQLITE_UTF8, 0,
2430 shellstaticFunc, 0, 0);
2431 }
2432 if( p->db==0 || SQLITE_OK!=sqlite3_errcode(p->db) ){
2433 utf8_printf(stderr,"Error: unable to open database \"%s\": %s\n",
2434 p->zDbFilename, sqlite3_errmsg(p->db));
2435 if( keepAlive ) return;
2436 exit(1);
@@ -2440,10 +3377,18 @@
2440 #endif
2441 sqlite3_create_function(p->db, "readfile", 1, SQLITE_UTF8, 0,
2442 readfileFunc, 0, 0);
2443 sqlite3_create_function(p->db, "writefile", 2, SQLITE_UTF8, 0,
2444 writefileFunc, 0, 0);
 
 
 
 
 
 
 
 
2445 }
2446 }
2447
2448 /*
2449 ** Do C-language style dequoting.
@@ -2564,11 +3509,11 @@
2564
2565 /*
2566 ** Interpret zArg as either an integer or a boolean value. Return 1 or 0
2567 ** for TRUE and FALSE. Return the integer value if appropriate.
2568 */
2569 static int booleanValue(char *zArg){
2570 int i;
2571 if( zArg[0]=='0' && zArg[1]=='x' ){
2572 for(i=2; hexDigitValue(zArg[i])>=0; i++){}
2573 }else{
2574 for(i=0; zArg[i]>='0' && zArg[i]<='9'; i++){}
@@ -2582,10 +3527,21 @@
2582 }
2583 utf8_printf(stderr, "ERROR: Not a boolean value: \"%s\". Assuming \"no\".\n",
2584 zArg);
2585 return 0;
2586 }
 
 
 
 
 
 
 
 
 
 
 
2587
2588 /*
2589 ** Close an output file, assuming it is not stderr or stdout
2590 */
2591 static void output_file_close(FILE *f){
@@ -3656,11 +4612,11 @@
3656 test_breakpoint();
3657 }else
3658
3659 if( c=='c' && n>=3 && strncmp(azArg[0], "changes", n)==0 ){
3660 if( nArg==2 ){
3661 p->countChanges = booleanValue(azArg[1]);
3662 }else{
3663 raw_printf(stderr, "Usage: .changes on|off\n");
3664 rc = 1;
3665 }
3666 }else
@@ -3720,25 +4676,46 @@
3720 if( c=='d' && strncmp(azArg[0], "dbinfo", n)==0 ){
3721 rc = shell_dbinfo_command(p, nArg, azArg);
3722 }else
3723
3724 if( c=='d' && strncmp(azArg[0], "dump", n)==0 ){
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3725 open_db(p, 0);
3726 /* When playing back a "dump", the content might appear in an order
3727 ** which causes immediate foreign key constraints to be violated.
3728 ** So disable foreign-key constraint enforcement to prevent problems. */
3729 if( nArg!=1 && nArg!=2 ){
3730 raw_printf(stderr, "Usage: .dump ?LIKE-PATTERN?\n");
3731 rc = 1;
3732 goto meta_command_exit;
3733 }
3734 raw_printf(p->out, "PRAGMA foreign_keys=OFF;\n");
3735 raw_printf(p->out, "BEGIN TRANSACTION;\n");
3736 p->writableSchema = 0;
 
 
 
3737 sqlite3_exec(p->db, "SAVEPOINT dump; PRAGMA writable_schema=ON", 0, 0, 0);
3738 p->nErr = 0;
3739 if( nArg==1 ){
3740 run_schema_dump_query(p,
3741 "SELECT name, type, sql FROM sqlite_master "
3742 "WHERE sql NOT NULL AND type=='table' AND name!='sqlite_sequence'"
3743 );
3744 run_schema_dump_query(p,
@@ -3748,25 +4725,24 @@
3748 run_table_dump_query(p,
3749 "SELECT sql FROM sqlite_master "
3750 "WHERE sql NOT NULL AND type IN ('index','trigger','view')", 0
3751 );
3752 }else{
3753 int i;
3754 for(i=1; i<nArg; i++){
3755 zShellStatic = azArg[i];
3756 run_schema_dump_query(p,
3757 "SELECT name, type, sql FROM sqlite_master "
3758 "WHERE tbl_name LIKE shellstatic() AND type=='table'"
3759 " AND sql NOT NULL");
3760 run_table_dump_query(p,
3761 "SELECT sql FROM sqlite_master "
3762 "WHERE sql NOT NULL"
3763 " AND type IN ('index','trigger','view')"
3764 " AND tbl_name LIKE shellstatic()", 0
3765 );
3766 zShellStatic = 0;
3767 }
3768 }
3769 if( p->writableSchema ){
3770 raw_printf(p->out, "PRAGMA writable_schema=OFF;\n");
3771 p->writableSchema = 0;
3772 }
@@ -3775,11 +4751,11 @@
3775 raw_printf(p->out, p->nErr ? "ROLLBACK; -- due to errors\n" : "COMMIT;\n");
3776 }else
3777
3778 if( c=='e' && strncmp(azArg[0], "echo", n)==0 ){
3779 if( nArg==2 ){
3780 p->echoOn = booleanValue(azArg[1]);
3781 }else{
3782 raw_printf(stderr, "Usage: .echo on|off\n");
3783 rc = 1;
3784 }
3785 }else
@@ -4572,21 +5548,21 @@
4572 new_colv[0] = "sql";
4573 new_colv[1] = 0;
4574 callback(&data, 1, new_argv, new_colv);
4575 rc = SQLITE_OK;
4576 }else{
4577 zShellStatic = azArg[1];
4578 rc = sqlite3_exec(p->db,
4579 "SELECT sql FROM "
4580 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
4581 " FROM sqlite_master UNION ALL"
4582 " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
4583 "WHERE lower(tbl_name) LIKE shellstatic()"
4584 " AND type!='meta' AND sql NOTNULL "
4585 "ORDER BY rowid",
4586 callback, &data, &zErrMsg);
4587 zShellStatic = 0;
4588 }
4589 }else if( nArg==1 ){
4590 rc = sqlite3_exec(p->db,
4591 "SELECT sql FROM "
4592 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
@@ -4835,10 +5811,123 @@
4835 utf8_printf(p->out, "%s", zBuf);
4836 }
4837 }
4838 }else
4839 #endif
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4840
4841 if( c=='s' && strncmp(azArg[0], "separator", n)==0 ){
4842 if( nArg<2 || nArg>3 ){
4843 raw_printf(stderr, "Usage: .separator COL ?ROW?\n");
4844 rc = 1;
@@ -4850,10 +5939,126 @@
4850 if( nArg>=3 ){
4851 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator,
4852 "%.*s", (int)ArraySize(p->rowSeparator)-1, azArg[2]);
4853 }
4854 }else
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4855
4856 if( c=='s'
4857 && (strncmp(azArg[0], "shell", n)==0 || strncmp(azArg[0],"system",n)==0)
4858 ){
4859 char *zCmd;
@@ -4879,11 +6084,12 @@
4879 if( nArg!=1 ){
4880 raw_printf(stderr, "Usage: .show\n");
4881 rc = 1;
4882 goto meta_command_exit;
4883 }
4884 utf8_printf(p->out, "%12.12s: %s\n","echo", azBool[p->echoOn!=0]);
 
4885 utf8_printf(p->out, "%12.12s: %s\n","eqp", azBool[p->autoEQP&3]);
4886 utf8_printf(p->out, "%12.12s: %s\n","explain",
4887 p->mode==MODE_Explain ? "on" : p->autoExplain ? "auto" : "off");
4888 utf8_printf(p->out,"%12.12s: %s\n","headers", azBool[p->showHeader!=0]);
4889 utf8_printf(p->out, "%12.12s: %s\n","mode", modeDescr[p->mode]);
@@ -5444,11 +6650,11 @@
5444 static int runOneSqlLine(ShellState *p, char *zSql, FILE *in, int startline){
5445 int rc;
5446 char *zErrMsg = 0;
5447
5448 open_db(p, 0);
5449 if( p->backslashOn ) resolve_backslashes(zSql);
5450 BEGIN_TIMER;
5451 rc = shell_exec(p->db, zSql, shell_callback, p, &zErrMsg);
5452 END_TIMER;
5453 if( rc || zErrMsg ){
5454 char zPrefix[100];
@@ -5464,11 +6670,11 @@
5464 zErrMsg = 0;
5465 }else{
5466 utf8_printf(stderr, "%s %s\n", zPrefix, sqlite3_errmsg(p->db));
5467 }
5468 return 1;
5469 }else if( p->countChanges ){
5470 raw_printf(p->out, "changes: %3d total_changes: %d\n",
5471 sqlite3_changes(p->db), sqlite3_total_changes(p->db));
5472 }
5473 return 0;
5474 }
@@ -5507,15 +6713,15 @@
5507 if( in!=0 ) break;
5508 seenInterrupt = 0;
5509 }
5510 lineno++;
5511 if( nSql==0 && _all_whitespace(zLine) ){
5512 if( p->echoOn ) printf("%s\n", zLine);
5513 continue;
5514 }
5515 if( zLine && zLine[0]=='.' && nSql==0 ){
5516 if( p->echoOn ) printf("%s\n", zLine);
5517 rc = do_meta_command(zLine, p);
5518 if( rc==2 ){ /* exit requested */
5519 break;
5520 }else if( rc ){
5521 errCnt++;
@@ -5554,11 +6760,11 @@
5554 if( p->outCount ){
5555 output_reset(p);
5556 p->outCount = 0;
5557 }
5558 }else if( nSql && _all_whitespace(zSql) ){
5559 if( p->echoOn ) printf("%s\n", zSql);
5560 nSql = 0;
5561 }
5562 }
5563 if( nSql && !_all_whitespace(zSql) ){
5564 runOneSqlLine(p, zSql, in, startline);
@@ -6023,11 +7229,11 @@
6023 }else if( strcmp(z,"-header")==0 ){
6024 data.showHeader = 1;
6025 }else if( strcmp(z,"-noheader")==0 ){
6026 data.showHeader = 0;
6027 }else if( strcmp(z,"-echo")==0 ){
6028 data.echoOn = 1;
6029 }else if( strcmp(z,"-eqp")==0 ){
6030 data.autoEQP = 1;
6031 }else if( strcmp(z,"-eqpfull")==0 ){
6032 data.autoEQP = 2;
6033 }else if( strcmp(z,"-stats")==0 ){
@@ -6038,11 +7244,11 @@
6038 /* Undocumented command-line option: -backslash
6039 ** Causes C-style backslash escapes to be evaluated in SQL statements
6040 ** prior to sending the SQL into SQLite. Useful for injecting
6041 ** crazy bytes in the middle of SQL statements for testing and debugging.
6042 */
6043 data.backslashOn = 1;
6044 }else if( strcmp(z,"-bail")==0 ){
6045 bail_on_error = 1;
6046 }else if( strcmp(z,"-version")==0 ){
6047 printf("%s %s\n", sqlite3_libversion(), sqlite3_sourceid());
6048 return 0;
6049
--- src/shell.c
+++ src/shell.c
@@ -452,32 +452,10 @@
452 while( IsDigit(*z) ){ z++; }
453 if( realnum ) *realnum = 1;
454 }
455 return *z==0;
456 }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
457
458 /*
459 ** Compute a string length that is limited to what can be stored in
460 ** lower 30 bits of a 32-bit signed integer.
461 */
@@ -575,10 +553,783 @@
553 if( zResult && *zResult ) shell_add_history(zResult);
554 #endif
555 }
556 return zResult;
557 }
558 /*
559 ** A variable length string to which one can append text.
560 */
561 typedef struct ShellText ShellText;
562 struct ShellText {
563 char *z;
564 int n;
565 int nAlloc;
566 };
567
568 /*
569 ** Initialize and destroy a ShellText object
570 */
571 static void initText(ShellText *p){
572 memset(p, 0, sizeof(*p));
573 }
574 static void freeText(ShellText *p){
575 free(p->z);
576 initText(p);
577 }
578
579 /* zIn is either a pointer to a NULL-terminated string in memory obtained
580 ** from malloc(), or a NULL pointer. The string pointed to by zAppend is
581 ** added to zIn, and the result returned in memory obtained from malloc().
582 ** zIn, if it was not NULL, is freed.
583 **
584 ** If the third argument, quote, is not '\0', then it is used as a
585 ** quote character for zAppend.
586 */
587 static void appendText(ShellText *p, char const *zAppend, char quote){
588 int len;
589 int i;
590 int nAppend = strlen30(zAppend);
591
592 len = nAppend+p->n+1;
593 if( quote ){
594 len += 2;
595 for(i=0; i<nAppend; i++){
596 if( zAppend[i]==quote ) len++;
597 }
598 }
599
600 if( p->n+len>=p->nAlloc ){
601 p->nAlloc = p->nAlloc*2 + len + 20;
602 p->z = realloc(p->z, p->nAlloc);
603 if( p->z==0 ){
604 memset(p, 0, sizeof(*p));
605 return;
606 }
607 }
608
609 if( quote ){
610 char *zCsr = p->z+p->n;
611 *zCsr++ = quote;
612 for(i=0; i<nAppend; i++){
613 *zCsr++ = zAppend[i];
614 if( zAppend[i]==quote ) *zCsr++ = quote;
615 }
616 *zCsr++ = quote;
617 p->n = (int)(zCsr - p->z);
618 *zCsr = '\0';
619 }else{
620 memcpy(p->z+p->n, zAppend, nAppend);
621 p->n += nAppend;
622 p->z[p->n] = '\0';
623 }
624 }
625
626 /*
627 ** Attempt to determine if identifier zName needs to be quoted, either
628 ** because it contains non-alphanumeric characters, or because it is an
629 ** SQLite keyword. Be conservative in this estimate: When in doubt assume
630 ** that quoting is required.
631 **
632 ** Return '"' if quoting is required. Return 0 if no quoting is required.
633 */
634 static char quoteChar(const char *zName){
635 /* All SQLite keywords, in alphabetical order */
636 static const char *azKeywords[] = {
637 "ABORT", "ACTION", "ADD", "AFTER", "ALL", "ALTER", "ANALYZE", "AND", "AS",
638 "ASC", "ATTACH", "AUTOINCREMENT", "BEFORE", "BEGIN", "BETWEEN", "BY",
639 "CASCADE", "CASE", "CAST", "CHECK", "COLLATE", "COLUMN", "COMMIT",
640 "CONFLICT", "CONSTRAINT", "CREATE", "CROSS", "CURRENT_DATE",
641 "CURRENT_TIME", "CURRENT_TIMESTAMP", "DATABASE", "DEFAULT", "DEFERRABLE",
642 "DEFERRED", "DELETE", "DESC", "DETACH", "DISTINCT", "DROP", "EACH",
643 "ELSE", "END", "ESCAPE", "EXCEPT", "EXCLUSIVE", "EXISTS", "EXPLAIN",
644 "FAIL", "FOR", "FOREIGN", "FROM", "FULL", "GLOB", "GROUP", "HAVING", "IF",
645 "IGNORE", "IMMEDIATE", "IN", "INDEX", "INDEXED", "INITIALLY", "INNER",
646 "INSERT", "INSTEAD", "INTERSECT", "INTO", "IS", "ISNULL", "JOIN", "KEY",
647 "LEFT", "LIKE", "LIMIT", "MATCH", "NATURAL", "NO", "NOT", "NOTNULL",
648 "NULL", "OF", "OFFSET", "ON", "OR", "ORDER", "OUTER", "PLAN", "PRAGMA",
649 "PRIMARY", "QUERY", "RAISE", "RECURSIVE", "REFERENCES", "REGEXP",
650 "REINDEX", "RELEASE", "RENAME", "REPLACE", "RESTRICT", "RIGHT",
651 "ROLLBACK", "ROW", "SAVEPOINT", "SELECT", "SET", "TABLE", "TEMP",
652 "TEMPORARY", "THEN", "TO", "TRANSACTION", "TRIGGER", "UNION", "UNIQUE",
653 "UPDATE", "USING", "VACUUM", "VALUES", "VIEW", "VIRTUAL", "WHEN", "WHERE",
654 "WITH", "WITHOUT",
655 };
656 int i, lwr, upr, mid, c;
657 if( !isalpha((unsigned char)zName[0]) && zName[0]!='_' ) return '"';
658 for(i=0; zName[i]; i++){
659 if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ) return '"';
660 }
661 lwr = 0;
662 upr = sizeof(azKeywords)/sizeof(azKeywords[0]) - 1;
663 while( lwr<=upr ){
664 mid = (lwr+upr)/2;
665 c = sqlite3_stricmp(azKeywords[mid], zName);
666 if( c==0 ) return '"';
667 if( c<0 ){
668 lwr = mid+1;
669 }else{
670 upr = mid-1;
671 }
672 }
673 return 0;
674 }
675
676 /******************************************************************************
677 ** SHA3 hash implementation copied from ../ext/misc/shathree.c
678 */
679 typedef sqlite3_uint64 u64;
680 /*
681 ** Macros to determine whether the machine is big or little endian,
682 ** and whether or not that determination is run-time or compile-time.
683 **
684 ** For best performance, an attempt is made to guess at the byte-order
685 ** using C-preprocessor macros. If that is unsuccessful, or if
686 ** -DSHA3_BYTEORDER=0 is set, then byte-order is determined
687 ** at run-time.
688 */
689 #ifndef SHA3_BYTEORDER
690 # if defined(i386) || defined(__i386__) || defined(_M_IX86) || \
691 defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) || \
692 defined(_M_AMD64) || defined(_M_ARM) || defined(__x86) || \
693 defined(__arm__)
694 # define SHA3_BYTEORDER 1234
695 # elif defined(sparc) || defined(__ppc__)
696 # define SHA3_BYTEORDER 4321
697 # else
698 # define SHA3_BYTEORDER 0
699 # endif
700 #endif
701
702
703 /*
704 ** State structure for a SHA3 hash in progress
705 */
706 typedef struct SHA3Context SHA3Context;
707 struct SHA3Context {
708 union {
709 u64 s[25]; /* Keccak state. 5x5 lines of 64 bits each */
710 unsigned char x[1600]; /* ... or 1600 bytes */
711 } u;
712 unsigned nRate; /* Bytes of input accepted per Keccak iteration */
713 unsigned nLoaded; /* Input bytes loaded into u.x[] so far this cycle */
714 unsigned ixMask; /* Insert next input into u.x[nLoaded^ixMask]. */
715 };
716
717 /*
718 ** A single step of the Keccak mixing function for a 1600-bit state
719 */
720 static void KeccakF1600Step(SHA3Context *p){
721 int i;
722 u64 B0, B1, B2, B3, B4;
723 u64 C0, C1, C2, C3, C4;
724 u64 D0, D1, D2, D3, D4;
725 static const u64 RC[] = {
726 0x0000000000000001ULL, 0x0000000000008082ULL,
727 0x800000000000808aULL, 0x8000000080008000ULL,
728 0x000000000000808bULL, 0x0000000080000001ULL,
729 0x8000000080008081ULL, 0x8000000000008009ULL,
730 0x000000000000008aULL, 0x0000000000000088ULL,
731 0x0000000080008009ULL, 0x000000008000000aULL,
732 0x000000008000808bULL, 0x800000000000008bULL,
733 0x8000000000008089ULL, 0x8000000000008003ULL,
734 0x8000000000008002ULL, 0x8000000000000080ULL,
735 0x000000000000800aULL, 0x800000008000000aULL,
736 0x8000000080008081ULL, 0x8000000000008080ULL,
737 0x0000000080000001ULL, 0x8000000080008008ULL
738 };
739 # define A00 (p->u.s[0])
740 # define A01 (p->u.s[1])
741 # define A02 (p->u.s[2])
742 # define A03 (p->u.s[3])
743 # define A04 (p->u.s[4])
744 # define A10 (p->u.s[5])
745 # define A11 (p->u.s[6])
746 # define A12 (p->u.s[7])
747 # define A13 (p->u.s[8])
748 # define A14 (p->u.s[9])
749 # define A20 (p->u.s[10])
750 # define A21 (p->u.s[11])
751 # define A22 (p->u.s[12])
752 # define A23 (p->u.s[13])
753 # define A24 (p->u.s[14])
754 # define A30 (p->u.s[15])
755 # define A31 (p->u.s[16])
756 # define A32 (p->u.s[17])
757 # define A33 (p->u.s[18])
758 # define A34 (p->u.s[19])
759 # define A40 (p->u.s[20])
760 # define A41 (p->u.s[21])
761 # define A42 (p->u.s[22])
762 # define A43 (p->u.s[23])
763 # define A44 (p->u.s[24])
764 # define ROL64(a,x) ((a<<x)|(a>>(64-x)))
765
766 for(i=0; i<24; i+=4){
767 C0 = A00^A10^A20^A30^A40;
768 C1 = A01^A11^A21^A31^A41;
769 C2 = A02^A12^A22^A32^A42;
770 C3 = A03^A13^A23^A33^A43;
771 C4 = A04^A14^A24^A34^A44;
772 D0 = C4^ROL64(C1, 1);
773 D1 = C0^ROL64(C2, 1);
774 D2 = C1^ROL64(C3, 1);
775 D3 = C2^ROL64(C4, 1);
776 D4 = C3^ROL64(C0, 1);
777
778 B0 = (A00^D0);
779 B1 = ROL64((A11^D1), 44);
780 B2 = ROL64((A22^D2), 43);
781 B3 = ROL64((A33^D3), 21);
782 B4 = ROL64((A44^D4), 14);
783 A00 = B0 ^((~B1)& B2 );
784 A00 ^= RC[i];
785 A11 = B1 ^((~B2)& B3 );
786 A22 = B2 ^((~B3)& B4 );
787 A33 = B3 ^((~B4)& B0 );
788 A44 = B4 ^((~B0)& B1 );
789
790 B2 = ROL64((A20^D0), 3);
791 B3 = ROL64((A31^D1), 45);
792 B4 = ROL64((A42^D2), 61);
793 B0 = ROL64((A03^D3), 28);
794 B1 = ROL64((A14^D4), 20);
795 A20 = B0 ^((~B1)& B2 );
796 A31 = B1 ^((~B2)& B3 );
797 A42 = B2 ^((~B3)& B4 );
798 A03 = B3 ^((~B4)& B0 );
799 A14 = B4 ^((~B0)& B1 );
800
801 B4 = ROL64((A40^D0), 18);
802 B0 = ROL64((A01^D1), 1);
803 B1 = ROL64((A12^D2), 6);
804 B2 = ROL64((A23^D3), 25);
805 B3 = ROL64((A34^D4), 8);
806 A40 = B0 ^((~B1)& B2 );
807 A01 = B1 ^((~B2)& B3 );
808 A12 = B2 ^((~B3)& B4 );
809 A23 = B3 ^((~B4)& B0 );
810 A34 = B4 ^((~B0)& B1 );
811
812 B1 = ROL64((A10^D0), 36);
813 B2 = ROL64((A21^D1), 10);
814 B3 = ROL64((A32^D2), 15);
815 B4 = ROL64((A43^D3), 56);
816 B0 = ROL64((A04^D4), 27);
817 A10 = B0 ^((~B1)& B2 );
818 A21 = B1 ^((~B2)& B3 );
819 A32 = B2 ^((~B3)& B4 );
820 A43 = B3 ^((~B4)& B0 );
821 A04 = B4 ^((~B0)& B1 );
822
823 B3 = ROL64((A30^D0), 41);
824 B4 = ROL64((A41^D1), 2);
825 B0 = ROL64((A02^D2), 62);
826 B1 = ROL64((A13^D3), 55);
827 B2 = ROL64((A24^D4), 39);
828 A30 = B0 ^((~B1)& B2 );
829 A41 = B1 ^((~B2)& B3 );
830 A02 = B2 ^((~B3)& B4 );
831 A13 = B3 ^((~B4)& B0 );
832 A24 = B4 ^((~B0)& B1 );
833
834 C0 = A00^A20^A40^A10^A30;
835 C1 = A11^A31^A01^A21^A41;
836 C2 = A22^A42^A12^A32^A02;
837 C3 = A33^A03^A23^A43^A13;
838 C4 = A44^A14^A34^A04^A24;
839 D0 = C4^ROL64(C1, 1);
840 D1 = C0^ROL64(C2, 1);
841 D2 = C1^ROL64(C3, 1);
842 D3 = C2^ROL64(C4, 1);
843 D4 = C3^ROL64(C0, 1);
844
845 B0 = (A00^D0);
846 B1 = ROL64((A31^D1), 44);
847 B2 = ROL64((A12^D2), 43);
848 B3 = ROL64((A43^D3), 21);
849 B4 = ROL64((A24^D4), 14);
850 A00 = B0 ^((~B1)& B2 );
851 A00 ^= RC[i+1];
852 A31 = B1 ^((~B2)& B3 );
853 A12 = B2 ^((~B3)& B4 );
854 A43 = B3 ^((~B4)& B0 );
855 A24 = B4 ^((~B0)& B1 );
856
857 B2 = ROL64((A40^D0), 3);
858 B3 = ROL64((A21^D1), 45);
859 B4 = ROL64((A02^D2), 61);
860 B0 = ROL64((A33^D3), 28);
861 B1 = ROL64((A14^D4), 20);
862 A40 = B0 ^((~B1)& B2 );
863 A21 = B1 ^((~B2)& B3 );
864 A02 = B2 ^((~B3)& B4 );
865 A33 = B3 ^((~B4)& B0 );
866 A14 = B4 ^((~B0)& B1 );
867
868 B4 = ROL64((A30^D0), 18);
869 B0 = ROL64((A11^D1), 1);
870 B1 = ROL64((A42^D2), 6);
871 B2 = ROL64((A23^D3), 25);
872 B3 = ROL64((A04^D4), 8);
873 A30 = B0 ^((~B1)& B2 );
874 A11 = B1 ^((~B2)& B3 );
875 A42 = B2 ^((~B3)& B4 );
876 A23 = B3 ^((~B4)& B0 );
877 A04 = B4 ^((~B0)& B1 );
878
879 B1 = ROL64((A20^D0), 36);
880 B2 = ROL64((A01^D1), 10);
881 B3 = ROL64((A32^D2), 15);
882 B4 = ROL64((A13^D3), 56);
883 B0 = ROL64((A44^D4), 27);
884 A20 = B0 ^((~B1)& B2 );
885 A01 = B1 ^((~B2)& B3 );
886 A32 = B2 ^((~B3)& B4 );
887 A13 = B3 ^((~B4)& B0 );
888 A44 = B4 ^((~B0)& B1 );
889
890 B3 = ROL64((A10^D0), 41);
891 B4 = ROL64((A41^D1), 2);
892 B0 = ROL64((A22^D2), 62);
893 B1 = ROL64((A03^D3), 55);
894 B2 = ROL64((A34^D4), 39);
895 A10 = B0 ^((~B1)& B2 );
896 A41 = B1 ^((~B2)& B3 );
897 A22 = B2 ^((~B3)& B4 );
898 A03 = B3 ^((~B4)& B0 );
899 A34 = B4 ^((~B0)& B1 );
900
901 C0 = A00^A40^A30^A20^A10;
902 C1 = A31^A21^A11^A01^A41;
903 C2 = A12^A02^A42^A32^A22;
904 C3 = A43^A33^A23^A13^A03;
905 C4 = A24^A14^A04^A44^A34;
906 D0 = C4^ROL64(C1, 1);
907 D1 = C0^ROL64(C2, 1);
908 D2 = C1^ROL64(C3, 1);
909 D3 = C2^ROL64(C4, 1);
910 D4 = C3^ROL64(C0, 1);
911
912 B0 = (A00^D0);
913 B1 = ROL64((A21^D1), 44);
914 B2 = ROL64((A42^D2), 43);
915 B3 = ROL64((A13^D3), 21);
916 B4 = ROL64((A34^D4), 14);
917 A00 = B0 ^((~B1)& B2 );
918 A00 ^= RC[i+2];
919 A21 = B1 ^((~B2)& B3 );
920 A42 = B2 ^((~B3)& B4 );
921 A13 = B3 ^((~B4)& B0 );
922 A34 = B4 ^((~B0)& B1 );
923
924 B2 = ROL64((A30^D0), 3);
925 B3 = ROL64((A01^D1), 45);
926 B4 = ROL64((A22^D2), 61);
927 B0 = ROL64((A43^D3), 28);
928 B1 = ROL64((A14^D4), 20);
929 A30 = B0 ^((~B1)& B2 );
930 A01 = B1 ^((~B2)& B3 );
931 A22 = B2 ^((~B3)& B4 );
932 A43 = B3 ^((~B4)& B0 );
933 A14 = B4 ^((~B0)& B1 );
934
935 B4 = ROL64((A10^D0), 18);
936 B0 = ROL64((A31^D1), 1);
937 B1 = ROL64((A02^D2), 6);
938 B2 = ROL64((A23^D3), 25);
939 B3 = ROL64((A44^D4), 8);
940 A10 = B0 ^((~B1)& B2 );
941 A31 = B1 ^((~B2)& B3 );
942 A02 = B2 ^((~B3)& B4 );
943 A23 = B3 ^((~B4)& B0 );
944 A44 = B4 ^((~B0)& B1 );
945
946 B1 = ROL64((A40^D0), 36);
947 B2 = ROL64((A11^D1), 10);
948 B3 = ROL64((A32^D2), 15);
949 B4 = ROL64((A03^D3), 56);
950 B0 = ROL64((A24^D4), 27);
951 A40 = B0 ^((~B1)& B2 );
952 A11 = B1 ^((~B2)& B3 );
953 A32 = B2 ^((~B3)& B4 );
954 A03 = B3 ^((~B4)& B0 );
955 A24 = B4 ^((~B0)& B1 );
956
957 B3 = ROL64((A20^D0), 41);
958 B4 = ROL64((A41^D1), 2);
959 B0 = ROL64((A12^D2), 62);
960 B1 = ROL64((A33^D3), 55);
961 B2 = ROL64((A04^D4), 39);
962 A20 = B0 ^((~B1)& B2 );
963 A41 = B1 ^((~B2)& B3 );
964 A12 = B2 ^((~B3)& B4 );
965 A33 = B3 ^((~B4)& B0 );
966 A04 = B4 ^((~B0)& B1 );
967
968 C0 = A00^A30^A10^A40^A20;
969 C1 = A21^A01^A31^A11^A41;
970 C2 = A42^A22^A02^A32^A12;
971 C3 = A13^A43^A23^A03^A33;
972 C4 = A34^A14^A44^A24^A04;
973 D0 = C4^ROL64(C1, 1);
974 D1 = C0^ROL64(C2, 1);
975 D2 = C1^ROL64(C3, 1);
976 D3 = C2^ROL64(C4, 1);
977 D4 = C3^ROL64(C0, 1);
978
979 B0 = (A00^D0);
980 B1 = ROL64((A01^D1), 44);
981 B2 = ROL64((A02^D2), 43);
982 B3 = ROL64((A03^D3), 21);
983 B4 = ROL64((A04^D4), 14);
984 A00 = B0 ^((~B1)& B2 );
985 A00 ^= RC[i+3];
986 A01 = B1 ^((~B2)& B3 );
987 A02 = B2 ^((~B3)& B4 );
988 A03 = B3 ^((~B4)& B0 );
989 A04 = B4 ^((~B0)& B1 );
990
991 B2 = ROL64((A10^D0), 3);
992 B3 = ROL64((A11^D1), 45);
993 B4 = ROL64((A12^D2), 61);
994 B0 = ROL64((A13^D3), 28);
995 B1 = ROL64((A14^D4), 20);
996 A10 = B0 ^((~B1)& B2 );
997 A11 = B1 ^((~B2)& B3 );
998 A12 = B2 ^((~B3)& B4 );
999 A13 = B3 ^((~B4)& B0 );
1000 A14 = B4 ^((~B0)& B1 );
1001
1002 B4 = ROL64((A20^D0), 18);
1003 B0 = ROL64((A21^D1), 1);
1004 B1 = ROL64((A22^D2), 6);
1005 B2 = ROL64((A23^D3), 25);
1006 B3 = ROL64((A24^D4), 8);
1007 A20 = B0 ^((~B1)& B2 );
1008 A21 = B1 ^((~B2)& B3 );
1009 A22 = B2 ^((~B3)& B4 );
1010 A23 = B3 ^((~B4)& B0 );
1011 A24 = B4 ^((~B0)& B1 );
1012
1013 B1 = ROL64((A30^D0), 36);
1014 B2 = ROL64((A31^D1), 10);
1015 B3 = ROL64((A32^D2), 15);
1016 B4 = ROL64((A33^D3), 56);
1017 B0 = ROL64((A34^D4), 27);
1018 A30 = B0 ^((~B1)& B2 );
1019 A31 = B1 ^((~B2)& B3 );
1020 A32 = B2 ^((~B3)& B4 );
1021 A33 = B3 ^((~B4)& B0 );
1022 A34 = B4 ^((~B0)& B1 );
1023
1024 B3 = ROL64((A40^D0), 41);
1025 B4 = ROL64((A41^D1), 2);
1026 B0 = ROL64((A42^D2), 62);
1027 B1 = ROL64((A43^D3), 55);
1028 B2 = ROL64((A44^D4), 39);
1029 A40 = B0 ^((~B1)& B2 );
1030 A41 = B1 ^((~B2)& B3 );
1031 A42 = B2 ^((~B3)& B4 );
1032 A43 = B3 ^((~B4)& B0 );
1033 A44 = B4 ^((~B0)& B1 );
1034 }
1035 }
1036
1037 /*
1038 ** Initialize a new hash. iSize determines the size of the hash
1039 ** in bits and should be one of 224, 256, 384, or 512. Or iSize
1040 ** can be zero to use the default hash size of 256 bits.
1041 */
1042 static void SHA3Init(SHA3Context *p, int iSize){
1043 memset(p, 0, sizeof(*p));
1044 if( iSize>=128 && iSize<=512 ){
1045 p->nRate = (1600 - ((iSize + 31)&~31)*2)/8;
1046 }else{
1047 p->nRate = (1600 - 2*256)/8;
1048 }
1049 #if SHA3_BYTEORDER==1234
1050 /* Known to be little-endian at compile-time. No-op */
1051 #elif SHA3_BYTEORDER==4321
1052 p->ixMask = 7; /* Big-endian */
1053 #else
1054 {
1055 static unsigned int one = 1;
1056 if( 1==*(unsigned char*)&one ){
1057 /* Little endian. No byte swapping. */
1058 p->ixMask = 0;
1059 }else{
1060 /* Big endian. Byte swap. */
1061 p->ixMask = 7;
1062 }
1063 }
1064 #endif
1065 }
1066
1067 /*
1068 ** Make consecutive calls to the SHA3Update function to add new content
1069 ** to the hash
1070 */
1071 static void SHA3Update(
1072 SHA3Context *p,
1073 const unsigned char *aData,
1074 unsigned int nData
1075 ){
1076 unsigned int i = 0;
1077 #if SHA3_BYTEORDER==1234
1078 if( (p->nLoaded % 8)==0 && ((aData - (const unsigned char*)0)&7)==0 ){
1079 for(; i+7<nData; i+=8){
1080 p->u.s[p->nLoaded/8] ^= *(u64*)&aData[i];
1081 p->nLoaded += 8;
1082 if( p->nLoaded>=p->nRate ){
1083 KeccakF1600Step(p);
1084 p->nLoaded = 0;
1085 }
1086 }
1087 }
1088 #endif
1089 for(; i<nData; i++){
1090 #if SHA3_BYTEORDER==1234
1091 p->u.x[p->nLoaded] ^= aData[i];
1092 #elif SHA3_BYTEORDER==4321
1093 p->u.x[p->nLoaded^0x07] ^= aData[i];
1094 #else
1095 p->u.x[p->nLoaded^p->ixMask] ^= aData[i];
1096 #endif
1097 p->nLoaded++;
1098 if( p->nLoaded==p->nRate ){
1099 KeccakF1600Step(p);
1100 p->nLoaded = 0;
1101 }
1102 }
1103 }
1104
1105 /*
1106 ** After all content has been added, invoke SHA3Final() to compute
1107 ** the final hash. The function returns a pointer to the binary
1108 ** hash value.
1109 */
1110 static unsigned char *SHA3Final(SHA3Context *p){
1111 unsigned int i;
1112 if( p->nLoaded==p->nRate-1 ){
1113 const unsigned char c1 = 0x86;
1114 SHA3Update(p, &c1, 1);
1115 }else{
1116 const unsigned char c2 = 0x06;
1117 const unsigned char c3 = 0x80;
1118 SHA3Update(p, &c2, 1);
1119 p->nLoaded = p->nRate - 1;
1120 SHA3Update(p, &c3, 1);
1121 }
1122 for(i=0; i<p->nRate; i++){
1123 p->u.x[i+p->nRate] = p->u.x[i^p->ixMask];
1124 }
1125 return &p->u.x[p->nRate];
1126 }
1127
1128 /*
1129 ** Implementation of the sha3(X,SIZE) function.
1130 **
1131 ** Return a BLOB which is the SIZE-bit SHA3 hash of X. The default
1132 ** size is 256. If X is a BLOB, it is hashed as is.
1133 ** For all other non-NULL types of input, X is converted into a UTF-8 string
1134 ** and the string is hashed without the trailing 0x00 terminator. The hash
1135 ** of a NULL value is NULL.
1136 */
1137 static void sha3Func(
1138 sqlite3_context *context,
1139 int argc,
1140 sqlite3_value **argv
1141 ){
1142 SHA3Context cx;
1143 int eType = sqlite3_value_type(argv[0]);
1144 int nByte = sqlite3_value_bytes(argv[0]);
1145 int iSize;
1146 if( argc==1 ){
1147 iSize = 256;
1148 }else{
1149 iSize = sqlite3_value_int(argv[1]);
1150 if( iSize!=224 && iSize!=256 && iSize!=384 && iSize!=512 ){
1151 sqlite3_result_error(context, "SHA3 size should be one of: 224 256 "
1152 "384 512", -1);
1153 return;
1154 }
1155 }
1156 if( eType==SQLITE_NULL ) return;
1157 SHA3Init(&cx, iSize);
1158 if( eType==SQLITE_BLOB ){
1159 SHA3Update(&cx, sqlite3_value_blob(argv[0]), nByte);
1160 }else{
1161 SHA3Update(&cx, sqlite3_value_text(argv[0]), nByte);
1162 }
1163 sqlite3_result_blob(context, SHA3Final(&cx), iSize/8, SQLITE_TRANSIENT);
1164 }
1165
1166 /* Compute a string using sqlite3_vsnprintf() with a maximum length
1167 ** of 50 bytes and add it to the hash.
1168 */
1169 static void hash_step_vformat(
1170 SHA3Context *p, /* Add content to this context */
1171 const char *zFormat,
1172 ...
1173 ){
1174 va_list ap;
1175 int n;
1176 char zBuf[50];
1177 va_start(ap, zFormat);
1178 sqlite3_vsnprintf(sizeof(zBuf),zBuf,zFormat,ap);
1179 va_end(ap);
1180 n = (int)strlen(zBuf);
1181 SHA3Update(p, (unsigned char*)zBuf, n);
1182 }
1183
1184 /*
1185 ** Implementation of the sha3_query(SQL,SIZE) function.
1186 **
1187 ** This function compiles and runs the SQL statement(s) given in the
1188 ** argument. The results are hashed using a SIZE-bit SHA3. The default
1189 ** size is 256.
1190 **
1191 ** The format of the byte stream that is hashed is summarized as follows:
1192 **
1193 ** S<n>:<sql>
1194 ** R
1195 ** N
1196 ** I<int>
1197 ** F<ieee-float>
1198 ** B<size>:<bytes>
1199 ** T<size>:<text>
1200 **
1201 ** <sql> is the original SQL text for each statement run and <n> is
1202 ** the size of that text. The SQL text is UTF-8. A single R character
1203 ** occurs before the start of each row. N means a NULL value.
1204 ** I mean an 8-byte little-endian integer <int>. F is a floating point
1205 ** number with an 8-byte little-endian IEEE floating point value <ieee-float>.
1206 ** B means blobs of <size> bytes. T means text rendered as <size>
1207 ** bytes of UTF-8. The <n> and <size> values are expressed as an ASCII
1208 ** text integers.
1209 **
1210 ** For each SQL statement in the X input, there is one S segment. Each
1211 ** S segment is followed by zero or more R segments, one for each row in the
1212 ** result set. After each R, there are one or more N, I, F, B, or T segments,
1213 ** one for each column in the result set. Segments are concatentated directly
1214 ** with no delimiters of any kind.
1215 */
1216 static void sha3QueryFunc(
1217 sqlite3_context *context,
1218 int argc,
1219 sqlite3_value **argv
1220 ){
1221 sqlite3 *db = sqlite3_context_db_handle(context);
1222 const char *zSql = (const char*)sqlite3_value_text(argv[0]);
1223 sqlite3_stmt *pStmt = 0;
1224 int nCol; /* Number of columns in the result set */
1225 int i; /* Loop counter */
1226 int rc;
1227 int n;
1228 const char *z;
1229 SHA3Context cx;
1230 int iSize;
1231
1232 if( argc==1 ){
1233 iSize = 256;
1234 }else{
1235 iSize = sqlite3_value_int(argv[1]);
1236 if( iSize!=224 && iSize!=256 && iSize!=384 && iSize!=512 ){
1237 sqlite3_result_error(context, "SHA3 size should be one of: 224 256 "
1238 "384 512", -1);
1239 return;
1240 }
1241 }
1242 if( zSql==0 ) return;
1243 SHA3Init(&cx, iSize);
1244 while( zSql[0] ){
1245 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zSql);
1246 if( rc ){
1247 char *zMsg = sqlite3_mprintf("error SQL statement [%s]: %s",
1248 zSql, sqlite3_errmsg(db));
1249 sqlite3_finalize(pStmt);
1250 sqlite3_result_error(context, zMsg, -1);
1251 sqlite3_free(zMsg);
1252 return;
1253 }
1254 if( !sqlite3_stmt_readonly(pStmt) ){
1255 char *zMsg = sqlite3_mprintf("non-query: [%s]", sqlite3_sql(pStmt));
1256 sqlite3_finalize(pStmt);
1257 sqlite3_result_error(context, zMsg, -1);
1258 sqlite3_free(zMsg);
1259 return;
1260 }
1261 nCol = sqlite3_column_count(pStmt);
1262 z = sqlite3_sql(pStmt);
1263 if( z==0 ){
1264 sqlite3_finalize(pStmt);
1265 continue;
1266 }
1267 n = (int)strlen(z);
1268 hash_step_vformat(&cx,"S%d:",n);
1269 SHA3Update(&cx,(unsigned char*)z,n);
1270
1271 /* Compute a hash over the result of the query */
1272 while( SQLITE_ROW==sqlite3_step(pStmt) ){
1273 SHA3Update(&cx,(const unsigned char*)"R",1);
1274 for(i=0; i<nCol; i++){
1275 switch( sqlite3_column_type(pStmt,i) ){
1276 case SQLITE_NULL: {
1277 SHA3Update(&cx, (const unsigned char*)"N",1);
1278 break;
1279 }
1280 case SQLITE_INTEGER: {
1281 sqlite3_uint64 u;
1282 int j;
1283 unsigned char x[9];
1284 sqlite3_int64 v = sqlite3_column_int64(pStmt,i);
1285 memcpy(&u, &v, 8);
1286 for(j=8; j>=1; j--){
1287 x[j] = u & 0xff;
1288 u >>= 8;
1289 }
1290 x[0] = 'I';
1291 SHA3Update(&cx, x, 9);
1292 break;
1293 }
1294 case SQLITE_FLOAT: {
1295 sqlite3_uint64 u;
1296 int j;
1297 unsigned char x[9];
1298 double r = sqlite3_column_double(pStmt,i);
1299 memcpy(&u, &r, 8);
1300 for(j=8; j>=1; j--){
1301 x[j] = u & 0xff;
1302 u >>= 8;
1303 }
1304 x[0] = 'F';
1305 SHA3Update(&cx,x,9);
1306 break;
1307 }
1308 case SQLITE_TEXT: {
1309 int n2 = sqlite3_column_bytes(pStmt, i);
1310 const unsigned char *z2 = sqlite3_column_text(pStmt, i);
1311 hash_step_vformat(&cx,"T%d:",n2);
1312 SHA3Update(&cx, z2, n2);
1313 break;
1314 }
1315 case SQLITE_BLOB: {
1316 int n2 = sqlite3_column_bytes(pStmt, i);
1317 const unsigned char *z2 = sqlite3_column_blob(pStmt, i);
1318 hash_step_vformat(&cx,"B%d:",n2);
1319 SHA3Update(&cx, z2, n2);
1320 break;
1321 }
1322 }
1323 }
1324 }
1325 sqlite3_finalize(pStmt);
1326 }
1327 sqlite3_result_blob(context, SHA3Final(&cx), iSize/8, SQLITE_TRANSIENT);
1328 }
1329 /* End of SHA3 hashing logic copy/pasted from ../ext/misc/shathree.c
1330 ********************************************************************************/
1331
1332 #if defined(SQLITE_ENABLE_SESSION)
1333 /*
1334 ** State information for a single open session
1335 */
@@ -608,17 +1359,14 @@
1359 ** instance of the following structure.
1360 */
1361 typedef struct ShellState ShellState;
1362 struct ShellState {
1363 sqlite3 *db; /* The database */
 
1364 int autoExplain; /* Automatically turn on .explain mode */
1365 int autoEQP; /* Run EXPLAIN QUERY PLAN prior to seach SQL stmt */
1366 int statsOn; /* True to display memory stats before each finalize */
1367 int scanstatsOn; /* True to display scan stats before each finalize */
 
 
1368 int outCount; /* Revert to stdout when reaching zero */
1369 int cnt; /* Number of records displayed so far */
1370 FILE *out; /* Write results here */
1371 FILE *traceOut; /* Output for sqlite3_trace() */
1372 int nErr; /* Number of errors seen */
@@ -653,13 +1401,24 @@
1401 };
1402
1403 /*
1404 ** These are the allowed shellFlgs values
1405 */
1406 #define SHFLG_Scratch 0x00000001 /* The --scratch option is used */
1407 #define SHFLG_Pagecache 0x00000002 /* The --pagecache option is used */
1408 #define SHFLG_Lookaside 0x00000004 /* Lookaside memory is used */
1409 #define SHFLG_Backslash 0x00000008 /* The --backslash option is used */
1410 #define SHFLG_PreserveRowid 0x00000010 /* .dump preserves rowid values */
1411 #define SHFLG_CountChanges 0x00000020 /* .changes setting */
1412 #define SHFLG_Echo 0x00000040 /* .echo or --echo setting */
1413
1414 /*
1415 ** Macros for testing and setting shellFlgs
1416 */
1417 #define ShellHasFlag(P,X) (((P)->shellFlgs & (X))!=0)
1418 #define ShellSetFlag(P,X) ((P)->shellFlgs|=(X))
1419 #define ShellClearFlag(P,X) ((P)->shellFlgs&=(~(X)))
1420
1421 /*
1422 ** These are the allowed modes.
1423 */
1424 #define MODE_Line 0 /* One column per line. Blank line between records */
@@ -729,36 +1488,56 @@
1488 raw_printf(out,"'");
1489 }
1490
1491 /*
1492 ** Output the given string as a quoted string using SQL quoting conventions.
1493 **
1494 ** The "\n" and "\r" characters are converted to char(10) and char(13)
1495 ** to prevent them from being transformed by end-of-line translators.
1496 */
1497 static void output_quoted_string(FILE *out, const char *z){
1498 int i;
1499 char c;
1500 setBinaryMode(out, 1);
1501 for(i=0; (c = z[i])!=0 && c!='\'' && c!='\n' && c!='\r'; i++){}
1502 if( c==0 ){
 
 
1503 utf8_printf(out,"'%s'",z);
1504 }else{
1505 int inQuote = 0;
1506 int bStarted = 0;
1507 while( *z ){
1508 for(i=0; (c = z[i])!=0 && c!='\n' && c!='\r' && c!='\''; i++){}
1509 if( c=='\'' ) i++;
1510 if( i ){
1511 if( !inQuote ){
1512 if( bStarted ) raw_printf(out, "||");
1513 raw_printf(out, "'");
1514 inQuote = 1;
1515 }
1516 utf8_printf(out, "%.*s", i, z);
1517 z += i;
1518 bStarted = 1;
1519 }
1520 if( c=='\'' ){
1521 raw_printf(out, "'");
1522 continue;
1523 }
1524 if( inQuote ){
1525 raw_printf(out, "'");
1526 inQuote = 0;
1527 }
1528 if( c==0 ){
1529 break;
1530 }
1531 for(i=0; (c = z[i])=='\r' || c=='\n'; i++){
1532 if( bStarted ) raw_printf(out, "||");
1533 raw_printf(out, "char(%d)", c);
1534 bStarted = 1;
1535 }
1536 z += i;
1537 }
1538 if( inQuote ) raw_printf(out, "'");
1539 }
1540 setTextMode(out, 1);
1541 }
1542
1543 /*
@@ -1246,13 +2025,17 @@
2025 if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){
2026 utf8_printf(p->out,"%sNULL",zSep);
2027 }else if( aiType && aiType[i]==SQLITE_TEXT ){
2028 if( zSep[0] ) utf8_printf(p->out,"%s",zSep);
2029 output_quoted_string(p->out, azArg[i]);
2030 }else if( aiType && aiType[i]==SQLITE_INTEGER ){
 
2031 utf8_printf(p->out,"%s%s",zSep, azArg[i]);
2032 }else if( aiType && aiType[i]==SQLITE_FLOAT ){
2033 char z[50];
2034 double r = sqlite3_column_double(p->pStmt, i);
2035 sqlite3_snprintf(50,z,"%!.20g", r);
2036 raw_printf(p->out, "%s%s", zSep, z);
2037 }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){
2038 const void *pBlob = sqlite3_column_blob(p->pStmt, i);
2039 int nBlob = sqlite3_column_bytes(p->pStmt, i);
2040 if( zSep[0] ) utf8_printf(p->out,"%s",zSep);
2041 output_hex_blob(p->out, pBlob, nBlob);
@@ -1292,92 +2075,106 @@
2075 */
2076 static int callback(void *pArg, int nArg, char **azArg, char **azCol){
2077 /* since we don't have type info, call the shell_callback with a NULL value */
2078 return shell_callback(pArg, nArg, azArg, azCol, NULL);
2079 }
2080
2081 /*
2082 ** This is the callback routine from sqlite3_exec() that appends all
2083 ** output onto the end of a ShellText object.
2084 */
2085 static int captureOutputCallback(void *pArg, int nArg, char **azArg, char **az){
2086 ShellText *p = (ShellText*)pArg;
2087 int i;
2088 if( p->n ) appendText(p, "|", 0);
2089 for(i=0; i<nArg; i++){
2090 if( i ) appendText(p, ",", 0);
2091 if( azArg[i] ) appendText(p, azArg[i], 0);
2092 }
2093 return 0;
2094 }
2095
2096 /*
2097 ** Generate an appropriate SELFTEST table in the main database.
2098 */
2099 static void createSelftestTable(ShellState *p){
2100 char *zErrMsg = 0;
2101 sqlite3_exec(p->db,
2102 "SAVEPOINT selftest_init;\n"
2103 "CREATE TABLE IF NOT EXISTS selftest(\n"
2104 " tno INTEGER PRIMARY KEY,\n" /* Test number */
2105 " op TEXT,\n" /* Operator: memo run */
2106 " cmd TEXT,\n" /* Command text */
2107 " ans TEXT\n" /* Desired answer */
2108 ");"
2109 "CREATE TEMP TABLE [_shell$self](op,cmd,ans);\n"
2110 "INSERT INTO [_shell$self](rowid,op,cmd)\n"
2111 " VALUES(coalesce((SELECT (max(tno)+100)/10 FROM selftest),10),\n"
2112 " 'memo','Tests generated by --init');\n"
2113 "INSERT INTO [_shell$self]\n"
2114 " SELECT 'run',\n"
2115 " 'SELECT hex(sha3_query(''SELECT type,name,tbl_name,sql "
2116 "FROM sqlite_master ORDER BY 2'',224))',\n"
2117 " hex(sha3_query('SELECT type,name,tbl_name,sql "
2118 "FROM sqlite_master ORDER BY 2',224));\n"
2119 "INSERT INTO [_shell$self]\n"
2120 " SELECT 'run',"
2121 " 'SELECT hex(sha3_query(''SELECT * FROM \"' ||"
2122 " printf('%w',name) || '\" NOT INDEXED'',224))',\n"
2123 " hex(sha3_query(printf('SELECT * FROM \"%w\" NOT INDEXED',name),224))\n"
2124 " FROM (\n"
2125 " SELECT name FROM sqlite_master\n"
2126 " WHERE type='table'\n"
2127 " AND name<>'selftest'\n"
2128 " AND coalesce(rootpage,0)>0\n"
2129 " )\n"
2130 " ORDER BY name;\n"
2131 "INSERT INTO [_shell$self]\n"
2132 " VALUES('run','PRAGMA integrity_check','ok');\n"
2133 "INSERT INTO selftest(tno,op,cmd,ans)"
2134 " SELECT rowid*10,op,cmd,ans FROM [_shell$self];\n"
2135 "DROP TABLE [_shell$self];"
2136 ,0,0,&zErrMsg);
2137 if( zErrMsg ){
2138 utf8_printf(stderr, "SELFTEST initialization failure: %s\n", zErrMsg);
2139 sqlite3_free(zErrMsg);
2140 }
2141 sqlite3_exec(p->db, "RELEASE selftest_init",0,0,0);
2142 }
2143
2144
2145 /*
2146 ** Set the destination table field of the ShellState structure to
2147 ** the name of the table given. Escape any quote characters in the
2148 ** table name.
2149 */
2150 static void set_table_name(ShellState *p, const char *zName){
2151 int i, n;
2152 int cQuote;
2153 char *z;
2154
2155 if( p->zDestTable ){
2156 free(p->zDestTable);
2157 p->zDestTable = 0;
2158 }
2159 if( zName==0 ) return;
2160 cQuote = quoteChar(zName);
2161 n = strlen30(zName);
2162 if( cQuote ) n += 2;
 
 
 
 
 
2163 z = p->zDestTable = malloc( n+1 );
2164 if( z==0 ){
2165 raw_printf(stderr,"Error: out of memory\n");
2166 exit(1);
2167 }
2168 n = 0;
2169 if( cQuote ) z[n++] = cQuote;
2170 for(i=0; zName[i]; i++){
2171 z[n++] = zName[i];
2172 if( zName[i]==cQuote ) z[n++] = cQuote;
2173 }
2174 if( cQuote ) z[n++] = cQuote;
2175 z[n] = 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2176 }
2177
2178
2179 /*
2180 ** Execute a query statement that will generate SQL output. Print
@@ -1484,10 +2281,35 @@
2281 }
2282 fclose(in);
2283 }
2284 #endif
2285
2286 /*
2287 ** Display a single line of status using 64-bit values.
2288 */
2289 static void displayStatLine(
2290 ShellState *p, /* The shell context */
2291 char *zLabel, /* Label for this one line */
2292 char *zFormat, /* Format for the result */
2293 int iStatusCtrl, /* Which status to display */
2294 int bReset /* True to reset the stats */
2295 ){
2296 sqlite3_int64 iCur = -1;
2297 sqlite3_int64 iHiwtr = -1;
2298 int i, nPercent;
2299 char zLine[200];
2300 sqlite3_status64(iStatusCtrl, &iCur, &iHiwtr, bReset);
2301 for(i=0, nPercent=0; zFormat[i]; i++){
2302 if( zFormat[i]=='%' ) nPercent++;
2303 }
2304 if( nPercent>1 ){
2305 sqlite3_snprintf(sizeof(zLine), zLine, zFormat, iCur, iHiwtr);
2306 }else{
2307 sqlite3_snprintf(sizeof(zLine), zLine, zFormat, iHiwtr);
2308 }
2309 raw_printf(p->out, "%-36s %s\n", zLabel, zLine);
2310 }
2311
2312 /*
2313 ** Display memory stats.
2314 */
2315 static int display_stats(
@@ -1497,61 +2319,35 @@
2319 ){
2320 int iCur;
2321 int iHiwtr;
2322
2323 if( pArg && pArg->out ){
2324 displayStatLine(pArg, "Memory Used:",
2325 "%lld (max %lld) bytes", SQLITE_STATUS_MEMORY_USED, bReset);
2326 displayStatLine(pArg, "Number of Outstanding Allocations:",
2327 "%lld (max %lld)", SQLITE_STATUS_MALLOC_COUNT, bReset);
 
 
 
 
 
 
2328 if( pArg->shellFlgs & SHFLG_Pagecache ){
2329 displayStatLine(pArg, "Number of Pcache Pages Used:",
2330 "%lld (max %lld) pages", SQLITE_STATUS_PAGECACHE_USED, bReset);
2331 }
2332 displayStatLine(pArg, "Number of Pcache Overflow Bytes:",
2333 "%lld (max %lld) bytes", SQLITE_STATUS_PAGECACHE_OVERFLOW, bReset);
 
 
 
 
 
 
2334 if( pArg->shellFlgs & SHFLG_Scratch ){
2335 displayStatLine(pArg, "Number of Scratch Allocations Used:",
2336 "%lld (max %lld)", SQLITE_STATUS_SCRATCH_USED, bReset);
2337 }
2338 displayStatLine(pArg, "Number of Scratch Overflow Bytes:",
2339 "%lld (max %lld) bytes", SQLITE_STATUS_SCRATCH_OVERFLOW, bReset);
2340 displayStatLine(pArg, "Largest Allocation:",
2341 "%lld bytes", SQLITE_STATUS_MALLOC_SIZE, bReset);
2342 displayStatLine(pArg, "Largest Pcache Allocation:",
2343 "%lld bytes", SQLITE_STATUS_PAGECACHE_SIZE, bReset);
2344 displayStatLine(pArg, "Largest Scratch Allocation:",
2345 "%lld bytes", SQLITE_STATUS_SCRATCH_SIZE, bReset);
 
 
 
 
 
 
 
 
 
 
 
 
2346 #ifdef YYTRACKMAXSTACKDEPTH
2347 displayStatLine(pArg, "Deepest Parser Stack:",
2348 "%lld (max %lld)", SQLITE_STATUS_PARSER_STACK, bReset);
 
 
2349 #endif
2350 }
2351
2352 if( pArg && pArg->out && db ){
2353 if( pArg->shellFlgs & SHFLG_Lookaside ){
@@ -1934,11 +2730,11 @@
2730 pArg->pStmt = pStmt;
2731 pArg->cnt = 0;
2732 }
2733
2734 /* echo the sql statement if echo on */
2735 if( pArg && ShellHasFlag(pArg, SHFLG_Echo) ){
2736 utf8_printf(pArg->out, "%s\n", zStmtSql ? zStmtSql : zSql);
2737 }
2738
2739 /* Show the EXPLAIN QUERY PLAN if .eqp is on */
2740 if( pArg && pArg->autoEQP && sqlite3_strlike("EXPLAIN%",zStmtSql,0)!=0 ){
@@ -2022,10 +2818,142 @@
2818 } /* end while */
2819
2820 return rc;
2821 }
2822
2823 /*
2824 ** Release memory previously allocated by tableColumnList().
2825 */
2826 static void freeColumnList(char **azCol){
2827 int i;
2828 for(i=1; azCol[i]; i++){
2829 sqlite3_free(azCol[i]);
2830 }
2831 /* azCol[0] is a static string */
2832 sqlite3_free(azCol);
2833 }
2834
2835 /*
2836 ** Return a list of pointers to strings which are the names of all
2837 ** columns in table zTab. The memory to hold the names is dynamically
2838 ** allocated and must be released by the caller using a subsequent call
2839 ** to freeColumnList().
2840 **
2841 ** The azCol[0] entry is usually NULL. However, if zTab contains a rowid
2842 ** value that needs to be preserved, then azCol[0] is filled in with the
2843 ** name of the rowid column.
2844 **
2845 ** The first regular column in the table is azCol[1]. The list is terminated
2846 ** by an entry with azCol[i]==0.
2847 */
2848 static char **tableColumnList(ShellState *p, const char *zTab){
2849 char **azCol = 0;
2850 sqlite3_stmt *pStmt;
2851 char *zSql;
2852 int nCol = 0;
2853 int nAlloc = 0;
2854 int nPK = 0; /* Number of PRIMARY KEY columns seen */
2855 int isIPK = 0; /* True if one PRIMARY KEY column of type INTEGER */
2856 int preserveRowid = ShellHasFlag(p, SHFLG_PreserveRowid);
2857 int rc;
2858
2859 zSql = sqlite3_mprintf("PRAGMA table_info=%Q", zTab);
2860 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
2861 sqlite3_free(zSql);
2862 if( rc ) return 0;
2863 while( sqlite3_step(pStmt)==SQLITE_ROW ){
2864 if( nCol>=nAlloc-2 ){
2865 nAlloc = nAlloc*2 + nCol + 10;
2866 azCol = sqlite3_realloc(azCol, nAlloc*sizeof(azCol[0]));
2867 if( azCol==0 ){
2868 raw_printf(stderr, "Error: out of memory\n");
2869 exit(1);
2870 }
2871 }
2872 azCol[++nCol] = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 1));
2873 if( sqlite3_column_int(pStmt, 5) ){
2874 nPK++;
2875 if( nPK==1
2876 && sqlite3_stricmp((const char*)sqlite3_column_text(pStmt,2),
2877 "INTEGER")==0
2878 ){
2879 isIPK = 1;
2880 }else{
2881 isIPK = 0;
2882 }
2883 }
2884 }
2885 sqlite3_finalize(pStmt);
2886 azCol[0] = 0;
2887 azCol[nCol+1] = 0;
2888
2889 /* The decision of whether or not a rowid really needs to be preserved
2890 ** is tricky. We never need to preserve a rowid for a WITHOUT ROWID table
2891 ** or a table with an INTEGER PRIMARY KEY. We are unable to preserve
2892 ** rowids on tables where the rowid is inaccessible because there are other
2893 ** columns in the table named "rowid", "_rowid_", and "oid".
2894 */
2895 if( preserveRowid && isIPK ){
2896 /* If a single PRIMARY KEY column with type INTEGER was seen, then it
2897 ** might be an alise for the ROWID. But it might also be a WITHOUT ROWID
2898 ** table or a INTEGER PRIMARY KEY DESC column, neither of which are
2899 ** ROWID aliases. To distinguish these cases, check to see if
2900 ** there is a "pk" entry in "PRAGMA index_list". There will be
2901 ** no "pk" index if the PRIMARY KEY really is an alias for the ROWID.
2902 */
2903 zSql = sqlite3_mprintf("SELECT 1 FROM pragma_index_list(%Q)"
2904 " WHERE origin='pk'", zTab);
2905 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
2906 sqlite3_free(zSql);
2907 if( rc ){
2908 freeColumnList(azCol);
2909 return 0;
2910 }
2911 rc = sqlite3_step(pStmt);
2912 sqlite3_finalize(pStmt);
2913 preserveRowid = rc==SQLITE_ROW;
2914 }
2915 if( preserveRowid ){
2916 /* Only preserve the rowid if we can find a name to use for the
2917 ** rowid */
2918 static char *azRowid[] = { "rowid", "_rowid_", "oid" };
2919 int i, j;
2920 for(j=0; j<3; j++){
2921 for(i=1; i<=nCol; i++){
2922 if( sqlite3_stricmp(azRowid[j],azCol[i])==0 ) break;
2923 }
2924 if( i>nCol ){
2925 /* At this point, we know that azRowid[j] is not the name of any
2926 ** ordinary column in the table. Verify that azRowid[j] is a valid
2927 ** name for the rowid before adding it to azCol[0]. WITHOUT ROWID
2928 ** tables will fail this last check */
2929 int rc;
2930 rc = sqlite3_table_column_metadata(p->db,0,zTab,azRowid[j],0,0,0,0,0);
2931 if( rc==SQLITE_OK ) azCol[0] = azRowid[j];
2932 break;
2933 }
2934 }
2935 }
2936 return azCol;
2937 }
2938
2939 /*
2940 ** Toggle the reverse_unordered_selects setting.
2941 */
2942 static void toggleSelectOrder(sqlite3 *db){
2943 sqlite3_stmt *pStmt = 0;
2944 int iSetting = 0;
2945 char zStmt[100];
2946 sqlite3_prepare_v2(db, "PRAGMA reverse_unordered_selects", -1, &pStmt, 0);
2947 if( sqlite3_step(pStmt)==SQLITE_ROW ){
2948 iSetting = sqlite3_column_int(pStmt, 0);
2949 }
2950 sqlite3_finalize(pStmt);
2951 sqlite3_snprintf(sizeof(zStmt), zStmt,
2952 "PRAGMA reverse_unordered_selects(%d)", !iSetting);
2953 sqlite3_exec(db, zStmt, 0, 0, 0);
2954 }
2955
2956 /*
2957 ** This is a different callback routine used for dumping the database.
2958 ** Each row received by this callback consists of a table name,
2959 ** the table type ("index" or "table") and SQL to create the table.
@@ -2034,21 +2962,20 @@
2962 static int dump_callback(void *pArg, int nArg, char **azArg, char **azCol){
2963 int rc;
2964 const char *zTable;
2965 const char *zType;
2966 const char *zSql;
 
2967 ShellState *p = (ShellState *)pArg;
2968
2969 UNUSED_PARAMETER(azCol);
2970 if( nArg!=3 ) return 1;
2971 zTable = azArg[0];
2972 zType = azArg[1];
2973 zSql = azArg[2];
2974
2975 if( strcmp(zTable, "sqlite_sequence")==0 ){
2976 raw_printf(p->out, "DELETE FROM sqlite_sequence;\n");
2977 }else if( sqlite3_strglob("sqlite_stat?", zTable)==0 ){
2978 raw_printf(p->out, "ANALYZE sqlite_master;\n");
2979 }else if( strncmp(zTable, "sqlite_", 7)==0 ){
2980 return 0;
2981 }else if( strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){
@@ -2067,62 +2994,74 @@
2994 }else{
2995 printSchemaLine(p->out, zSql, ";\n");
2996 }
2997
2998 if( strcmp(zType, "table")==0 ){
2999 ShellText sSelect;
3000 ShellText sTable;
3001 char **azCol;
3002 int i;
3003 char *savedDestTable;
3004 int savedMode;
3005
3006 azCol = tableColumnList(p, zTable);
3007 if( azCol==0 ){
3008 p->nErr++;
3009 return 0;
3010 }
3011
 
 
 
 
3012 /* Always quote the table name, even if it appears to be pure ascii,
3013 ** in case it is a keyword. Ex: INSERT INTO "table" ... */
3014 initText(&sTable);
3015 appendText(&sTable, zTable, quoteChar(zTable));
3016 /* If preserving the rowid, add a column list after the table name.
3017 ** In other words: "INSERT INTO tab(rowid,a,b,c,...) VALUES(...)"
3018 ** instead of the usual "INSERT INTO tab VALUES(...)".
3019 */
3020 if( azCol[0] ){
3021 appendText(&sTable, "(", 0);
3022 appendText(&sTable, azCol[0], 0);
3023 for(i=1; azCol[i]; i++){
3024 appendText(&sTable, ",", 0);
3025 appendText(&sTable, azCol[i], quoteChar(azCol[i]));
3026 }
3027 appendText(&sTable, ")", 0);
3028 }
3029
3030 /* Build an appropriate SELECT statement */
3031 initText(&sSelect);
3032 appendText(&sSelect, "SELECT ", 0);
3033 if( azCol[0] ){
3034 appendText(&sSelect, azCol[0], 0);
3035 appendText(&sSelect, ",", 0);
3036 }
3037 for(i=1; azCol[i]; i++){
3038 appendText(&sSelect, azCol[i], quoteChar(azCol[i]));
3039 if( azCol[i+1] ){
3040 appendText(&sSelect, ",", 0);
3041 }
3042 }
3043 freeColumnList(azCol);
3044 appendText(&sSelect, " FROM ", 0);
3045 appendText(&sSelect, zTable, quoteChar(zTable));
3046
3047 savedDestTable = p->zDestTable;
3048 savedMode = p->mode;
3049 p->zDestTable = sTable.z;
3050 p->mode = p->cMode = MODE_Insert;
3051 rc = shell_exec(p->db, sSelect.z, shell_callback, p, 0);
3052 if( (rc&0xff)==SQLITE_CORRUPT ){
3053 raw_printf(p->out, "/****** CORRUPTION ERROR *******/\n");
3054 toggleSelectOrder(p->db);
3055 shell_exec(p->db, sSelect.z, shell_callback, p, 0);
3056 toggleSelectOrder(p->db);
3057 }
3058 p->zDestTable = savedDestTable;
3059 p->mode = savedMode;
3060 freeText(&sTable);
3061 freeText(&sSelect);
3062 if( rc ) p->nErr++;
3063 }
3064 return 0;
3065 }
3066
3067 /*
@@ -2228,15 +3167,17 @@
3167 ".restore ?DB? FILE Restore content of DB (default \"main\") from FILE\n"
3168 ".save FILE Write in-memory database into FILE\n"
3169 ".scanstats on|off Turn sqlite3_stmt_scanstatus() metrics on or off\n"
3170 ".schema ?PATTERN? Show the CREATE statements matching PATTERN\n"
3171 " Add --indent for pretty-printing\n"
3172 ".selftest ?--init? Run tests defined in the SELFTEST table\n"
3173 ".separator COL ?ROW? Change the column separator and optionally the row\n"
3174 " separator for both the output mode and .import\n"
3175 #if defined(SQLITE_ENABLE_SESSION)
3176 ".session CMD ... Create or control sessions\n"
3177 #endif
3178 ".sha3sum ?OPTIONS...? Compute a SHA3 hash of database content\n"
3179 ".shell CMD ARGS... Run CMD ARGS... in a system shell\n"
3180 ".show Show the current values for various settings\n"
3181 ".stats ?on|off? Show stats or turn stats on or off\n"
3182 ".system CMD ARGS... Run CMD ARGS... in a system shell\n"
3183 ".tables ?TABLE? List names of tables\n"
@@ -2423,14 +3364,10 @@
3364 static void open_db(ShellState *p, int keepAlive){
3365 if( p->db==0 ){
3366 sqlite3_initialize();
3367 sqlite3_open(p->zDbFilename, &p->db);
3368 globalDb = p->db;
 
 
 
 
3369 if( p->db==0 || SQLITE_OK!=sqlite3_errcode(p->db) ){
3370 utf8_printf(stderr,"Error: unable to open database \"%s\": %s\n",
3371 p->zDbFilename, sqlite3_errmsg(p->db));
3372 if( keepAlive ) return;
3373 exit(1);
@@ -2440,10 +3377,18 @@
3377 #endif
3378 sqlite3_create_function(p->db, "readfile", 1, SQLITE_UTF8, 0,
3379 readfileFunc, 0, 0);
3380 sqlite3_create_function(p->db, "writefile", 2, SQLITE_UTF8, 0,
3381 writefileFunc, 0, 0);
3382 sqlite3_create_function(p->db, "sha3", 1, SQLITE_UTF8, 0,
3383 sha3Func, 0, 0);
3384 sqlite3_create_function(p->db, "sha3", 2, SQLITE_UTF8, 0,
3385 sha3Func, 0, 0);
3386 sqlite3_create_function(p->db, "sha3_query", 1, SQLITE_UTF8, 0,
3387 sha3QueryFunc, 0, 0);
3388 sqlite3_create_function(p->db, "sha3_query", 2, SQLITE_UTF8, 0,
3389 sha3QueryFunc, 0, 0);
3390 }
3391 }
3392
3393 /*
3394 ** Do C-language style dequoting.
@@ -2564,11 +3509,11 @@
3509
3510 /*
3511 ** Interpret zArg as either an integer or a boolean value. Return 1 or 0
3512 ** for TRUE and FALSE. Return the integer value if appropriate.
3513 */
3514 static int booleanValue(const char *zArg){
3515 int i;
3516 if( zArg[0]=='0' && zArg[1]=='x' ){
3517 for(i=2; hexDigitValue(zArg[i])>=0; i++){}
3518 }else{
3519 for(i=0; zArg[i]>='0' && zArg[i]<='9'; i++){}
@@ -2582,10 +3527,21 @@
3527 }
3528 utf8_printf(stderr, "ERROR: Not a boolean value: \"%s\". Assuming \"no\".\n",
3529 zArg);
3530 return 0;
3531 }
3532
3533 /*
3534 ** Set or clear a shell flag according to a boolean value.
3535 */
3536 static void setOrClearFlag(ShellState *p, unsigned mFlag, const char *zArg){
3537 if( booleanValue(zArg) ){
3538 ShellSetFlag(p, mFlag);
3539 }else{
3540 ShellClearFlag(p, mFlag);
3541 }
3542 }
3543
3544 /*
3545 ** Close an output file, assuming it is not stderr or stdout
3546 */
3547 static void output_file_close(FILE *f){
@@ -3656,11 +4612,11 @@
4612 test_breakpoint();
4613 }else
4614
4615 if( c=='c' && n>=3 && strncmp(azArg[0], "changes", n)==0 ){
4616 if( nArg==2 ){
4617 setOrClearFlag(p, SHFLG_CountChanges, azArg[1]);
4618 }else{
4619 raw_printf(stderr, "Usage: .changes on|off\n");
4620 rc = 1;
4621 }
4622 }else
@@ -3720,25 +4676,46 @@
4676 if( c=='d' && strncmp(azArg[0], "dbinfo", n)==0 ){
4677 rc = shell_dbinfo_command(p, nArg, azArg);
4678 }else
4679
4680 if( c=='d' && strncmp(azArg[0], "dump", n)==0 ){
4681 const char *zLike = 0;
4682 int i;
4683 ShellClearFlag(p, SHFLG_PreserveRowid);
4684 for(i=1; i<nArg; i++){
4685 if( azArg[i][0]=='-' ){
4686 const char *z = azArg[i]+1;
4687 if( z[0]=='-' ) z++;
4688 if( strcmp(z,"preserve-rowids")==0 ){
4689 ShellSetFlag(p, SHFLG_PreserveRowid);
4690 }else
4691 {
4692 raw_printf(stderr, "Unknown option \"%s\" on \".dump\"\n", azArg[i]);
4693 rc = 1;
4694 goto meta_command_exit;
4695 }
4696 }else if( zLike ){
4697 raw_printf(stderr, "Usage: .dump ?--preserve-rowids? ?LIKE-PATTERN?\n");
4698 rc = 1;
4699 goto meta_command_exit;
4700 }else{
4701 zLike = azArg[i];
4702 }
4703 }
4704 open_db(p, 0);
4705 /* When playing back a "dump", the content might appear in an order
4706 ** which causes immediate foreign key constraints to be violated.
4707 ** So disable foreign-key constraint enforcement to prevent problems. */
 
 
 
 
 
4708 raw_printf(p->out, "PRAGMA foreign_keys=OFF;\n");
4709 raw_printf(p->out, "BEGIN TRANSACTION;\n");
4710 p->writableSchema = 0;
4711 /* Set writable_schema=ON since doing so forces SQLite to initialize
4712 ** as much of the schema as it can even if the sqlite_master table is
4713 ** corrupt. */
4714 sqlite3_exec(p->db, "SAVEPOINT dump; PRAGMA writable_schema=ON", 0, 0, 0);
4715 p->nErr = 0;
4716 if( zLike==0 ){
4717 run_schema_dump_query(p,
4718 "SELECT name, type, sql FROM sqlite_master "
4719 "WHERE sql NOT NULL AND type=='table' AND name!='sqlite_sequence'"
4720 );
4721 run_schema_dump_query(p,
@@ -3748,25 +4725,24 @@
4725 run_table_dump_query(p,
4726 "SELECT sql FROM sqlite_master "
4727 "WHERE sql NOT NULL AND type IN ('index','trigger','view')", 0
4728 );
4729 }else{
4730 char *zSql;
4731 zSql = sqlite3_mprintf(
4732 "SELECT name, type, sql FROM sqlite_master "
4733 "WHERE tbl_name LIKE %Q AND type=='table'"
4734 " AND sql NOT NULL", zLike);
4735 run_schema_dump_query(p,zSql);
4736 sqlite3_free(zSql);
4737 zSql = sqlite3_mprintf(
4738 "SELECT sql FROM sqlite_master "
4739 "WHERE sql NOT NULL"
4740 " AND type IN ('index','trigger','view')"
4741 " AND tbl_name LIKE %Q", zLike);
4742 run_table_dump_query(p, zSql, 0);
4743 sqlite3_free(zSql);
 
4744 }
4745 if( p->writableSchema ){
4746 raw_printf(p->out, "PRAGMA writable_schema=OFF;\n");
4747 p->writableSchema = 0;
4748 }
@@ -3775,11 +4751,11 @@
4751 raw_printf(p->out, p->nErr ? "ROLLBACK; -- due to errors\n" : "COMMIT;\n");
4752 }else
4753
4754 if( c=='e' && strncmp(azArg[0], "echo", n)==0 ){
4755 if( nArg==2 ){
4756 setOrClearFlag(p, SHFLG_Echo, azArg[1]);
4757 }else{
4758 raw_printf(stderr, "Usage: .echo on|off\n");
4759 rc = 1;
4760 }
4761 }else
@@ -4572,21 +5548,21 @@
5548 new_colv[0] = "sql";
5549 new_colv[1] = 0;
5550 callback(&data, 1, new_argv, new_colv);
5551 rc = SQLITE_OK;
5552 }else{
5553 char *zSql;
5554 zSql = sqlite3_mprintf(
5555 "SELECT sql FROM "
5556 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
5557 " FROM sqlite_master UNION ALL"
5558 " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
5559 "WHERE lower(tbl_name) LIKE %Q"
5560 " AND type!='meta' AND sql NOTNULL "
5561 "ORDER BY rowid", azArg[1]);
5562 rc = sqlite3_exec(p->db, zSql, callback, &data, &zErrMsg);
5563 sqlite3_free(zSql);
5564 }
5565 }else if( nArg==1 ){
5566 rc = sqlite3_exec(p->db,
5567 "SELECT sql FROM "
5568 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
@@ -4835,10 +5811,123 @@
5811 utf8_printf(p->out, "%s", zBuf);
5812 }
5813 }
5814 }else
5815 #endif
5816
5817 if( c=='s' && n>=4 && strncmp(azArg[0],"selftest",n)==0 ){
5818 int bIsInit = 0; /* True to initialize the SELFTEST table */
5819 int bVerbose = 0; /* Verbose output */
5820 int bSelftestExists; /* True if SELFTEST already exists */
5821 char **azTest = 0; /* Content of the SELFTEST table */
5822 int nRow = 0; /* Number of rows in the SELFTEST table */
5823 int nCol = 4; /* Number of columns in the SELFTEST table */
5824 int i; /* Loop counter */
5825 int nTest = 0; /* Number of tests runs */
5826 int nErr = 0; /* Number of errors seen */
5827 ShellText str; /* Answer for a query */
5828 static char *azDefaultTest[] = {
5829 0, 0, 0, 0,
5830 "0", "memo", "Missing SELFTEST table - default checks only", "",
5831 "1", "run", "PRAGMA integrity_check", "ok"
5832 };
5833 static const int nDefaultRow = 2;
5834
5835 open_db(p,0);
5836 for(i=1; i<nArg; i++){
5837 const char *z = azArg[i];
5838 if( z[0]=='-' && z[1]=='-' ) z++;
5839 if( strcmp(z,"-init")==0 ){
5840 bIsInit = 1;
5841 }else
5842 if( strcmp(z,"-v")==0 ){
5843 bVerbose++;
5844 }else
5845 {
5846 utf8_printf(stderr, "Unknown option \"%s\" on \"%s\"\n",
5847 azArg[i], azArg[0]);
5848 raw_printf(stderr, "Should be one of: --init -v\n");
5849 rc = 1;
5850 goto meta_command_exit;
5851 }
5852 }
5853 if( sqlite3_table_column_metadata(p->db,"main","selftest",0,0,0,0,0,0)
5854 != SQLITE_OK ){
5855 bSelftestExists = 0;
5856 }else{
5857 bSelftestExists = 1;
5858 }
5859 if( bIsInit ){
5860 createSelftestTable(p);
5861 bSelftestExists = 1;
5862 }
5863 if( bSelftestExists ){
5864 rc = sqlite3_get_table(p->db,
5865 "SELECT tno,op,cmd,ans FROM selftest ORDER BY tno",
5866 &azTest, &nRow, &nCol, 0);
5867 if( rc ){
5868 raw_printf(stderr, "Error querying the selftest table\n");
5869 rc = 1;
5870 sqlite3_free_table(azTest);
5871 goto meta_command_exit;
5872 }else if( nRow==0 ){
5873 sqlite3_free_table(azTest);
5874 azTest = azDefaultTest;
5875 nRow = nDefaultRow;
5876 }
5877 }else{
5878 azTest = azDefaultTest;
5879 nRow = nDefaultRow;
5880 }
5881 initText(&str);
5882 appendText(&str, "x", 0);
5883 for(i=1; i<=nRow; i++){
5884 int tno = atoi(azTest[i*nCol]);
5885 const char *zOp = azTest[i*nCol+1];
5886 const char *zSql = azTest[i*nCol+2];
5887 const char *zAns = azTest[i*nCol+3];
5888
5889 if( bVerbose>0 ){
5890 char *zQuote = sqlite3_mprintf("%q", zSql);
5891 printf("%d: %s %s\n", tno, zOp, zSql);
5892 sqlite3_free(zQuote);
5893 }
5894 if( strcmp(zOp,"memo")==0 ){
5895 utf8_printf(p->out, "%s\n", zSql);
5896 }else
5897 if( strcmp(zOp,"run")==0 ){
5898 char *zErrMsg = 0;
5899 str.n = 0;
5900 str.z[0] = 0;
5901 rc = sqlite3_exec(p->db, zSql, captureOutputCallback, &str, &zErrMsg);
5902 nTest++;
5903 if( bVerbose ){
5904 utf8_printf(p->out, "Result: %s\n", str.z);
5905 }
5906 if( rc || zErrMsg ){
5907 nErr++;
5908 rc = 1;
5909 utf8_printf(p->out, "%d: error-code-%d: %s\n", tno, rc, zErrMsg);
5910 sqlite3_free(zErrMsg);
5911 }else if( strcmp(zAns,str.z)!=0 ){
5912 nErr++;
5913 rc = 1;
5914 utf8_printf(p->out, "%d: Expected: [%s]\n", tno, zAns);
5915 utf8_printf(p->out, "%d: Got: [%s]\n", tno, str.z);
5916 }
5917 }else
5918 {
5919 utf8_printf(stderr,
5920 "Unknown operation \"%s\" on selftest line %d\n", zOp, tno);
5921 rc = 1;
5922 break;
5923 }
5924 }
5925 freeText(&str);
5926 if( azTest!=azDefaultTest ) sqlite3_free_table(azTest);
5927 utf8_printf(p->out, "%d errors out of %d tests\n", nErr, nTest);
5928 }else
5929
5930 if( c=='s' && strncmp(azArg[0], "separator", n)==0 ){
5931 if( nArg<2 || nArg>3 ){
5932 raw_printf(stderr, "Usage: .separator COL ?ROW?\n");
5933 rc = 1;
@@ -4850,10 +5939,126 @@
5939 if( nArg>=3 ){
5940 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator,
5941 "%.*s", (int)ArraySize(p->rowSeparator)-1, azArg[2]);
5942 }
5943 }else
5944
5945 if( c=='s' && n>=4 && strncmp(azArg[0],"sha3sum",n)==0 ){
5946 const char *zLike = 0; /* Which table to checksum. 0 means everything */
5947 int i; /* Loop counter */
5948 int bSchema = 0; /* Also hash the schema */
5949 int bSeparate = 0; /* Hash each table separately */
5950 int iSize = 224; /* Hash algorithm to use */
5951 int bDebug = 0; /* Only show the query that would have run */
5952 sqlite3_stmt *pStmt; /* For querying tables names */
5953 char *zSql; /* SQL to be run */
5954 char *zSep; /* Separator */
5955 ShellText sSql; /* Complete SQL for the query to run the hash */
5956 ShellText sQuery; /* Set of queries used to read all content */
5957 open_db(p, 0);
5958 for(i=1; i<nArg; i++){
5959 const char *z = azArg[i];
5960 if( z[0]=='-' ){
5961 z++;
5962 if( z[0]=='-' ) z++;
5963 if( strcmp(z,"schema")==0 ){
5964 bSchema = 1;
5965 }else
5966 if( strcmp(z,"sha3-224")==0 || strcmp(z,"sha3-256")==0
5967 || strcmp(z,"sha3-384")==0 || strcmp(z,"sha3-512")==0
5968 ){
5969 iSize = atoi(&z[5]);
5970 }else
5971 if( strcmp(z,"debug")==0 ){
5972 bDebug = 1;
5973 }else
5974 {
5975 utf8_printf(stderr, "Unknown option \"%s\" on \"%s\"\n",
5976 azArg[i], azArg[0]);
5977 raw_printf(stderr, "Should be one of: --schema"
5978 " --sha3-224 --sha3-255 --sha3-384 --sha3-512\n");
5979 rc = 1;
5980 goto meta_command_exit;
5981 }
5982 }else if( zLike ){
5983 raw_printf(stderr, "Usage: .sha3sum ?OPTIONS? ?LIKE-PATTERN?\n");
5984 rc = 1;
5985 goto meta_command_exit;
5986 }else{
5987 zLike = z;
5988 bSeparate = 1;
5989 if( sqlite3_strlike("sqlite_%", zLike, 0)==0 ) bSchema = 1;
5990 }
5991 }
5992 if( bSchema ){
5993 zSql = "SELECT lower(name) FROM sqlite_master"
5994 " WHERE type='table' AND coalesce(rootpage,0)>1"
5995 " UNION ALL SELECT 'sqlite_master'"
5996 " ORDER BY 1 collate nocase";
5997 }else{
5998 zSql = "SELECT lower(name) FROM sqlite_master"
5999 " WHERE type='table' AND coalesce(rootpage,0)>1"
6000 " AND name NOT LIKE 'sqlite_%'"
6001 " ORDER BY 1 collate nocase";
6002 }
6003 sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
6004 initText(&sQuery);
6005 initText(&sSql);
6006 appendText(&sSql, "WITH [sha3sum$query](a,b) AS(",0);
6007 zSep = "VALUES(";
6008 while( SQLITE_ROW==sqlite3_step(pStmt) ){
6009 const char *zTab = (const char*)sqlite3_column_text(pStmt,0);
6010 if( zLike && sqlite3_strlike(zLike, zTab, 0)!=0 ) continue;
6011 if( strncmp(zTab, "sqlite_",7)!=0 ){
6012 appendText(&sQuery,"SELECT * FROM ", 0);
6013 appendText(&sQuery,zTab,'"');
6014 appendText(&sQuery," NOT INDEXED;", 0);
6015 }else if( strcmp(zTab, "sqlite_master")==0 ){
6016 appendText(&sQuery,"SELECT type,name,tbl_name,sql FROM sqlite_master"
6017 " ORDER BY name;", 0);
6018 }else if( strcmp(zTab, "sqlite_sequence")==0 ){
6019 appendText(&sQuery,"SELECT name,seq FROM sqlite_sequence"
6020 " ORDER BY name;", 0);
6021 }else if( strcmp(zTab, "sqlite_stat1")==0 ){
6022 appendText(&sQuery,"SELECT tbl,idx,stat FROM sqlite_stat1"
6023 " ORDER BY tbl,idx;", 0);
6024 }else if( strcmp(zTab, "sqlite_stat3")==0
6025 || strcmp(zTab, "sqlite_stat4")==0 ){
6026 appendText(&sQuery, "SELECT * FROM ", 0);
6027 appendText(&sQuery, zTab, 0);
6028 appendText(&sQuery, " ORDER BY tbl, idx, rowid;\n", 0);
6029 }
6030 appendText(&sSql, zSep, 0);
6031 appendText(&sSql, sQuery.z, '\'');
6032 sQuery.n = 0;
6033 appendText(&sSql, ",", 0);
6034 appendText(&sSql, zTab, '\'');
6035 zSep = "),(";
6036 }
6037 sqlite3_finalize(pStmt);
6038 if( bSeparate ){
6039 zSql = sqlite3_mprintf(
6040 "%s))"
6041 " SELECT lower(hex(sha3_query(a,%d))) AS hash, b AS label"
6042 " FROM [sha3sum$query]",
6043 sSql.z, iSize);
6044 }else{
6045 zSql = sqlite3_mprintf(
6046 "%s))"
6047 " SELECT lower(hex(sha3_query(group_concat(a,''),%d))) AS hash"
6048 " FROM [sha3sum$query]",
6049 sSql.z, iSize);
6050 }
6051 freeText(&sQuery);
6052 freeText(&sSql);
6053 if( bDebug ){
6054 utf8_printf(p->out, "%s\n", zSql);
6055 }else{
6056 shell_exec(p->db, zSql, shell_callback, p, 0);
6057 }
6058 sqlite3_free(zSql);
6059 }else
6060
6061 if( c=='s'
6062 && (strncmp(azArg[0], "shell", n)==0 || strncmp(azArg[0],"system",n)==0)
6063 ){
6064 char *zCmd;
@@ -4879,11 +6084,12 @@
6084 if( nArg!=1 ){
6085 raw_printf(stderr, "Usage: .show\n");
6086 rc = 1;
6087 goto meta_command_exit;
6088 }
6089 utf8_printf(p->out, "%12.12s: %s\n","echo",
6090 azBool[ShellHasFlag(p, SHFLG_Echo)]);
6091 utf8_printf(p->out, "%12.12s: %s\n","eqp", azBool[p->autoEQP&3]);
6092 utf8_printf(p->out, "%12.12s: %s\n","explain",
6093 p->mode==MODE_Explain ? "on" : p->autoExplain ? "auto" : "off");
6094 utf8_printf(p->out,"%12.12s: %s\n","headers", azBool[p->showHeader!=0]);
6095 utf8_printf(p->out, "%12.12s: %s\n","mode", modeDescr[p->mode]);
@@ -5444,11 +6650,11 @@
6650 static int runOneSqlLine(ShellState *p, char *zSql, FILE *in, int startline){
6651 int rc;
6652 char *zErrMsg = 0;
6653
6654 open_db(p, 0);
6655 if( ShellHasFlag(p,SHFLG_Backslash) ) resolve_backslashes(zSql);
6656 BEGIN_TIMER;
6657 rc = shell_exec(p->db, zSql, shell_callback, p, &zErrMsg);
6658 END_TIMER;
6659 if( rc || zErrMsg ){
6660 char zPrefix[100];
@@ -5464,11 +6670,11 @@
6670 zErrMsg = 0;
6671 }else{
6672 utf8_printf(stderr, "%s %s\n", zPrefix, sqlite3_errmsg(p->db));
6673 }
6674 return 1;
6675 }else if( ShellHasFlag(p, SHFLG_CountChanges) ){
6676 raw_printf(p->out, "changes: %3d total_changes: %d\n",
6677 sqlite3_changes(p->db), sqlite3_total_changes(p->db));
6678 }
6679 return 0;
6680 }
@@ -5507,15 +6713,15 @@
6713 if( in!=0 ) break;
6714 seenInterrupt = 0;
6715 }
6716 lineno++;
6717 if( nSql==0 && _all_whitespace(zLine) ){
6718 if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zLine);
6719 continue;
6720 }
6721 if( zLine && zLine[0]=='.' && nSql==0 ){
6722 if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zLine);
6723 rc = do_meta_command(zLine, p);
6724 if( rc==2 ){ /* exit requested */
6725 break;
6726 }else if( rc ){
6727 errCnt++;
@@ -5554,11 +6760,11 @@
6760 if( p->outCount ){
6761 output_reset(p);
6762 p->outCount = 0;
6763 }
6764 }else if( nSql && _all_whitespace(zSql) ){
6765 if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zSql);
6766 nSql = 0;
6767 }
6768 }
6769 if( nSql && !_all_whitespace(zSql) ){
6770 runOneSqlLine(p, zSql, in, startline);
@@ -6023,11 +7229,11 @@
7229 }else if( strcmp(z,"-header")==0 ){
7230 data.showHeader = 1;
7231 }else if( strcmp(z,"-noheader")==0 ){
7232 data.showHeader = 0;
7233 }else if( strcmp(z,"-echo")==0 ){
7234 ShellSetFlag(&data, SHFLG_Echo);
7235 }else if( strcmp(z,"-eqp")==0 ){
7236 data.autoEQP = 1;
7237 }else if( strcmp(z,"-eqpfull")==0 ){
7238 data.autoEQP = 2;
7239 }else if( strcmp(z,"-stats")==0 ){
@@ -6038,11 +7244,11 @@
7244 /* Undocumented command-line option: -backslash
7245 ** Causes C-style backslash escapes to be evaluated in SQL statements
7246 ** prior to sending the SQL into SQLite. Useful for injecting
7247 ** crazy bytes in the middle of SQL statements for testing and debugging.
7248 */
7249 ShellSetFlag(&data, SHFLG_Backslash);
7250 }else if( strcmp(z,"-bail")==0 ){
7251 bail_on_error = 1;
7252 }else if( strcmp(z,"-version")==0 ){
7253 printf("%s %s\n", sqlite3_libversion(), sqlite3_sourceid());
7254 return 0;
7255

Keyboard Shortcuts

Open search /
Next entry (timeline) j
Previous entry (timeline) k
Open focused entry Enter
Show this help ?
Toggle theme Top nav button