Many hyperlinks are disabled.
Use anonymous login to enable hyperlinks.

Changes to about.wiki.

    97     97   <h2>Test-Script Format</h2>
    98     98   
    99     99   Test scripts are line-oriented ASCII text files.  
   100    100   No provision is made for Unicode; the purpose
   101    101   of sqllogictest is to test the query and join logic of the database engine, not
   102    102   its support for localization and internationalization.
   103    103   
   104         -Test scripts consist of zero or more records.  A record represents either a
   105         -single statement or query.  Each record
          104  +Test scripts consist of zero or more records.  A record is a
          105  +single statement or query or a control record.  Each record
   106    106   is separated from its neighbors by one or more blank line.  Records
   107    107   are evaluated in order, starting from the beginning of the
   108    108   script and working toward the end.
   109    109   
   110    110   Lines of the test script that begin with the sharp character
   111    111   ("#", ASCII code 35)
   112    112   are comment lines and are ignored.  Comment lines are not considered blank
................................................................................
   115    115   allowed to occur in the middle of a record.  Comments
   116    116   that occurs in the middle of an SQL statement are stripped from the
   117    117   statement prior to the statement being sent to the database engine for
   118    118   evaluation.  Comments are logically removed from the script by a preprocessor.
   119    119   Hence, when we speak of the "first line of a record" we
   120    120   really mean the "first non-comment line of a record".
   121    121   
   122         -Each record is either a statement or a query.  A statement is an SQL
          122  +Most records are either a statement or a query.  A statement is an SQL
   123    123   command that is to be evaluated but from which we do not expect to get
   124    124   results (other than success or failure).  A statement might be a
   125    125   CREATE TABLE or an INSERT or an UPDATE or a DROP INDEX.  A query is an
   126    126   SQL command from which we expect to receive results.  The result set
   127    127   might be empty.
   128    128   
   129    129   A statement record begins with one of the following two lines:
................................................................................
   182    182   
   183    183   In the results section, integer values are rendered as if by
   184    184   printf("%d").  Floating point values are rendered as if by
   185    185   printf("%.3f").  NULL values are rendered as "NULL".  Empty
   186    186   strings are rendered as "(empty)".  Within non-empty strings,
   187    187   all control characters and unprintable characters are rendered as "@".
   188    188   
          189  +<h3>Control Records</h3>
          190  +
          191  +The test script might also contain control records.  A control record is
          192  +one of the following:
          193  +
          194  +<blockquote>
          195  +<tt>halt</tt><br>
          196  +<tt>hash-threshold</td> &lt;max-result-set-size&gt;
          197  +</blockquote>
          198  +
          199  +A "halt" record is intended for debugging use only.  A halt record merely
          200  +causes sqllogictest to ignore the rest of the test script.  A halt record
          201  +can be inserted after a query that is giving an anomalous result, causing
          202  +the database to be left in the state where it gives the unexpected answer.
          203  +After sqllogictest exist, manually debugging can then proceed.
          204  +
          205  +The "hash-threshold" record sets a limit on the number of values that can
          206  +appear in a result set.  If the number of values exceeds this, then instead
          207  +of recording each individual value in the full test script, an MD5 hash of
          208  +all values is computed in stored.  This makes the full test scripts much
          209  +shorter, but at the cost of obscuring the results.  If the hash-threshold
          210  +is 0, then results are never hashed.  A hash-threshold of 10 or 20 is
          211  +recommended.  During debugging, it is advantage to set the hash-threshold
          212  +to zero so that all results can be seen.
          213  +
   189    214   <h2>Suggestions For Generating Test-Scripts</h2>
   190    215   
   191    216   When sqllogictest runs a test script, it begins with a completely
   192    217   empty database.  So the first few records of any test script will
   193    218   typically be CREATE statements of various kinds and expecially
   194    219   CREATE TABLE statements.  In order to maximize the portability of
   195    220   scripts across database engines, it is suggested that test scripts stick 
................................................................................
   224    249   
   225    250     *  Generate a random WHERE clause.
   226    251   
   227    252     *  Generate a random string literal of some maximum length.
   228    253   
   229    254     *  Generate a random identifier which is not a keyword.
   230    255   
   231         -Use LIMIT and OFFSET clauses to keep results set sizes under control.
   232         -It is recommented that most queries use an ORDER BY clause so that
   233         -the order of values in the output is deterministic.  Of course, it
   234         -is also desirable to have some test cases that omit ORDER BY.  In those
   235         -cases use either the "rowsort" or "valuesort" modifiers at the beginning
          256  +Segregate queries that use LIMIT and OFFSET into separate test scripts
          257  +which are only run on database engines that support LIMIT and OFFSET.
          258  +
          259  +All queries should use either an ORDER BY clause so that
          260  +the order of values in the output is deterministic, or else
          261  +the "rowsort" or "valuesort" modifiers at the beginning
   236    262   of the query record to ensure that the output appears in the same order
   237    263   on all database engines.
   238    264   
   239    265   A typical test script will begin with some CREATE statements followed by
   240    266   some INSERT statements to add initial data.  This is followed by
   241    267   thousands of randomly generate UPDATE, DELETE, and INSERT statements.
   242    268   Several SELECT statements typical follow each UPDATE, DELETE, or INSERT

Changes to src/Makefile.

    14     14   #
    15     15   LIB = $(LDFLAGS)
    16     16   
    17     17   # You should not need to change anything below this line
    18     18   ###############################################################################
    19     19   #
    20     20   OBJ = \
           21  +  md5.o \
    21     22     sqlite3.o
    22     23   
    23     24   sqllogictest$(E):	sqllogictest.c sqllogictest.h $(OBJ)
    24     25   	$(CC) -o sqllogictest$(E) sqllogictest.c $(OBJ)
    25     26   
           27  +md5.o:	md5.c
           28  +	$(CC) -c md5.c
           29  +
    26     30   sqlite3.o:	sqlite3.c sqlite3.h
    27     31   	$(CC) -c sqlite3.c -DSQLITE_THREADSAFE=0 -DSQLITE_OMIT_LOAD_EXTENSION
    28     32   
    29     33   clean:
    30     34   	rm -f $(OBJ)

Added src/md5.c.

            1  +/*
            2  +** This code taken from the SQLite test library.  Originally found on
            3  +** the internet.  The original header comment follows this comment.
            4  +** The code is largerly unchanged, but there have been some modifications.
            5  +*/
            6  +/*
            7  + * This code implements the MD5 message-digest algorithm.
            8  + * The algorithm is due to Ron Rivest.  This code was
            9  + * written by Colin Plumb in 1993, no copyright is claimed.
           10  + * This code is in the public domain; do with it what you wish.
           11  + *
           12  + * Equivalent code is available from RSA Data Security, Inc.
           13  + * This code has been tested against that, and is equivalent,
           14  + * except that you don't need to include two pages of legalese
           15  + * with every copy.
           16  + *
           17  + * To compute the message digest of a chunk of bytes, declare an
           18  + * MD5Context structure, pass it to MD5Init, call MD5Update as
           19  + * needed on buffers full of bytes, and then call MD5Final, which
           20  + * will fill a supplied 16-byte array with the digest.
           21  + */
           22  +#include <string.h>
           23  +
           24  +/*
           25  + * If compiled on a machine that doesn't have a 32-bit integer,
           26  + * you just set "uint32" to the appropriate datatype for an
           27  + * unsigned 32-bit integer.  For example:
           28  + *
           29  + *       cc -Duint32='unsigned long' md5.c
           30  + *
           31  + */
           32  +#ifndef uint32
           33  +#  define uint32 unsigned int
           34  +#endif
           35  +
           36  +struct Context {
           37  +  int isInit;
           38  +  uint32 buf[4];
           39  +  uint32 bits[2];
           40  +  unsigned char in[64];
           41  +};
           42  +typedef struct Context MD5Context;
           43  +
           44  +/*
           45  + * Note: this code is harmless on little-endian machines.
           46  + */
           47  +static void byteReverse (unsigned char *buf, unsigned longs){
           48  +        uint32 t;
           49  +        do {
           50  +                t = (uint32)((unsigned)buf[3]<<8 | buf[2]) << 16 |
           51  +                            ((unsigned)buf[1]<<8 | buf[0]);
           52  +                *(uint32 *)buf = t;
           53  +                buf += 4;
           54  +        } while (--longs);
           55  +}
           56  +/* The four core functions - F1 is optimized somewhat */
           57  +
           58  +/* #define F1(x, y, z) (x & y | ~x & z) */
           59  +#define F1(x, y, z) (z ^ (x & (y ^ z)))
           60  +#define F2(x, y, z) F1(z, x, y)
           61  +#define F3(x, y, z) (x ^ y ^ z)
           62  +#define F4(x, y, z) (y ^ (x | ~z))
           63  +
           64  +/* This is the central step in the MD5 algorithm. */
           65  +#define MD5STEP(f, w, x, y, z, data, s) \
           66  +        ( w += f(x, y, z) + data,  w = w<<s | w>>(32-s),  w += x )
           67  +
           68  +/*
           69  + * The core of the MD5 algorithm, this alters an existing MD5 hash to
           70  + * reflect the addition of 16 longwords of new data.  MD5Update blocks
           71  + * the data and converts bytes into longwords for this routine.
           72  + */
           73  +static void MD5Transform(uint32 buf[4], const uint32 in[16]){
           74  +        register uint32 a, b, c, d;
           75  +
           76  +        a = buf[0];
           77  +        b = buf[1];
           78  +        c = buf[2];
           79  +        d = buf[3];
           80  +
           81  +        MD5STEP(F1, a, b, c, d, in[ 0]+0xd76aa478,  7);
           82  +        MD5STEP(F1, d, a, b, c, in[ 1]+0xe8c7b756, 12);
           83  +        MD5STEP(F1, c, d, a, b, in[ 2]+0x242070db, 17);
           84  +        MD5STEP(F1, b, c, d, a, in[ 3]+0xc1bdceee, 22);
           85  +        MD5STEP(F1, a, b, c, d, in[ 4]+0xf57c0faf,  7);
           86  +        MD5STEP(F1, d, a, b, c, in[ 5]+0x4787c62a, 12);
           87  +        MD5STEP(F1, c, d, a, b, in[ 6]+0xa8304613, 17);
           88  +        MD5STEP(F1, b, c, d, a, in[ 7]+0xfd469501, 22);
           89  +        MD5STEP(F1, a, b, c, d, in[ 8]+0x698098d8,  7);
           90  +        MD5STEP(F1, d, a, b, c, in[ 9]+0x8b44f7af, 12);
           91  +        MD5STEP(F1, c, d, a, b, in[10]+0xffff5bb1, 17);
           92  +        MD5STEP(F1, b, c, d, a, in[11]+0x895cd7be, 22);
           93  +        MD5STEP(F1, a, b, c, d, in[12]+0x6b901122,  7);
           94  +        MD5STEP(F1, d, a, b, c, in[13]+0xfd987193, 12);
           95  +        MD5STEP(F1, c, d, a, b, in[14]+0xa679438e, 17);
           96  +        MD5STEP(F1, b, c, d, a, in[15]+0x49b40821, 22);
           97  +
           98  +        MD5STEP(F2, a, b, c, d, in[ 1]+0xf61e2562,  5);
           99  +        MD5STEP(F2, d, a, b, c, in[ 6]+0xc040b340,  9);
          100  +        MD5STEP(F2, c, d, a, b, in[11]+0x265e5a51, 14);
          101  +        MD5STEP(F2, b, c, d, a, in[ 0]+0xe9b6c7aa, 20);
          102  +        MD5STEP(F2, a, b, c, d, in[ 5]+0xd62f105d,  5);
          103  +        MD5STEP(F2, d, a, b, c, in[10]+0x02441453,  9);
          104  +        MD5STEP(F2, c, d, a, b, in[15]+0xd8a1e681, 14);
          105  +        MD5STEP(F2, b, c, d, a, in[ 4]+0xe7d3fbc8, 20);
          106  +        MD5STEP(F2, a, b, c, d, in[ 9]+0x21e1cde6,  5);
          107  +        MD5STEP(F2, d, a, b, c, in[14]+0xc33707d6,  9);
          108  +        MD5STEP(F2, c, d, a, b, in[ 3]+0xf4d50d87, 14);
          109  +        MD5STEP(F2, b, c, d, a, in[ 8]+0x455a14ed, 20);
          110  +        MD5STEP(F2, a, b, c, d, in[13]+0xa9e3e905,  5);
          111  +        MD5STEP(F2, d, a, b, c, in[ 2]+0xfcefa3f8,  9);
          112  +        MD5STEP(F2, c, d, a, b, in[ 7]+0x676f02d9, 14);
          113  +        MD5STEP(F2, b, c, d, a, in[12]+0x8d2a4c8a, 20);
          114  +
          115  +        MD5STEP(F3, a, b, c, d, in[ 5]+0xfffa3942,  4);
          116  +        MD5STEP(F3, d, a, b, c, in[ 8]+0x8771f681, 11);
          117  +        MD5STEP(F3, c, d, a, b, in[11]+0x6d9d6122, 16);
          118  +        MD5STEP(F3, b, c, d, a, in[14]+0xfde5380c, 23);
          119  +        MD5STEP(F3, a, b, c, d, in[ 1]+0xa4beea44,  4);
          120  +        MD5STEP(F3, d, a, b, c, in[ 4]+0x4bdecfa9, 11);
          121  +        MD5STEP(F3, c, d, a, b, in[ 7]+0xf6bb4b60, 16);
          122  +        MD5STEP(F3, b, c, d, a, in[10]+0xbebfbc70, 23);
          123  +        MD5STEP(F3, a, b, c, d, in[13]+0x289b7ec6,  4);
          124  +        MD5STEP(F3, d, a, b, c, in[ 0]+0xeaa127fa, 11);
          125  +        MD5STEP(F3, c, d, a, b, in[ 3]+0xd4ef3085, 16);
          126  +        MD5STEP(F3, b, c, d, a, in[ 6]+0x04881d05, 23);
          127  +        MD5STEP(F3, a, b, c, d, in[ 9]+0xd9d4d039,  4);
          128  +        MD5STEP(F3, d, a, b, c, in[12]+0xe6db99e5, 11);
          129  +        MD5STEP(F3, c, d, a, b, in[15]+0x1fa27cf8, 16);
          130  +        MD5STEP(F3, b, c, d, a, in[ 2]+0xc4ac5665, 23);
          131  +
          132  +        MD5STEP(F4, a, b, c, d, in[ 0]+0xf4292244,  6);
          133  +        MD5STEP(F4, d, a, b, c, in[ 7]+0x432aff97, 10);
          134  +        MD5STEP(F4, c, d, a, b, in[14]+0xab9423a7, 15);
          135  +        MD5STEP(F4, b, c, d, a, in[ 5]+0xfc93a039, 21);
          136  +        MD5STEP(F4, a, b, c, d, in[12]+0x655b59c3,  6);
          137  +        MD5STEP(F4, d, a, b, c, in[ 3]+0x8f0ccc92, 10);
          138  +        MD5STEP(F4, c, d, a, b, in[10]+0xffeff47d, 15);
          139  +        MD5STEP(F4, b, c, d, a, in[ 1]+0x85845dd1, 21);
          140  +        MD5STEP(F4, a, b, c, d, in[ 8]+0x6fa87e4f,  6);
          141  +        MD5STEP(F4, d, a, b, c, in[15]+0xfe2ce6e0, 10);
          142  +        MD5STEP(F4, c, d, a, b, in[ 6]+0xa3014314, 15);
          143  +        MD5STEP(F4, b, c, d, a, in[13]+0x4e0811a1, 21);
          144  +        MD5STEP(F4, a, b, c, d, in[ 4]+0xf7537e82,  6);
          145  +        MD5STEP(F4, d, a, b, c, in[11]+0xbd3af235, 10);
          146  +        MD5STEP(F4, c, d, a, b, in[ 2]+0x2ad7d2bb, 15);
          147  +        MD5STEP(F4, b, c, d, a, in[ 9]+0xeb86d391, 21);
          148  +
          149  +        buf[0] += a;
          150  +        buf[1] += b;
          151  +        buf[2] += c;
          152  +        buf[3] += d;
          153  +}
          154  +
          155  +/*
          156  + * Start MD5 accumulation.  Set bit count to 0 and buffer to mysterious
          157  + * initialization constants.
          158  + */
          159  +static void MD5Init(MD5Context *ctx){
          160  +        ctx->isInit = 1;
          161  +        ctx->buf[0] = 0x67452301;
          162  +        ctx->buf[1] = 0xefcdab89;
          163  +        ctx->buf[2] = 0x98badcfe;
          164  +        ctx->buf[3] = 0x10325476;
          165  +        ctx->bits[0] = 0;
          166  +        ctx->bits[1] = 0;
          167  +}
          168  +
          169  +/*
          170  + * Update context to reflect the concatenation of another buffer full
          171  + * of bytes.
          172  + */
          173  +static 
          174  +void MD5Update(MD5Context *pCtx, const unsigned char *buf, unsigned int len){
          175  +        struct Context *ctx = (struct Context *)pCtx;
          176  +        uint32 t;
          177  +
          178  +        /* Update bitcount */
          179  +
          180  +        t = ctx->bits[0];
          181  +        if ((ctx->bits[0] = t + ((uint32)len << 3)) < t)
          182  +                ctx->bits[1]++; /* Carry from low to high */
          183  +        ctx->bits[1] += len >> 29;
          184  +
          185  +        t = (t >> 3) & 0x3f;    /* Bytes already in shsInfo->data */
          186  +
          187  +        /* Handle any leading odd-sized chunks */
          188  +
          189  +        if ( t ) {
          190  +                unsigned char *p = (unsigned char *)ctx->in + t;
          191  +
          192  +                t = 64-t;
          193  +                if (len < t) {
          194  +                        memcpy(p, buf, len);
          195  +                        return;
          196  +                }
          197  +                memcpy(p, buf, t);
          198  +                byteReverse(ctx->in, 16);
          199  +                MD5Transform(ctx->buf, (uint32 *)ctx->in);
          200  +                buf += t;
          201  +                len -= t;
          202  +        }
          203  +
          204  +        /* Process data in 64-byte chunks */
          205  +
          206  +        while (len >= 64) {
          207  +                memcpy(ctx->in, buf, 64);
          208  +                byteReverse(ctx->in, 16);
          209  +                MD5Transform(ctx->buf, (uint32 *)ctx->in);
          210  +                buf += 64;
          211  +                len -= 64;
          212  +        }
          213  +
          214  +        /* Handle any remaining bytes of data. */
          215  +
          216  +        memcpy(ctx->in, buf, len);
          217  +}
          218  +
          219  +/*
          220  + * Final wrapup - pad to 64-byte boundary with the bit pattern 
          221  + * 1 0* (64-bit count of bits processed, MSB-first)
          222  + */
          223  +static void MD5Final(unsigned char digest[16], MD5Context *pCtx){
          224  +        struct Context *ctx = (struct Context *)pCtx;
          225  +        unsigned count;
          226  +        unsigned char *p;
          227  +
          228  +        /* Compute number of bytes mod 64 */
          229  +        count = (ctx->bits[0] >> 3) & 0x3F;
          230  +
          231  +        /* Set the first char of padding to 0x80.  This is safe since there is
          232  +           always at least one byte free */
          233  +        p = ctx->in + count;
          234  +        *p++ = 0x80;
          235  +
          236  +        /* Bytes of padding needed to make 64 bytes */
          237  +        count = 64 - 1 - count;
          238  +
          239  +        /* Pad out to 56 mod 64 */
          240  +        if (count < 8) {
          241  +                /* Two lots of padding:  Pad the first block to 64 bytes */
          242  +                memset(p, 0, count);
          243  +                byteReverse(ctx->in, 16);
          244  +                MD5Transform(ctx->buf, (uint32 *)ctx->in);
          245  +
          246  +                /* Now fill the next block with 56 bytes */
          247  +                memset(ctx->in, 0, 56);
          248  +        } else {
          249  +                /* Pad block to 56 bytes */
          250  +                memset(p, 0, count-8);
          251  +        }
          252  +        byteReverse(ctx->in, 14);
          253  +
          254  +        /* Append length in bits and transform */
          255  +        ((uint32 *)ctx->in)[ 14 ] = ctx->bits[0];
          256  +        ((uint32 *)ctx->in)[ 15 ] = ctx->bits[1];
          257  +
          258  +        MD5Transform(ctx->buf, (uint32 *)ctx->in);
          259  +        byteReverse((unsigned char *)ctx->buf, 4);
          260  +        memcpy(digest, ctx->buf, 16);
          261  +        memset(ctx, 0, sizeof(ctx));    /* In case it is sensitive */
          262  +}
          263  +
          264  +/*
          265  +** Convert a digest into base-16.  digest should be declared as
          266  +** "unsigned char digest[16]" in the calling function.  The MD5
          267  +** digest is stored in the first 16 bytes.  zBuf should
          268  +** be "char zBuf[33]".
          269  +*/
          270  +static void DigestToBase16(unsigned char *digest, char *zBuf){
          271  +  static char const zEncode[] = "0123456789abcdef";
          272  +  int i, j;
          273  +
          274  +  for(j=i=0; i<16; i++){
          275  +    int a = digest[i];
          276  +    zBuf[j++] = zEncode[(a>>4)&0xf];
          277  +    zBuf[j++] = zEncode[a & 0xf];
          278  +  }
          279  +  zBuf[j] = 0;
          280  +}
          281  +
          282  +/*
          283  +** Status of an MD5 hash.
          284  +*/
          285  +static MD5Context ctx;
          286  +static int isInit = 0;
          287  +static char zResult[34] = "";
          288  +
          289  +/*
          290  +** Add additional text to the current MD5 hash.
          291  +*/
          292  +void md5_add(const char *z){
          293  +  if( !isInit ){
          294  +    MD5Init(&ctx);
          295  +    isInit = 1;
          296  +  }
          297  +  MD5Update(&ctx, (unsigned char*)z, (unsigned)strlen(z));
          298  +}
          299  +
          300  +/*
          301  +** Compute the final signature.  Reset the hash generator in preparation
          302  +** for the next round.
          303  +*/
          304  +const char *md5_finish(void){
          305  +  if( isInit ){
          306  +    unsigned char digest[16];
          307  +    MD5Final(digest, &ctx);
          308  +    isInit = 0;
          309  +    DigestToBase16(digest, zResult);
          310  +  }
          311  +  return zResult;
          312  +}

Changes to src/slt_odbc3.c.

    28     28   ** On connect, it will attempt to "DROP" all existing tables 
    29     29   ** from the database name 'slt' to reset it to a known status.
    30     30   **
    31     31   ** The DSN name and DB name are controlled by the defines
    32     32   ** SLT_DSN and SLT_DB.
    33     33   **
    34     34   */
           35  +#ifndef OMIT_ODBC  /* Omit this module if OMIT_ODBC is defined */
           36  +
    35     37   #ifdef WIN32
    36     38   #include <windows.h>
    37     39   #endif
    38     40   #define SQL_NOUNICODEMAP
    39     41   #include <sql.h>
    40     42   #include <sqlext.h>
    41     43   
................................................................................
   523    525     };
   524    526     sqllogictestRegisterEngine(&ODBC3DbEngine);
   525    527   }
   526    528   
   527    529   /*
   528    530   **************** End of the ODBC3 database engine interface *****************
   529    531   *****************************************************************************/
          532  +#endif /* OMIT_ODBC */

Changes to src/sqllogictest.c.

   242    242   /*
   243    243   ** This is the main routine.  This routine runs first.  It processes
   244    244   ** command-line arguments then runs the test.
   245    245   */
   246    246   int main(int argc, char **argv){
   247    247     int verifyMode = 0;                  /* True if in -verify mode */
   248    248     const char *zScriptFile = 0;         /* Input script filename */
   249         -  const char *zDbEngine = NULL;        /* Name of database engine */
          249  +  const char *zDbEngine = "SQLite";    /* Name of database engine */
   250    250     const char *zConnection = 0;         /* Connection string on DB engine */
   251    251     const DbEngine *pEngine = 0;         /* Pointer to DbEngine object */
   252    252     int i;                               /* Loop counter */
   253    253     char *zScript;                       /* Content of the script */
   254    254     long nScript;                        /* Size of the script in bytes */
   255    255     void *pConn;                         /* Connection to the database engine */
   256    256     int rc;                              /* Result code from subroutine call */
   257    257     int nErr = 0;                        /* Number of errors */
   258    258     int nCmd = 0;                        /* Number of SQL statements processed */
   259    259     int nResult;                         /* Number of query results */
   260    260     char **azResult;                     /* Query result vector */
   261    261     Script sScript;                      /* Script parsing status */
   262    262     FILE *in;                            /* For reading script */
          263  +  int hashThreshold = 0;               /* Hash result if this long or longer */
   263    264     
   264    265   
   265    266     /* Add calls to the registration procedures for new database engine
   266    267     ** interfaces here
   267    268     */
   268    269     registerSqlite();
          270  +#ifndef OMIT_ODBC
   269    271     registerODBC3();
          272  +#endif
   270    273   
   271    274     /* Report an error if no registered engines
   272    275     */
   273    276     if( nEngine == 0 ){
   274    277       fprintf(stderr, "%s: no registered database engines\n", argv[0]);
   275    278       usage(argv[0]);
   276    279     }
................................................................................
   283    286   
   284    287     /* Scan the command-line and process arguments
   285    288     */
   286    289     for(i=1; i<argc; i++){
   287    290       int n = (int)strlen(argv[i]);
   288    291       if( strncmp(argv[i], "-verify",n)==0 ){
   289    292         verifyMode = 1;
          293  +#if 0  /* Obsolete code */
   290    294       }else if( strncmp(argv[i], "-engine",n)==0 ){
   291    295         zDbEngine = argv[++i];
   292    296       }else if( strncmp(argv[i], "-connection",n)==0 ){
   293    297         zConnection = argv[++i];
          298  +#endif
          299  +    }else if( strncmp(argv[i], "-odbc",n)==0 ){
          300  +      zDbEngine = "ODBC3";
          301  +      zConnection = argv[++i];
   294    302       }else if( zScriptFile==0 ){
   295    303         zScriptFile = argv[i];
   296    304       }else{
   297    305         fprintf(stderr, "%s: unknown argument: %s\n", argv[0], argv[i]);
   298    306         usage(argv[0]);
   299    307       }
   300    308     }
................................................................................
   462    470           nColumn = 1;
   463    471           qsort(azResult, nResult, sizeof(azResult[0]), rowCompare);
   464    472         }else{
   465    473           fprintf(stderr, "%s:%d: unknown sort method: '%s'\n",
   466    474                   zScriptFile, sScript.startLine, sScript.azToken[2]);
   467    475           nErr++;
   468    476         }
          477  +
          478  +      /* Hash the results if we are over the hash threshold */
          479  +      if( hashThreshold>0 && nResult>hashThreshold ){
          480  +        for(i=0; i<nResult; i++){
          481  +          md5_add(azResult[i]);
          482  +          md5_add("\n");
          483  +        }
          484  +      }
   469    485   
   470    486         if( verifyMode ){
   471    487           /* In verify mode, first skip over the ---- line if we are still
   472    488           ** pointing at it. */
   473    489           if( strcmp(sScript.zLine, "----")==0 ) nextLine(&sScript);
   474    490   
   475    491           /* Compare subsequent lines of the script against the results
   476    492           ** from the query.  Report an error if any differences are found.
   477    493           */
   478         -        for(i=0; i<nResult && sScript.zLine[0]; nextLine(&sScript), i++){
   479         -          if( strcmp(sScript.zLine, azResult[i])!=0 ){
   480         -            fprintf(stderr,"%s:%d: wrong result\n", zScriptFile,
   481         -                    sScript.nLine);
          494  +        if( hashThreshold==0 || nResult<=hashThreshold ){
          495  +          for(i=0; i<nResult && sScript.zLine[0]; nextLine(&sScript), i++){
          496  +            if( strcmp(sScript.zLine, azResult[i])!=0 ){
          497  +              fprintf(stderr,"%s:%d: wrong result\n", zScriptFile,
          498  +                      sScript.nLine);
          499  +              nErr++;
          500  +              break;
          501  +            }
          502  +          }
          503  +        }else{
          504  +          if( strcmp(sScript.zLine, md5_finish())!=0 ){
          505  +            fprintf(stderr, "%s:%d: wrong result hash\n",
          506  +                    zScriptFile, sScript.nLine);
   482    507               nErr++;
   483         -            break;
   484    508             }
   485    509           }
   486    510         }else{
   487    511           /* In completion mode, first make sure we have output an ---- line.
   488    512           ** Output such a line now if we have not already done so.
   489    513           */
   490    514           if( strcmp(sScript.zLine, "----")!=0 ){
   491    515             printf("----\n");
   492    516           }
   493    517   
   494    518           /* Output the results obtained by running the query
   495    519           */
   496         -        for(i=0; i<nResult; i++){
   497         -          printf("%s\n", azResult[i]);
          520  +        if( hashThreshold==0 || nResult<=hashThreshold ){
          521  +          for(i=0; i<nResult; i++){
          522  +            printf("%s\n", azResult[i]);
          523  +          }
          524  +        }else{
          525  +          printf("%s\n", md5_finish());
   498    526           }
   499    527           printf("\n");
   500    528   
   501    529           /* Skip over any existing results.  They will be ignored.
   502    530           */
   503    531           sScript.copyFlag = 0;
   504    532           while( sScript.zLine[0]!=0 && sScript.iCur<sScript.iEnd ){
................................................................................
   505    533             nextLine(&sScript);
   506    534           }
   507    535           sScript.copyFlag = 1;
   508    536         }
   509    537   
   510    538         /* Free the query results */
   511    539         pEngine->xFreeResults(pConn, azResult, nResult);
          540  +    }else if( strcmp(sScript.azToken[0],"hash-threshold")==0 ){
          541  +      /* Set the maximum number of result values that will be accepted
          542  +      ** for a query.  If the number of result values exceeds this number,
          543  +      ** then an MD5 hash is computed of all values, and the resulting hash
          544  +      ** is the only result.
          545  +      **
          546  +      ** If the threshold is 0, then hashing is never used.
          547  +      */
          548  +      hashThreshold = atoi(sScript.azToken[1]);
          549  +    }else if( strcmp(sScript.azToken[0],"halt")==0 ){
          550  +      /* Used for debugging.  Stop reading the test script and shut down.
          551  +      ** A "halt" record can be inserted in the middle of a test script in
          552  +      ** to run the script up to a particular point that is giving a
          553  +      ** faulty result, then terminate at that point for analysis.
          554  +      */
          555  +      fprintf(stderr, "%s:%d: halt\n", zScriptFile, sScript.startLine);
          556  +      break;
   512    557       }else{
   513    558         /* An unrecognized record type is an error */
   514    559         fprintf(stderr, "%s:%d: unknown record type: '%s'\n",
   515    560                 zScriptFile, sScript.startLine, sScript.azToken[0]);
   516    561         nErr++;
          562  +      break;
   517    563       }
   518    564     }
   519    565   
   520    566   
   521    567     /* Shutdown the database connection.
   522    568     */
   523    569     rc = pEngine->xDisconnect(pConn);

Changes to src/sqllogictest.h.

    42     42   };
    43     43   
    44     44   /*
    45     45   ** Each database engine interface invokes the following routine
    46     46   ** to register itself with the main sqllogictest driver.
    47     47   */
    48     48   void sqllogictestRegisterEngine(const DbEngine*);
           49  +
           50  +
           51  +/*
           52  +** MD5 hashing routines.
           53  +*/
           54  +void md5_add(const char *z);
           55  +const char *md5_finish(void);