/ Check-in [0242c9e4]
Login

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

Overview
Comment:Change the table record format to support manifest typing. (CVS 1361)
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | trunk
Files: files | file ages | folders
SHA1: 0242c9e4f7c85e9c911cf30d90b0cdb1015f3d7d
User & Date: danielk1977 2004-05-12 07:33:33
Context
2004-05-12
11:24
Add some more code to support manifest typing in indices. Not activated yet. (CVS 1362) check-in: 2f16c9ef user: danielk1977 tags: trunk
07:33
Change the table record format to support manifest typing. (CVS 1361) check-in: 0242c9e4 user: danielk1977 tags: trunk
2004-05-11
10:04
Change sqlite_ to sqlite3_ in the attach2.test test script. (CVS 1360) check-in: 98f756e6 user: drh tags: trunk
Changes
Hide Diffs Unified Diffs Show Whitespace Changes Patch

Changes to src/printf.c.

354
355
356
357
358
359
360








361
362
363
364
365
366

367
368
369
370
371
372
373
        if( longvalue==0 ) flag_alternateform = 0;
#else
        /* More sensible: turn off the prefix for octal (to prevent "00"),
        ** but leave the prefix for hex. */
        if( longvalue==0 && infop->base==8 ) flag_alternateform = 0;
#endif
        if( infop->flags & FLAG_SIGNED ){








          if( *(long*)&longvalue<0 ){
            longvalue = -*(long*)&longvalue;
            prefix = '-';
          }else if( flag_plussign )  prefix = '+';
          else if( flag_blanksign )  prefix = ' ';
          else                       prefix = 0;

        }else                        prefix = 0;
        if( flag_zeropad && precision<width-(prefix!=0) ){
          precision = width-(prefix!=0);
        }
        bufpt = &buf[etBUFSIZE-1];
        {
          register char *cset;      /* Use registers for speed */







>
>
>
>
>
>
>
>






>







354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
        if( longvalue==0 ) flag_alternateform = 0;
#else
        /* More sensible: turn off the prefix for octal (to prevent "00"),
        ** but leave the prefix for hex. */
        if( longvalue==0 && infop->base==8 ) flag_alternateform = 0;
#endif
        if( infop->flags & FLAG_SIGNED ){
          if( flag_longlong ){
            if( *(i64*)&longvalue<0 ){
              longvalue = -*(i64*)&longvalue;
              prefix = '-';
            }else if( flag_plussign )  prefix = '+';
            else if( flag_blanksign )  prefix = ' ';
            else                       prefix = 0;
          }else{
            if( *(long*)&longvalue<0 ){
              longvalue = -*(long*)&longvalue;
              prefix = '-';
            }else if( flag_plussign )  prefix = '+';
            else if( flag_blanksign )  prefix = ' ';
            else                       prefix = 0;
          }
        }else                        prefix = 0;
        if( flag_zeropad && precision<width-(prefix!=0) ){
          precision = width-(prefix!=0);
        }
        bufpt = &buf[etBUFSIZE-1];
        {
          register char *cset;      /* Use registers for speed */

Changes to src/sqliteInt.h.

7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
....
1284
1285
1286
1287
1288
1289
1290


**    May you do good and not evil.
**    May you find forgiveness for yourself and forgive others.
**    May you share freely, never taking more than you give.
**
*************************************************************************
** Internal interface definitions for SQLite.
**
** @(#) $Id: sqliteInt.h,v 1.229 2004/05/10 23:29:50 drh Exp $
*/
#include "config.h"
#include "sqlite.h"
#include "hash.h"
#include "parse.h"
#include <stdio.h>
#include <stdlib.h>
................................................................................
void *sqlite3utf8to16be(const unsigned char *pIn, int N);
void *sqlite3utf8to16le(const unsigned char *pIn, int N);
void sqlite3utf16to16le(void *pData, int N);
void sqlite3utf16to16be(void *pData, int N);
int sqlite3PutVarint(unsigned char *, u64);
int sqlite3GetVarint(const unsigned char *, u64 *);
int sqlite3VarintLen(u64 v);









|







 







>
>
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
....
1284
1285
1286
1287
1288
1289
1290
1291
1292
**    May you do good and not evil.
**    May you find forgiveness for yourself and forgive others.
**    May you share freely, never taking more than you give.
**
*************************************************************************
** Internal interface definitions for SQLite.
**
** @(#) $Id: sqliteInt.h,v 1.230 2004/05/12 07:33:33 danielk1977 Exp $
*/
#include "config.h"
#include "sqlite.h"
#include "hash.h"
#include "parse.h"
#include <stdio.h>
#include <stdlib.h>
................................................................................
void *sqlite3utf8to16be(const unsigned char *pIn, int N);
void *sqlite3utf8to16le(const unsigned char *pIn, int N);
void sqlite3utf16to16le(void *pData, int N);
void sqlite3utf16to16be(void *pData, int N);
int sqlite3PutVarint(unsigned char *, u64);
int sqlite3GetVarint(const unsigned char *, u64 *);
int sqlite3VarintLen(u64 v);


Changes to src/vdbe.c.

39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
...
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
....
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
....
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839

1840
1841
1842



1843
1844


1845
1846
1847
1848
1849
1850
1851
1852





1853
1854
1855
1856
1857
1858
1859
....
1878
1879
1880
1881
1882
1883
1884
1885



1886
1887

1888
1889



1890
1891

1892
1893

1894
1895

1896

1897
1898
1899















1900
1901
1902








1903
1904


1905





1906
1907
1908
1909
1910
1911
1912
1913
1914



1915

1916
1917
1918
1919





1920
1921
1922
1923
1924
1925
1926





1927




1928
1929
1930
1931

1932

1933
1934
1935






1936
1937







1938
1939
1940



1941
1942

1943
1944
1945
1946
1947
1948
1949
1950
1951




1952


1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964


1965

1966
1967
1968
1969
1970
1971
1972
1973
1974
....
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017

2018
2019
2020
2021
2022
2023
2024

2025

2026
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054
2055
2056
2057
2058







2059
2060
2061
2062
2063
2064
2065
2066
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103
2104
2105
2106
2107
2108
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120
2121
2122
2123
2124
2125
2126
2127
2128
2129
2130
2131
2132
2133
2134
2135
2136
2137
2138
2139
2140
2141
2142
2143
2144
2145
2146
2147
2148
2149
2150
2151
2152
2153
2154
2155
2156
2157
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167
2168
2169
2170
2171
2172
2173
2174
2175
2176
2177
2178
2179
2180
2181
2182
2183
2184
2185
2186
2187
2188
2189
2190
2191
2192
2193
2194
2195
2196
2197
2198
2199
2200
2201
2202
2203
2204
....
3395
3396
3397
3398
3399
3400
3401
3402
3403
3404
3405
3406
3407
3408
3409
3410
3411
3412
3413
3414
3415
3416
3417
3418
3419
3420
3421
3422
3423
3424
3425
3426
3427
3428
3429
3430
3431
3432
3433
3434
3435
3436
3437
3438
3439
3440
3441
3442
3443
3444
3445
3446
3447
3448
3449
3450
3451
3452
3453
3454
3455
3456
3457
3458
3459
3460
3461
3462
3463
3464
3465
3466
3467
3468
3469
3470
3471
3472
3473
3474
3475
3476
3477
3478
3479
3480
3481
3482
3483
3484
3485
3486
3487
3488
3489
3490
3491
3492
3493
3494
3495
3496
3497
3498
3499
3500
3501
3502
3503
3504
3505
3506
3507
3508
3509
3510
3511
3512
3513
3514
3515
3516
3517
3518
3519
3520
3521
3522
3523
3524
3525
3526
3527
3528
3529
3530
3531
3532
3533
3534
3535
3536
3537
**
** Various scripts scan this source file in order to generate HTML
** documentation, headers files, or other derived files.  The formatting
** of the code in this file is, therefore, important.  See other comments
** in this file for details.  If in doubt, do not deviate from existing
** commenting and indentation practices when changing or adding code.
**
** $Id: vdbe.c,v 1.282 2004/05/11 09:57:35 drh Exp $
*/
#include "sqliteInt.h"
#include "os.h"
#include <ctype.h>
#include "vdbeInt.h"

/*
................................................................................
*/
#define Stringify(P) if(((P)->flags & MEM_Str)==0){hardStringify(P);}
static int hardStringify(Mem *pStack){
  int fg = pStack->flags;
  if( fg & MEM_Real ){
    sqlite3_snprintf(sizeof(pStack->zShort),pStack->zShort,"%.15g",pStack->r);
  }else if( fg & MEM_Int ){
    sqlite3_snprintf(sizeof(pStack->zShort),pStack->zShort,"%d",pStack->i);
  }else{
    pStack->zShort[0] = 0;
  }
  pStack->z = pStack->zShort;
  pStack->n = strlen(pStack->zShort)+1;
  pStack->flags = MEM_Str | MEM_Short;
  return 0;
................................................................................
  assert( pNos>=p->aStack );
  if( ((pTos->flags | pNos->flags) & MEM_Null)!=0 ){
    Release(pTos);
    pTos--;
    Release(pTos);
    pTos->flags = MEM_Null;
  }else if( (pTos->flags & pNos->flags & MEM_Int)==MEM_Int ){
    int a, b;
    a = pTos->i;
    b = pNos->i;
    switch( pOp->opcode ){
      case OP_Add:         b += a;       break;
      case OP_Subtract:    b -= a;       break;
      case OP_Multiply:    b *= a;       break;
      case OP_Divide: {
................................................................................
  if( i>=cnt ) pc = pOp->p2-1;
  if( pOp->p1>0 ) popStack(&pTos, cnt);
  break;
}

/* Opcode: Column3 P1 P2 *
**
** This opcode (not yet in use) is a replacement for the current
** OP_Column3 that supports the SQLite3 manifest typing feature.
**
** Interpret the data that cursor P1 points to as
** a structure built using the MakeRecord instruction.
** (See the MakeRecord opcode for additional information about
** the format of the data.)
** Push onto the stack the value of the P2-th column contained
** in the data.
**
** If the KeyAsData opcode has previously executed on this cursor,
** then the field might be extracted from the key rather than the
** data.
**
** If P1 is negative, then the record is stored on the stack rather
** than in a table.  For P1==-1, the top of the stack is used.
** For P1==-2, the next on the stack is used.  And so forth.  The
** value pushed is always just a pointer into the record which is
** stored further down on the stack.  The column value is not copied.
*/
case OP_Column3: {
  int payloadSize;
  int i = pOp->p1;
  int p2 = pOp->p2;
  Cursor *pC;
  char *zRec;

  BtCursor *pCrsr;

  char *zHdr = 0;



  int freeZHdr = 0;
  int dataOffsetLen;


  u64 dataOffset;
  char *zIdx = 0;
  int cnt;
  u64 idxN;
  u64 idxN1;

  assert( i<p->nCursor );
  pTos++;





  if( i<0 ){
    assert( &pTos[i]>=p->aStack );
    assert( pTos[i].flags & MEM_Str );
    zRec = pTos[i].z;
    payloadSize = pTos[i].n;
  }else if( (pC = &p->aCsr[i])->pCursor!=0 ){
    sqlite3VdbeCursorMoveto(pC);
................................................................................

  /* If payloadSize is 0, then just push a NULL onto the stack. */
  if( payloadSize==0 ){
    pTos->flags = MEM_Null;
    break;
  }

  /* Read the data-offset for this record */



  if( zRec ){
    dataOffsetLen = sqlite3GetVarint(zRec, &dataOffset);

  }else{
    unsigned char zDataOffset[9];



    if( pC->keyAsData ){
      sqlite3BtreeKey(pCrsr, 0, 9, zDataOffset);

    }else{
      sqlite3BtreeData(pCrsr, 0, 9, zDataOffset);

    }
    dataOffsetLen = sqlite3GetVarint(zDataOffset, &dataOffset);

  }


  /* Set zHdr to point at the start of the Idx() fields of the
  ** record. Set freeZHdr to 1 if we need to sqliteFree(zHdr) later.















  */
  if( zRec ){
    zHdr = zRec + dataOffsetLen;








  }else{
    zHdr = sqliteMalloc(dataOffset);


    if( !zHdr ){





      rc = SQLITE_NOMEM;
      goto abort_due_to_error;
    }
    freeZHdr = 1;
    if( pC->keyAsData ){
      sqlite3BtreeKey(pCrsr, dataOffsetLen, dataOffset, zHdr);
    }else{
      sqlite3BtreeData(pCrsr, dataOffsetLen, dataOffset, zHdr);
    }



  }


  /* Find the Nth byte of zHdr that does not have the 0x80
  ** bit set. The byte after this one is the start of the Idx(N)
  ** varint. Then read Idx(N) and Idx(N+1)





  */
  cnt = p2;
  zIdx = zHdr;
  while( cnt>0 ){
    assert( (zIdx-zHdr)<dataOffset );
    if( !(*zIdx & 0x80) ) cnt--;
    zIdx++;





  }




  zIdx += sqlite3GetVarint(zIdx, &idxN);
  sqlite3GetVarint(zIdx, &idxN1);

  /* Set zHdr to point at the field data */

  if( freeZHdr ){

    sqliteFree(zHdr);
    freeZHdr = 0;
  }






  if( zRec ){
    zHdr = zRec + (dataOffsetLen + dataOffset + idxN);







  }else{
    cnt = idxN1 - idxN;
    assert( cnt>0 );



    zHdr = sqliteMalloc(cnt);
    if( !zHdr ){

      rc = SQLITE_NOMEM;
      goto abort_due_to_error;
    }
    freeZHdr = 1;
    if( pC->keyAsData ){
      sqlite3BtreeKey(pCrsr, dataOffsetLen+dataOffset+idxN, cnt, zHdr);
    }else{
      sqlite3BtreeData(pCrsr, dataOffsetLen+dataOffset+idxN, cnt, zHdr);
    }




  }



  /* Deserialize the field value directory into the top of the
  ** stack. If the deserialized length does not match the expected
  ** length, this indicates corruption.
  */
  if( (idxN1-idxN)!=sqlite3VdbeDeserialize(pTos, zHdr) ){
    if( freeZHdr ){
      sqliteFree(zHdr);
    }
    rc = SQLITE_CORRUPT;
    goto abort_due_to_error;
  }




  if( freeZHdr ){
    sqliteFree(zHdr);
  }
  break;
}

/* Opcode MakeRecord3 P1 * *
**
** This opcode (not yet in use) is a replacement for the current
................................................................................
**
** Convert the top P1 entries of the stack into a single entry
** suitable for use as a data record in a database table.  The
** details of the format are irrelavant as long as the OP_Column
** opcode can decode the record later.  Refer to source code
** comments for the details of the record format.
*/
case OP_MakeRecord3: {
  /* Assuming the record contains N fields, the record format looks
  ** like this:
  **
  ** --------------------------------------------------------------------------
  ** | data-offset | idx1 | ... | idx(N-1) | idx(N) | data0 | ... | data(N-1) |
  ** --------------------------------------------------------------------------
  **
  ** Data(0) is taken from the lowest element of the stack and data(N-1) is
  ** the top of the stack.
  **
  ** The data-offset and each of the idx() entries is stored as a 1-9 
  ** byte variable-length integer (see comments in btree.c). The
  ** data-offset contains the offset from the end of itself to the start 
  ** of data(0).
  ** 
  ** Idx(k) contains the offset from the start of data(0) to the first 
  ** byte of data(k). Idx(0) is implicitly 0. Hence:
  ** 
  **    sizeof(data-offset) + data-offset + Idx(N) 
  **
  ** is the number of bytes in the record. The offset to start of data(X)
  ** is sizeof(data-offset) + data-offset + Idx(X
  **
  ** TODO: Even when the record is short enough for Mem::zShort, this opcode
  **   allocates it dynamically.
  */
  int nDataLen = 0;
  int nHdrLen = 0;
  int data_offset = 0;
  int nField = pOp->p1;
  unsigned char *zNewRecord;
  unsigned char *zHdr;
  Mem *pRec;


  Mem *pData0 = &pTos[1-nField];
  assert( pData0>=p->aStack );

  /* Loop through the elements that will make up the record, determining
  ** the aggregate length of the Data() segments and the data_offset.
  */

  for(pRec=pData0; pRec!=pTos; pRec++){

    nDataLen += sqlite3VdbeSerialLen(pRec);
    data_offset += sqlite3VarintLen(nDataLen);
  }
 
  /* The size of the header is the data-offset + the size of the
  ** data-offset as a varint. If the size of the header combined with
  ** the size of the Data() segments is greater than MAX_BYTES_PER_ROW, 
  ** report an error.
  */
  nHdrLen = data_offset + sqlite3VarintLen(data_offset);
  if( (nHdrLen+nDataLen)>MAX_BYTES_PER_ROW ){
    rc = SQLITE_TOOBIG;
    goto abort_due_to_error;
  }

  /* Allocate space for the new row. */
  zNewRecord = sqliteMalloc(nHdrLen+nDataLen);
  if( !zNewRecord ){
    rc = SQLITE_NOMEM;
    goto abort_due_to_error;
  }

  /* Write the data offset */
  zHdr = zNewRecord;
  zHdr += sqlite3PutVarint(zHdr, data_offset);

  /* Loop through the values on the stack writing both the serialized value
  ** and the the Idx() offset for each.
  */
  nDataLen = 0;
  for(pRec=pData0; pRec!=pTos; pRec++){
    nDataLen += sqlite3VdbeSerialize(pRec, &zNewRecord[nDataLen]);
    zHdr += sqlite3PutVarint(zHdr, nDataLen);







  }

  /* Pop nField entries from the stack and push the new entry on */
  popStack(&pTos, nField);
  pTos++;
  pTos->n = nDataLen+nHdrLen;
  pTos->z = zNewRecord;
  pTos->flags = MEM_Str | MEM_Dyn;

  break;
}

/* Opcode: MakeRecord P1 P2 *
**
** Convert the top P1 entries of the stack into a single entry
** suitable for use as a data record in a database table.  The
** details of the format are irrelavant as long as the OP_Column
** opcode can decode the record later.  Refer to source code
** comments for the details of the record format.
**
** If P2 is true (non-zero) and one or more of the P1 entries
** that go into building the record is NULL, then add some extra
** bytes to the record to make it distinct for other entries created
** during the same run of the VDBE.  The extra bytes added are a
** counter that is reset with each run of the VDBE, so records
** created this way will not necessarily be distinct across runs.
** But they should be distinct for transient tables (created using
** OP_OpenTemp) which is what they are intended for.
**
** (Later:) The P2==1 option was intended to make NULLs distinct
** for the UNION operator.  But I have since discovered that NULLs
** are indistinct for UNION.  So this option is never used.
*/
case OP_MakeRecord: {
  char *zNewRecord;
  int nByte;
  int nField;
  int i, j;
  int idxWidth;
  u32 addr;
  Mem *pRec;
  int addUnique = 0;   /* True to cause bytes to be added to make the
                       ** generated record distinct */
  char zTemp[NBFS];    /* Temp space for small records */

  /* Assuming the record contains N fields, the record format looks
  ** like this:
  **
  **   -------------------------------------------------------------------
  **   | idx0 | idx1 | ... | idx(N-1) | idx(N) | data0 | ... | data(N-1) |
  **   -------------------------------------------------------------------
  **
  ** All data fields are converted to strings before being stored and
  ** are stored with their null terminators.  NULL entries omit the
  ** null terminator.  Thus an empty string uses 1 byte and a NULL uses
  ** zero bytes.  Data(0) is taken from the lowest element of the stack
  ** and data(N-1) is the top of the stack.
  **
  ** Each of the idx() entries is either 1, 2, or 3 bytes depending on
  ** how big the total record is.  Idx(0) contains the offset to the start
  ** of data(0).  Idx(k) contains the offset to the start of data(k).
  ** Idx(N) contains the total number of bytes in the record.
  */
  nField = pOp->p1;
  pRec = &pTos[1-nField];
  assert( pRec>=p->aStack );
  nByte = 0;
  for(i=0; i<nField; i++, pRec++){
    if( pRec->flags & MEM_Null ){
      addUnique = pOp->p2;
    }else{
      Stringify(pRec);
      nByte += pRec->n;
    }
  }
  if( addUnique ) nByte += sizeof(p->uniqueCnt);
  if( nByte + nField + 1 < 256 ){
    idxWidth = 1;
  }else if( nByte + 2*nField + 2 < 65536 ){
    idxWidth = 2;
  }else{
    idxWidth = 3;
  }
  nByte += idxWidth*(nField + 1);
  if( nByte>MAX_BYTES_PER_ROW ){
    rc = SQLITE_TOOBIG;
    goto abort_due_to_error;
  }
  if( nByte<=NBFS ){
    zNewRecord = zTemp;
  }else{
    zNewRecord = sqliteMallocRaw( nByte );
    if( zNewRecord==0 ) goto no_mem;
  }
  j = 0;
  addr = idxWidth*(nField+1) + addUnique*sizeof(p->uniqueCnt);
  for(i=0, pRec=&pTos[1-nField]; i<nField; i++, pRec++){
    zNewRecord[j++] = addr & 0xff;
    if( idxWidth>1 ){
      zNewRecord[j++] = (addr>>8)&0xff;
      if( idxWidth>2 ){
        zNewRecord[j++] = (addr>>16)&0xff;
      }
    }
    if( (pRec->flags & MEM_Null)==0 ){
      addr += pRec->n;
    }
  }
  zNewRecord[j++] = addr & 0xff;
  if( idxWidth>1 ){
    zNewRecord[j++] = (addr>>8)&0xff;
    if( idxWidth>2 ){
      zNewRecord[j++] = (addr>>16)&0xff;
    }
  }
  if( addUnique ){
    memcpy(&zNewRecord[j], &p->uniqueCnt, sizeof(p->uniqueCnt));
    p->uniqueCnt++;
    j += sizeof(p->uniqueCnt);
  }
  for(i=0, pRec=&pTos[1-nField]; i<nField; i++, pRec++){
    if( (pRec->flags & MEM_Null)==0 ){
      memcpy(&zNewRecord[j], pRec->z, pRec->n);
      j += pRec->n;
    }
  }
  popStack(&pTos, nField);
  pTos++;
  pTos->n = nByte;
  if( nByte<=NBFS ){
    assert( zNewRecord==zTemp );
    memcpy(pTos->zShort, zTemp, nByte);
    pTos->z = pTos->zShort;
    pTos->flags = MEM_Str | MEM_Short;
  }else{
    assert( zNewRecord!=zTemp );
    pTos->z = zNewRecord;
    pTos->flags = MEM_Str | MEM_Dyn;
  }
  break;
}

/* Opcode: MakeKey P1 P2 P3
**
** Convert the top P1 entries of the stack into a single entry suitable
** for use as the key in an index.  The top P1 records are
................................................................................
  }else if( pC->pseudoTable ){
    pTos->n = pC->nData;
    pTos->z = pC->pData;
    pTos->flags = MEM_Str|MEM_Ephem;
  }else{
    pTos->flags = MEM_Null;
  }
  break;
}

/* Opcode: Column P1 P2 *
**
** Interpret the data that cursor P1 points to as
** a structure built using the MakeRecord instruction.
** (See the MakeRecord opcode for additional information about
** the format of the data.)
** Push onto the stack the value of the P2-th column contained
** in the data.
**
** If the KeyAsData opcode has previously executed on this cursor,
** then the field might be extracted from the key rather than the
** data.
**
** If P1 is negative, then the record is stored on the stack rather
** than in a table.  For P1==-1, the top of the stack is used.
** For P1==-2, the next on the stack is used.  And so forth.  The
** value pushed is always just a pointer into the record which is
** stored further down on the stack.  The column value is not copied.
*/
case OP_Column: {
  int amt, offset, end, payloadSize;
  int i = pOp->p1;
  int p2 = pOp->p2;
  Cursor *pC;
  char *zRec;
  BtCursor *pCrsr;
  int idxWidth;
  unsigned char aHdr[10];

  assert( i<p->nCursor );
  pTos++;
  if( i<0 ){
    assert( &pTos[i]>=p->aStack );
    assert( pTos[i].flags & MEM_Str );
    zRec = pTos[i].z;
    payloadSize = pTos[i].n;
  }else if( (pC = &p->aCsr[i])->pCursor!=0 ){
    sqlite3VdbeCursorMoveto(pC);
    zRec = 0;
    pCrsr = pC->pCursor;
    if( pC->nullRow ){
      payloadSize = 0;
    }else if( pC->keyAsData ){
      u64 pl64;
      assert( !pC->intKey );
      sqlite3BtreeKeySize(pCrsr, &pl64);
      payloadSize = pl64;
    }else{
      sqlite3BtreeDataSize(pCrsr, &payloadSize);
    }
  }else if( pC->pseudoTable ){
    payloadSize = pC->nData;
    zRec = pC->pData;
    assert( payloadSize==0 || zRec!=0 );
  }else{
    payloadSize = 0;
  }

  /* Figure out how many bytes in the column data and where the column
  ** data begins.
  */
  if( payloadSize==0 ){
    pTos->flags = MEM_Null;
    break;
  }else if( payloadSize<256 ){
    idxWidth = 1;
  }else if( payloadSize<65536 ){
    idxWidth = 2;
  }else{
    idxWidth = 3;
  }

  /* Figure out where the requested column is stored and how big it is.
  */
  if( payloadSize < idxWidth*(p2+1) ){
    rc = SQLITE_CORRUPT;
    goto abort_due_to_error;
  }
  if( zRec ){
    memcpy(aHdr, &zRec[idxWidth*p2], idxWidth*2);
  }else if( pC->keyAsData ){
    sqlite3BtreeKey(pCrsr, idxWidth*p2, idxWidth*2, (char*)aHdr);
  }else{
    sqlite3BtreeData(pCrsr, idxWidth*p2, idxWidth*2, (char*)aHdr);
  }
  offset = aHdr[0];
  end = aHdr[idxWidth];
  if( idxWidth>1 ){
    offset |= aHdr[1]<<8;
    end |= aHdr[idxWidth+1]<<8;
    if( idxWidth>2 ){
      offset |= aHdr[2]<<16;
      end |= aHdr[idxWidth+2]<<16;
    }
  }
  amt = end - offset;
  if( amt<0 || offset<0 || end>payloadSize ){
    rc = SQLITE_CORRUPT;
    goto abort_due_to_error;
  }

  /* amt and offset now hold the offset to the start of data and the
  ** amount of data.  Go get the data and put it on the stack.
  */
  pTos->n = amt;
  if( amt==0 ){
    pTos->flags = MEM_Null;
  }else if( zRec ){
    pTos->flags = MEM_Str | MEM_Ephem;
    pTos->z = &zRec[offset];
  }else{
    if( amt<=NBFS ){
      pTos->flags = MEM_Str | MEM_Short;
      pTos->z = pTos->zShort;
    }else{
      char *z = sqliteMallocRaw( amt );
      if( z==0 ) goto no_mem;
      pTos->flags = MEM_Str | MEM_Dyn;
      pTos->z = z;
    }
    if( pC->keyAsData ){
      sqlite3BtreeKey(pCrsr, offset, amt, pTos->z);
    }else{
      sqlite3BtreeData(pCrsr, offset, amt, pTos->z);
    }
  }
  break;
}

/* Opcode: Recno P1 * *
**
** Push onto the stack an integer which is the first 4 bytes of the
** the key to the current entry in a sequential scan of the database







|







 







|







 







|







 







|
|

|
<
|
|
|
<

|
|
<

|
|
|
|
|

|
|

|

<
>


|
>
>
>
|
<
>
>
|
<
|
<
<



>
>
>
>
>







 







|
>
>
>

<
>

<
>
>
>

<
>

<
>

<
>

>

<
<
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
|
<
<
>
>
>
>
>
>
>
>
|
<
>
>
|
>
>
>
>
>
|
|
|
<
|
|
|
|
|
>
>
>
|
>
|
<
<
<
>
>
>
>
>

<
<
<
<
<
<
>
>
>
>
>
|
>
>
>
>
|
<
|
<
>
|
>
|
<

>
>
>
>
>
>
|
<
>
>
>
>
>
>
>
|
<
<
>
>
>
|
|
>
|
|
|
<
|
|
|
|
|
>
>
>
>
|
>
>
|
<
<
<
<
<
<
<
|
<
<
|
>
>

>
|
|







 







|




|





|
|
|
<
<
<
<
<
<
<
<
<




<
<
<


|

>




|
|

>
|
>
|
|

|
<
<
<
<
<
<
<
<
<
<
<
|
|





|
|
|
|
|
|
|
|
|
|
|
>
>
>
>
>
>
>





<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
|
<
<
<
<
<
<
<
|
|
|







 







<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<







39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
...
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
....
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
....
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817

1818
1819
1820

1821
1822
1823

1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835

1836
1837
1838
1839
1840
1841
1842
1843

1844
1845
1846

1847


1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
....
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892

1893
1894

1895
1896
1897
1898

1899
1900

1901
1902

1903
1904
1905
1906


1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922


1923
1924
1925
1926
1927
1928
1929
1930
1931

1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942

1943
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953



1954
1955
1956
1957
1958
1959






1960
1961
1962
1963
1964
1965
1966
1967
1968
1969
1970

1971

1972
1973
1974
1975

1976
1977
1978
1979
1980
1981
1982
1983

1984
1985
1986
1987
1988
1989
1990
1991


1992
1993
1994
1995
1996
1997
1998
1999
2000

2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013







2014


2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
....
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051









2052
2053
2054
2055



2056
2057
2058
2059
2060
2061
2062
2063
2064
2065
2066
2067
2068
2069
2070
2071
2072
2073
2074











2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103
2104



























































































































2105







2106
2107
2108
2109
2110
2111
2112
2113
2114
2115
....
3306
3307
3308
3309
3310
3311
3312

































































































































3313
3314
3315
3316
3317
3318
3319
**
** Various scripts scan this source file in order to generate HTML
** documentation, headers files, or other derived files.  The formatting
** of the code in this file is, therefore, important.  See other comments
** in this file for details.  If in doubt, do not deviate from existing
** commenting and indentation practices when changing or adding code.
**
** $Id: vdbe.c,v 1.283 2004/05/12 07:33:33 danielk1977 Exp $
*/
#include "sqliteInt.h"
#include "os.h"
#include <ctype.h>
#include "vdbeInt.h"

/*
................................................................................
*/
#define Stringify(P) if(((P)->flags & MEM_Str)==0){hardStringify(P);}
static int hardStringify(Mem *pStack){
  int fg = pStack->flags;
  if( fg & MEM_Real ){
    sqlite3_snprintf(sizeof(pStack->zShort),pStack->zShort,"%.15g",pStack->r);
  }else if( fg & MEM_Int ){
    sqlite3_snprintf(sizeof(pStack->zShort),pStack->zShort,"%lld",pStack->i);
  }else{
    pStack->zShort[0] = 0;
  }
  pStack->z = pStack->zShort;
  pStack->n = strlen(pStack->zShort)+1;
  pStack->flags = MEM_Str | MEM_Short;
  return 0;
................................................................................
  assert( pNos>=p->aStack );
  if( ((pTos->flags | pNos->flags) & MEM_Null)!=0 ){
    Release(pTos);
    pTos--;
    Release(pTos);
    pTos->flags = MEM_Null;
  }else if( (pTos->flags & pNos->flags & MEM_Int)==MEM_Int ){
    i64 a, b;
    a = pTos->i;
    b = pNos->i;
    switch( pOp->opcode ){
      case OP_Add:         b += a;       break;
      case OP_Subtract:    b -= a;       break;
      case OP_Multiply:    b *= a;       break;
      case OP_Divide: {
................................................................................
  if( i>=cnt ) pc = pOp->p2-1;
  if( pOp->p1>0 ) popStack(&pTos, cnt);
  break;
}

/* Opcode: Column3 P1 P2 *
**
** This opcode (not yet in use) is a replacement for the current OP_Column3
** that supports the SQLite3 manifest typing feature.
**
** Interpret the data that cursor P1 points to as a structure built using

** the MakeRecord instruction.  (See the MakeRecord opcode for additional
** information about the format of the data.) Push onto the stack the value
** of the P2-th column contained in the data.

**
** If the KeyAsData opcode has previously executed on this cursor, then the
** field might be extracted from the key rather than the data.

**
** If P1 is negative, then the record is stored on the stack rather than in
** a table.  For P1==-1, the top of the stack is used.  For P1==-2, the
** next on the stack is used.  And so forth.  The value pushed is always
** just a pointer into the record which is stored further down on the
** stack.  The column value is not copied.
*/
case OP_Column: {
  int payloadSize;   /* Number of bytes in the record */
  int i = pOp->p1;
  int p2 = pOp->p2;  /* column number to retrieve */
  Cursor *pC;

  char *zRec;        /* Pointer to record-data from stack or pseudo-table. */
  BtCursor *pCrsr;

  char *zData;       
  int freeZdata = 0; /* zData requires sqliteFree() */

  u64 nFields;       /* number of fields in the record */
  u64 *aTypes;       /* An array of serial types (size nFields) */


  int len;           /* The length of the serialized data for the column */
  int offset;

  int nn;



  assert( i<p->nCursor );
  pTos++;

  /* This block sets the variable payloadSize, and if the data is coming
  ** from the stack or from a pseudo-table zRec. If the data is coming
  ** from a real cursor, then zRec is left as NULL.
  */
  if( i<0 ){
    assert( &pTos[i]>=p->aStack );
    assert( pTos[i].flags & MEM_Str );
    zRec = pTos[i].z;
    payloadSize = pTos[i].n;
  }else if( (pC = &p->aCsr[i])->pCursor!=0 ){
    sqlite3VdbeCursorMoveto(pC);
................................................................................

  /* If payloadSize is 0, then just push a NULL onto the stack. */
  if( payloadSize==0 ){
    pTos->flags = MEM_Null;
    break;
  }

  /* Read the number of fields for the record.
  ** FIX ME: The Cursor object should cache this data and the array of
  ** field types for subsequent OP_Column instructions.
  */
  if( zRec ){

    zData = zRec;
  }else{

    /* We can assume that 9 bytes (maximum length of a varint) fits
    ** on the main page in all cases.
    */
    if( pC->keyAsData ){

      zData = (char *)sqlite3BtreeKeyFetch(pCrsr, 9>payloadSize?payloadSize:9);
    }else{

      zData = (char *)sqlite3BtreeDataFetch(pCrsr, 9>payloadSize?payloadSize:9);
    }

    assert( zData );
  }
  offset = sqlite3GetVarint(zData, &nFields);



  if( !zRec ){
    /* If the record is stored in a table, see if enough of it is on
    ** the main page to use sqlite3BtreeDataFetch() to get the data
    ** containing the nFields serial types (varints). This will almost
    ** always work, but if it doesn't sqliteMalloc() space and use
    ** sqlite3BtreeData().
    **
    ** Estimate the maximum space required by the nFields varints by
    ** assuming the maximum space for each is the length required to store:
    **
    **     (<record length> * 2) + 13
    **
    ** This is the serial-type for a text object as long as the record
    ** itself. In all cases the length required to store this is three
    ** bytes or less. 
    */


    int max_space = sqlite3VarintLen((((u64)payloadSize)<<1)+13)*nFields;
    max_space += offset;
    if( max_space>payloadSize ){
      max_space = payloadSize;
    }

    if( pC->keyAsData ){
      zData = (char *)sqlite3BtreeKeyFetch(pCrsr, max_space);
    }else{

      zData = (char *)sqlite3BtreeDataFetch(pCrsr, max_space);
    }
    if( !zData ){
      /* This code will run very infrequently (e.g. tables with several
      ** hundred columns).
      */
      zData = (char *)sqliteMalloc(offset+max_space);
      if( !zData ){
        rc = SQLITE_NOMEM;
        goto abort_due_to_error;
      }

      if( pC->keyAsData ){
        rc = sqlite3BtreeKey(pCrsr, 0, max_space, zData);
      }else{
        rc = sqlite3BtreeData(pCrsr, 0, max_space, zData);
      }
      if( rc!=SQLITE_OK ){
        sqliteFree(zData);
        goto abort_due_to_error;
      }
      freeZdata = 1;
    }



  }

  /* Dynamically allocate space for the aTypes array. and read all
  ** the serial types for the record. At the end of this block variable
  ** offset is set to the offset to the start of Data0 in the record.
  */






  aTypes = (u64 *)sqliteMalloc(sizeof(u64)*nFields);
  if( !aTypes ){
    if( freeZdata ){
      sqliteFree(zData);
      freeZdata = 0;
    }
    rc = SQLITE_NOMEM;
    goto abort_due_to_error;
  }
  for(nn=0; nn<nFields; nn++){
    offset += sqlite3GetVarint(&zData[offset], &aTypes[nn]);

  }

 
  if( freeZdata ){
    freeZdata = 0;
    sqliteFree(zData);

  }

  for(nn=0; nn<p2; nn++){
    offset += sqlite3VdbeSerialTypeLen(aTypes[nn]);
  }
  len = sqlite3VdbeSerialTypeLen(aTypes[p2]);

  if( !zRec ){

    /* If the record is stored in a table, see if enough of it
    ** is on the main page to read our column using
    ** sqlite3BtreeDataFetch(). If not sqliteMalloc() space and read data
    ** with sqlite3BtreeData().
    */
    if( pC->keyAsData ){
      zData = (char *)sqlite3BtreeKeyFetch(pCrsr, offset+len);
    }else{


      zData = (char *)sqlite3BtreeDataFetch(pCrsr, offset+len);
    }
    if( !zData && len>0 ){
      zData = (char *)sqliteMalloc(len);
      if( !zData ){
        sqliteFree(aTypes);
        rc = SQLITE_NOMEM;
        goto abort_due_to_error;
      }

      if( pC->keyAsData ){
        rc = sqlite3BtreeKey(pCrsr, offset, len, zData);
      }else{
        rc = sqlite3BtreeData(pCrsr, offset, len, zData);
      }
      if( rc!=SQLITE_OK ){
        sqliteFree( aTypes );
        sqliteFree( zData );
        goto abort_due_to_error;
      }
      freeZdata = 1;
      offset = 0;
    }







  }



  /* Deserialize the value directly into the top of the stack */
  sqlite3VdbeSerialGet(&zData[offset], aTypes[p2], pTos);

  sqliteFree(aTypes);
  if( freeZdata ){
    sqliteFree(zData);
  }
  break;
}

/* Opcode MakeRecord3 P1 * *
**
** This opcode (not yet in use) is a replacement for the current
................................................................................
**
** Convert the top P1 entries of the stack into a single entry
** suitable for use as a data record in a database table.  The
** details of the format are irrelavant as long as the OP_Column
** opcode can decode the record later.  Refer to source code
** comments for the details of the record format.
*/
case OP_MakeRecord: {
  /* Assuming the record contains N fields, the record format looks
  ** like this:
  **
  ** --------------------------------------------------------------------------
  ** | num-fields | type 0 | type 1 | ... | type N-1 | data0 | ... | data N-1 | 
  ** --------------------------------------------------------------------------
  **
  ** Data(0) is taken from the lowest element of the stack and data(N-1) is
  ** the top of the stack.
  **
  ** Each type field is a varint representing the serial type of the 
  ** corresponding data element (see sqlite3VdbeSerialType()). The
  ** num-fields field is also a varint storing N.









  ** 
  ** TODO: Even when the record is short enough for Mem::zShort, this opcode
  **   allocates it dynamically.
  */



  int nField = pOp->p1;
  unsigned char *zNewRecord;
  unsigned char *zCsr;
  Mem *pRec;
  int nBytes;    /* Space required for this record */

  Mem *pData0 = &pTos[1-nField];
  assert( pData0>=p->aStack );

  /* Loop through the elements that will make up the record to figure
  ** out how much space is required for the new record.
  */
  nBytes = sqlite3VarintLen(nField);
  for(pRec=pData0; pRec<=pTos; pRec++){
    u64 serial_type = sqlite3VdbeSerialType(pRec);
    nBytes += sqlite3VdbeSerialTypeLen(serial_type);
    nBytes += sqlite3VarintLen(serial_type);
  }












  /* Allocate space for the new record. */
  zNewRecord = sqliteMalloc(nBytes);
  if( !zNewRecord ){
    rc = SQLITE_NOMEM;
    goto abort_due_to_error;
  }

  /* Write the record */
  zCsr = zNewRecord;
  zCsr += sqlite3PutVarint(zCsr, nField);             /* number of fields */
  for(pRec=pData0; pRec<=pTos; pRec++){
    u64 serial_type = sqlite3VdbeSerialType(pRec);
    zCsr += sqlite3PutVarint(zCsr, serial_type);      /* serial type */
  }
  for(pRec=pData0; pRec<=pTos; pRec++){
    zCsr += sqlite3VdbeSerialPut(zCsr, pRec);  /* serial data */
  }

  /* If zCsr has not been advanced exactly nBytes bytes, then one
  ** of the sqlite3PutVarint() or sqlite3VdbeSerialPut() calls above
  ** failed. This indicates a corrupted memory cell or code bug.
  */
  if( zCsr!=(zNewRecord+nBytes) ){
    rc = SQLITE_INTERNAL;
    goto abort_due_to_error;
  }

  /* Pop nField entries from the stack and push the new entry on */
  popStack(&pTos, nField);
  pTos++;



























































































































  pTos->n = nBytes;







  pTos->z = zNewRecord;
  pTos->flags = MEM_Str | MEM_Dyn;

  break;
}

/* Opcode: MakeKey P1 P2 P3
**
** Convert the top P1 entries of the stack into a single entry suitable
** for use as the key in an index.  The top P1 records are
................................................................................
  }else if( pC->pseudoTable ){
    pTos->n = pC->nData;
    pTos->z = pC->pData;
    pTos->flags = MEM_Str|MEM_Ephem;
  }else{
    pTos->flags = MEM_Null;
  }

































































































































  break;
}

/* Opcode: Recno P1 * *
**
** Push onto the stack an integer which is the first 4 bytes of the
** the key to the current entry in a sequential scan of the database

Changes to src/vdbeInt.h.

313
314
315
316
317
318
319
320
321

322
323
324
void sqlite3VdbeKeylistFree(Keylist*);
void sqliteVdbePopStack(Vdbe*,int);
int sqlite3VdbeCursorMoveto(Cursor*);
int sqlite3VdbeByteSwap(int);
#if !defined(NDEBUG) || defined(VDBE_PROFILE)
void sqlite3VdbePrintOp(FILE*, int, Op*);
#endif
int sqlite3VdbeSerialize(const Mem *, unsigned char *);
int sqlite3VdbeSerialLen(const Mem *);

int sqlite3VdbeDeserialize(Mem *, const unsigned char *);

int sqlite2BtreeKeyCompare(BtCursor *, const void *, int, int, int *);







|
|
>
|


313
314
315
316
317
318
319
320
321
322
323
324
325
void sqlite3VdbeKeylistFree(Keylist*);
void sqliteVdbePopStack(Vdbe*,int);
int sqlite3VdbeCursorMoveto(Cursor*);
int sqlite3VdbeByteSwap(int);
#if !defined(NDEBUG) || defined(VDBE_PROFILE)
void sqlite3VdbePrintOp(FILE*, int, Op*);
#endif
int sqlite3VdbeSerialTypeLen(u64);
u64 sqlite3VdbeSerialType(const Mem *);
int sqlite3VdbeSerialPut(unsigned char *, const Mem *);
int sqlite3VdbeSerialGet(const unsigned char *, u64, Mem *);

int sqlite2BtreeKeyCompare(BtCursor *, const void *, int, int, int *);

Changes to src/vdbeaux.c.

1103
1104
1105
1106
1107
1108
1109
1110
1111
1112


1113
1114
1115
1116
1117
1118


1119
1120









1121
1122
1123
1124
1125
1126
1127
....
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239


1240
1241

1242
1243
1244
1245
1246
1247



1248
1249

1250


1251
1252
1253
1254
1255
1256



1257
1258
1259
1260

1261
1262






1263
1264
1265
1266
1267
1268
1269
1270

1271
1272

1273


1274
1275
1276
1277


1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
  *pResult = memcmp(pMallocedKey, pKey, nKey>nCellKey?nCellKey:nKey);
  sqliteFree(pMallocedKey);

  return rc;
}

/*
** The following three functions:
**
** sqlite3VdbeSerialize()


** sqlite3VdbeSerialLen()
** sqlite3VdbeDeserialize()
**
** encapsulate the code that serializes values for storage in SQLite
** databases. Each serialized value consists of a variable length integer
** followed by type specific storage.


**
**   initial varint     bytes to follow    type









**   --------------     ---------------    ---------------
**      0                     0            NULL
**      1                     1            signed integer
**      2                     2            signed integer
**      3                     4            signed integer
**      4                     8            signed integer
**      5                     8            IEEE float
................................................................................
**     6..12                               reserved for expansion
**    N>=12 and even       (N-12)/2        BLOB
**    N>=13 and odd        (N-13)/2        text
**
*/

/*
** Write the serialized form of the value held by pMem into zBuf. Return
** the number of bytes written.
*/
int sqlite3VdbeSerialize(
  const Mem *pMem,      /* Pointer to vdbe value to serialize */
  unsigned char *zBuf   /* Buffer to write to */
){
  if( pMem->flags&MEM_Null ){
    return sqlite3PutVarint(zBuf, 0);
  }

  if( pMem->flags&MEM_Real ){
    assert(!"TODO: float");
  }

  if( pMem->flags&MEM_Str ){
    int data_type_len;
    u64 data_type = (pMem->n*2+31);

    data_type_len = sqlite3PutVarint(zBuf, data_type); 
    memcpy(&zBuf[data_type_len], pMem->z, pMem->n);
    return pMem->n + data_type_len;
  }

  if( pMem->flags& MEM_Int ){
    u64 absval;
    int size = 8;
    int ii;

    if( pMem->i<0 ){
      absval = pMem->i * -1;
    }else{
      absval = pMem->i;
    }
    if( absval<=127 ){
      size = 1;
      sqlite3PutVarint(zBuf, 1);
    }else if( absval<=32767 ){
      size = 2;
      sqlite3PutVarint(zBuf, 2);
    }else if( absval<=2147483647 ){
      size = 4;
      sqlite3PutVarint(zBuf, 3);
    }else{
      size = 8;
      sqlite3PutVarint(zBuf, 4);
    }

    for(ii=0; ii<size; ii++){
      zBuf[ii+1] = (pMem->i >> (8*ii)) & 0xFF;
    }
    if( pMem->i<0 ){
      zBuf[size] = zBuf[size] & 0x80;
    }

    return size+1;
  }

  return -1;
}

/*
** Return the number of bytes that would be consumed by the serialized
** form of the value held by pMem. Return negative if an error occurs.
*/
int sqlite3VdbeSerialLen(const Mem *pMem){
  if( pMem->flags&MEM_Null ){
    return 1; /* Varint 0 is 1 byte */
  }
  if( pMem->flags&MEM_Real ){
    return 9; /* Varing 5 (1 byte) + 8 bytes IEEE float */    
  }
  if( pMem->flags&MEM_Str ){
    return pMem->n + sqlite3VarintLen((pMem->n*2)+13);
  }
  if( pMem->flags& MEM_Int ){
    u64 absval;
    if( pMem->i<0 ){
      absval = pMem->i * -1;
    }else{
      absval = pMem->i;
    }
    if( absval<=127 ) return 2;        /* 1 byte integer */
    if( absval<=32767 ) return 3;      /* 2 byte integer */
    if( absval<=2147483647 ) return 5; /* 4 byte integer */
    return 9;                         /* 8 byte integer */
  }

  return -1;
}

/*
** Deserialize a value from zBuf and store it in *pMem. Return the number
** of bytes written, or negative if an error occurs.
*/
int sqlite3VdbeDeserialize(
  Mem *pMem,                   /* structure to write new value to */
  const unsigned char *zBuf    /* Buffer to read from */
){
  u64 data_type;
  int ret;
  int len;

  memset(pMem, 0, sizeof(Mem));
  ret = sqlite3GetVarint(zBuf, &data_type);



  if( data_type==0 ){  /* NULL */

    pMem->flags = MEM_Null;
    return ret;
  }

  /* FIX ME: update for 8-byte integers */
  if( data_type>0 && data_type<5 ){  /* 1, 2, 4 or 8 byte integer */



    int ii;
    int bytes = 1 << (data_type-1);




    pMem->flags = MEM_Int;
    pMem->i = 0;

    for(ii=0; ii<bytes; ii++){
      pMem->i = (pMem->i<<8) + zBuf[ii+ret];
    }




    /* If this is a 1, 2 or 4 byte integer, extend the sign-bit if need be. */
    if( bytes<8 && pMem->i & (1<<(bytes*8-1)) ){
      pMem->i = pMem->i - (1<<(bytes*8));

    }







    return ret+bytes;
  }

  if( data_type==5 ){ /* IEEE float */
    assert(!"TODO: float");
  }

  /* Must be text or a blob */

  assert( data_type>=12 );
  len = (data_type-12)/2;

  pMem->flags = MEM_Str;  /* FIX ME: there should be a MEM_Blob or similar */



  /* If the length of the text or blob is greater than NBFS, use space
  ** dynamically allocated. Otherwise, store the value in Mem::zShort.
  */


  if( len>NBFS ){
    pMem->z = sqliteMalloc( len );
    if( !pMem->z ){
      return -1;
    }
    pMem->flags |= MEM_Dyn;
  }else{
    pMem->z = pMem->zShort;
    pMem->flags |= MEM_Short;
  }
  memcpy(pMem->z, &zBuf[ret], len); 
  ret += len;

  return ret;
}

/*
** The following is the comparison function for (non-integer)
** keys in the btrees.  This function returns negative, zero, or
** positive if the first key is less than, equal to, or greater than
** the second.







|

|
>
>

|


|
<
>
>

<
>
>
>
>
>
>
>
>
>







 







|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
<
<
<
<
<
<
<



|
|
|
|
<
<
<
<
<


|
<
>
>

|
>

|

|
<
<
>
>
>
|
<
>

>
>
|
<
|
<
<

>
>
>
|
|
<
|
>
|

>
>
>
>
>
>
|

|
<
<
<
<
<
>
|
<
>
|
>
>
|
<
<
<
>
>










|
<

|







1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119

1120
1121
1122

1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
....
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227







1228
1229
1230
1231
1232
1233
1234





1235
1236
1237

1238
1239
1240
1241
1242
1243
1244
1245
1246


1247
1248
1249
1250

1251
1252
1253
1254
1255

1256


1257
1258
1259
1260
1261
1262

1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275





1276
1277

1278
1279
1280
1281
1282



1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295

1296
1297
1298
1299
1300
1301
1302
1303
1304
  *pResult = memcmp(pMallocedKey, pKey, nKey>nCellKey?nCellKey:nKey);
  sqliteFree(pMallocedKey);

  return rc;
}

/*
** The following functions:
**
** sqlite3VdbeSerialType()
** sqlite3VdbeSerialTypeLen()
** sqlite3VdbeSerialRead()
** sqlite3VdbeSerialLen()
** sqlite3VdbeSerialWrite()
**
** encapsulate the code that serializes values for storage in SQLite
** data and index records. Each serialized value consists of a

** 'serial-type' and a blob of data. The serial type is an 8-byte unsigned
** integer, stored as a varint.
**

** In an SQLite index record, the serial type is stored directly before
** the blob of data that it corresponds to. In a table record, all serial
** types are stored at the start of the record, and the blobs of data at
** the end. Hence these functions allow the caller to handle the
** serial-type and data blob seperately.
**
** The following table describes the various storage classes for data:
**
**   serial type        bytes of data      type
**   --------------     ---------------    ---------------
**      0                     0            NULL
**      1                     1            signed integer
**      2                     2            signed integer
**      3                     4            signed integer
**      4                     8            signed integer
**      5                     8            IEEE float
................................................................................
**     6..12                               reserved for expansion
**    N>=12 and even       (N-12)/2        BLOB
**    N>=13 and odd        (N-13)/2        text
**
*/

/*
** Return the serial-type for the value stored in pMem.
*/
u64 sqlite3VdbeSerialType(const Mem *pMem){
  int flags = pMem->flags;

  if( flags&MEM_Null ){
    return 0;
  }
  if( flags&MEM_Int ){
    /* Figure out whether to use 1, 2, 4 or 8 bytes. */
    i64 i = pMem->i;
    if( i>=-127 && i<=127 ) return 1;
    if( i>=-32767 && i<=32767 ) return 2;
    if( i>=-2147483647 && i<=2147483647 ) return 3;
    return 4;
  }
  if( flags&MEM_Real ){
    return 5;
  }
  if( flags&MEM_Str ){
    return (pMem->n*2 + 13);
  }
  if( flags&MEM_Blob ){
    return (pMem->n*2 + 12);
  }
  return 0;
}

/*
** Return the length of the data corresponding to the supplied serial-type.
*/
int sqlite3VdbeSerialTypeLen(u64 serial_type){
  switch(serial_type){
    case 0: return 0;                  /* NULL */
    case 1: return 1;                  /* 1 byte integer */
    case 2: return 2;                  /* 2 byte integer */
    case 3: return 4;                  /* 4 byte integer */
    case 4: return 8;                  /* 8 byte integer */
    case 5: return 8;                  /* 8 byte float */
  }
  assert( serial_type>=12 );
  return ((serial_type-12)>>1);        /* text or blob */
}

/*
** Write the serialized data blob for the value stored in pMem into 
** buf. It is assumed that the caller has allocated sufficient space.
** Return the number of bytes written.
*/ 
int sqlite3VdbeSerialPut(unsigned char *buf, const Mem *pMem){
  u64 serial_type = sqlite3VdbeSerialType(pMem);
  int len;
 
  /* NULL */
  if( serial_type==0 ){
    return 0;
  }
 
  /* Integer */
  if( serial_type<5 ){
    i64 i = pMem->i;
    len = sqlite3VdbeSerialTypeLen(serial_type);
    while( len-- ){
      buf[len] = (i&0xFF);
      i = i >> 8;
    }
    return sqlite3VdbeSerialTypeLen(serial_type);
  }

  /* Float */
  if( serial_type==5 ){
    /* TODO: byte ordering? */
    assert( sizeof(double)==8 );
    memcpy(buf, &pMem->r, 8);
    return 8;
  }
  
  /* String or blob */
  assert( serial_type>=12 );
  len = sqlite3VdbeSerialTypeLen(serial_type);
  memcpy(buf, pMem->z, len);
  return len;







}

/*
** Deserialize the data blob pointed to by buf as serial type serial_type
** and store the result in pMem.  Return the number of bytes read.
*/ 
int sqlite3VdbeSerialGet(const unsigned char *buf, u64 serial_type, Mem *pMem){





  int len;

  /* memset(pMem, 0, sizeof(pMem)); */

  pMem->flags = 0;
  pMem->z = 0;

  /* NULL */
  if( serial_type==0 ){
    pMem->flags = MEM_Null;
    return 0;
  }
 


  /* Integer */
  if( serial_type<5 ){
    i64 i = 0;
    int n;

    len = sqlite3VdbeSerialTypeLen(serial_type);

    if( buf[0]&0x80 ){
      for(n=0; n<(8-len); n++){
        i = (i<<8)+0xFF;

      }


    }
    for(n=0; n<len; n++){
      i = i << 8;
      i = i + buf[n];
    }
    pMem->flags = MEM_Int;

    pMem->i = i;
    return sqlite3VdbeSerialTypeLen(serial_type);
  }

  /* Float */
  if( serial_type==5 ){
    /* TODO: byte ordering? */
    assert( sizeof(double)==8 );
    memcpy(&pMem->r, buf, 8);
    pMem->flags = MEM_Real;
    return 8;
  }
  





  /* String or blob */
  assert( serial_type>=12 );

  if( serial_type&0x01 ){
    pMem->flags = MEM_Str;
  }else{
    pMem->flags = MEM_Blob;
  }



  len = sqlite3VdbeSerialTypeLen(serial_type);
  pMem->n = len;
  if( len>NBFS ){
    pMem->z = sqliteMalloc( len );
    if( !pMem->z ){
      return -1;
    }
    pMem->flags |= MEM_Dyn;
  }else{
    pMem->z = pMem->zShort;
    pMem->flags |= MEM_Short;
  }
  memcpy(pMem->z, buf, len); 


  return len;
}

/*
** The following is the comparison function for (non-integer)
** keys in the btrees.  This function returns negative, zero, or
** positive if the first key is less than, equal to, or greater than
** the second.

Changes to test/quick.test.

6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
..
22
23
24
25
26
27
28

































29
30
31
32
33
34
35
..
43
44
45
46
47
48
49
50
51
52
53
#    May you do good and not evil.
#    May you find forgiveness for yourself and forgive others.
#    May you share freely, never taking more than you give.
#
#***********************************************************************
# This file runs all tests.
#
# $Id: quick.test,v 1.6 2004/02/11 02:18:07 drh Exp $

set testdir [file dirname $argv0]
source $testdir/tester.tcl
rename finish_test really_finish_test
proc finish_test {} {}
set ISQUICK 1

................................................................................
  all.test
  quick.test
  btree2.test
  malloc.test
  memleak.test
  misuse.test
}


































if {[sqlite -has-codec]} {
  lappend EXCLUDE \
    attach.test \
    attach2.test \
    auth.test \
    format3.test \
................................................................................
  catch {db close}
  if {$sqlite_open_file_count>0} {
    puts "$tail did not close all files: $sqlite_open_file_count"
    incr nErr
    lappend ::failList $tail
  }
}
source $testdir/misuse.test

set sqlite_open_file_count 0
really_finish_test







|







 







>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>







 







|



6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
..
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
..
76
77
78
79
80
81
82
83
84
85
86
#    May you do good and not evil.
#    May you find forgiveness for yourself and forgive others.
#    May you share freely, never taking more than you give.
#
#***********************************************************************
# This file runs all tests.
#
# $Id: quick.test,v 1.7 2004/05/12 07:33:34 danielk1977 Exp $

set testdir [file dirname $argv0]
source $testdir/tester.tcl
rename finish_test really_finish_test
proc finish_test {} {}
set ISQUICK 1

................................................................................
  all.test
  quick.test
  btree2.test
  malloc.test
  memleak.test
  misuse.test
}

lappend EXCLUDE \
  auth.test \
  bind.test \
  capi2.test \
  conflict.test \
  copy.test \
  format3.test \
  func.test \
  index.test \
  interrupt.test \
  intpkey.test \
  ioerr.test \
  memdb.test \
  minmax.test \
  misc1.test \
  misc2.test \
  misc3.test \
  null.test \
  pragma.test \
  printf.test \
  rowid.test \
  table.test \
  tableapi.test \
  trans.test \
  trigger1.test \
  trigger2.test \
  unique.test \
  update.test \
  utf.test \
  vacuum.test \
  version.test \


if {[sqlite -has-codec]} {
  lappend EXCLUDE \
    attach.test \
    attach2.test \
    auth.test \
    format3.test \
................................................................................
  catch {db close}
  if {$sqlite_open_file_count>0} {
    puts "$tail did not close all files: $sqlite_open_file_count"
    incr nErr
    lappend ::failList $tail
  }
}
# source $testdir/misuse.test

set sqlite_open_file_count 0
really_finish_test