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

Changes to Makefile.in.

   412    412     $(TOP)/ext/session/test_session.c \
   413    413     $(TOP)/ext/rbu/test_rbu.c 
   414    414   
   415    415   # Statically linked extensions
   416    416   #
   417    417   TESTSRC += \
   418    418     $(TOP)/ext/misc/amatch.c \
          419  +  $(TOP)/ext/misc/carray.c \
   419    420     $(TOP)/ext/misc/closure.c \
   420    421     $(TOP)/ext/misc/csv.c \
   421    422     $(TOP)/ext/misc/eval.c \
   422    423     $(TOP)/ext/misc/fileio.c \
   423    424     $(TOP)/ext/misc/fuzzer.c \
   424    425     $(TOP)/ext/fts5/fts5_tcl.c \
   425    426     $(TOP)/ext/fts5/fts5_test_mi.c \

Changes to Makefile.msc.

  1288   1288     $(TOP)\ext\rbu\test_rbu.c \
  1289   1289     $(TOP)\ext\session\test_session.c
  1290   1290   
  1291   1291   # Statically linked extensions.
  1292   1292   #
  1293   1293   TESTEXT = \
  1294   1294     $(TOP)\ext\misc\amatch.c \
         1295  +  $(TOP)\ext\misc\carray.c \
  1295   1296     $(TOP)\ext\misc\closure.c \
  1296   1297     $(TOP)\ext\misc\csv.c \
  1297   1298     $(TOP)\ext\misc\eval.c \
  1298   1299     $(TOP)\ext\misc\fileio.c \
  1299   1300     $(TOP)\ext\misc\fuzzer.c \
  1300   1301     $(TOP)\ext\fts5\fts5_tcl.c \
  1301   1302     $(TOP)\ext\fts5\fts5_test_mi.c \

Added ext/misc/carray.c.

            1  +/*
            2  +** 2016-06-29
            3  +**
            4  +** The author disclaims copyright to this source code.  In place of
            5  +** a legal notice, here is a blessing:
            6  +**
            7  +**    May you do good and not evil.
            8  +**    May you find forgiveness for yourself and forgive others.
            9  +**    May you share freely, never taking more than you give.
           10  +**
           11  +*************************************************************************
           12  +**
           13  +** This file demonstrates how to create a table-valued-function that
           14  +** returns the values in a C-language array.
           15  +** Examples:
           16  +**
           17  +**      SELECT * FROM array($ptr,5)
           18  +**
           19  +** The query above returns 5 integers contained in a C-language array
           20  +** at the address $ptr.  $ptr is a pointer to the array of integers that
           21  +** has been cast to an integer.
           22  +**
           23  +** There is an optional third parameter to determine the datatype of
           24  +** the C-language array.  Allowed values of the third parameter are
           25  +** 'int32', 'int64', 'double', 'char*'.  Example:
           26  +**
           27  +**      SELECT * FROM array($ptr,10,'char*');
           28  +**
           29  +** HOW IT WORKS
           30  +**
           31  +** The carray "function" is really a virtual table with the
           32  +** following schema:
           33  +**
           34  +**     CREATE TABLE carray(
           35  +**       value,
           36  +**       pointer HIDDEN,
           37  +**       count HIDDEN,
           38  +**       ctype TEXT HIDDEN
           39  +**     );
           40  +**
           41  +** If the hidden columns "pointer" and "count" are unconstrained, then 
           42  +** the virtual table has no rows.  Otherwise, the virtual table interprets
           43  +** the integer value of "pointer" as a pointer to the array and "count"
           44  +** as the number of elements in the array.  The virtual table steps through
           45  +** the array, element by element.
           46  +*/
           47  +#include "sqlite3ext.h"
           48  +SQLITE_EXTENSION_INIT1
           49  +#include <assert.h>
           50  +#include <string.h>
           51  +
           52  +#ifndef SQLITE_OMIT_VIRTUALTABLE
           53  +
           54  +/*
           55  +** Allowed datatypes
           56  +*/
           57  +#define CARRAY_INT32    0
           58  +#define CARRAY_INT64    1
           59  +#define CARRAY_DOUBLE   2
           60  +#define CARRAY_TEXT     3
           61  +
           62  +/*
           63  +** Names of types
           64  +*/
           65  +static const char *azType[] = { "int32", "int64", "double", "char*" };
           66  +
           67  +
           68  +/* carray_cursor is a subclass of sqlite3_vtab_cursor which will
           69  +** serve as the underlying representation of a cursor that scans
           70  +** over rows of the result
           71  +*/
           72  +typedef struct carray_cursor carray_cursor;
           73  +struct carray_cursor {
           74  +  sqlite3_vtab_cursor base;  /* Base class - must be first */
           75  +  sqlite3_int64 iRowid;      /* The rowid */
           76  +  sqlite3_int64 iPtr;        /* Pointer to array of values */
           77  +  sqlite3_int64 iCnt;        /* Number of integers in the array */
           78  +  unsigned char eType;       /* One of the CARRAY_type values */
           79  +};
           80  +
           81  +/*
           82  +** The carrayConnect() method is invoked to create a new
           83  +** carray_vtab that describes the carray virtual table.
           84  +**
           85  +** Think of this routine as the constructor for carray_vtab objects.
           86  +**
           87  +** All this routine needs to do is:
           88  +**
           89  +**    (1) Allocate the carray_vtab object and initialize all fields.
           90  +**
           91  +**    (2) Tell SQLite (via the sqlite3_declare_vtab() interface) what the
           92  +**        result set of queries against carray will look like.
           93  +*/
           94  +static int carrayConnect(
           95  +  sqlite3 *db,
           96  +  void *pAux,
           97  +  int argc, const char *const*argv,
           98  +  sqlite3_vtab **ppVtab,
           99  +  char **pzErr
          100  +){
          101  +  sqlite3_vtab *pNew;
          102  +  int rc;
          103  +
          104  +/* Column numbers */
          105  +#define CARRAY_COLUMN_VALUE   0
          106  +#define CARRAY_COLUMN_POINTER 1
          107  +#define CARRAY_COLUMN_COUNT   2
          108  +#define CARRAY_COLUMN_CTYPE   3
          109  +
          110  +  rc = sqlite3_declare_vtab(db,
          111  +     "CREATE TABLE x(value,pointer hidden,count hidden,ctype hidden)");
          112  +  if( rc==SQLITE_OK ){
          113  +    pNew = *ppVtab = sqlite3_malloc( sizeof(*pNew) );
          114  +    if( pNew==0 ) return SQLITE_NOMEM;
          115  +    memset(pNew, 0, sizeof(*pNew));
          116  +  }
          117  +  return rc;
          118  +}
          119  +
          120  +/*
          121  +** This method is the destructor for carray_cursor objects.
          122  +*/
          123  +static int carrayDisconnect(sqlite3_vtab *pVtab){
          124  +  sqlite3_free(pVtab);
          125  +  return SQLITE_OK;
          126  +}
          127  +
          128  +/*
          129  +** Constructor for a new carray_cursor object.
          130  +*/
          131  +static int carrayOpen(sqlite3_vtab *p, sqlite3_vtab_cursor **ppCursor){
          132  +  carray_cursor *pCur;
          133  +  pCur = sqlite3_malloc( sizeof(*pCur) );
          134  +  if( pCur==0 ) return SQLITE_NOMEM;
          135  +  memset(pCur, 0, sizeof(*pCur));
          136  +  *ppCursor = &pCur->base;
          137  +  return SQLITE_OK;
          138  +}
          139  +
          140  +/*
          141  +** Destructor for a carray_cursor.
          142  +*/
          143  +static int carrayClose(sqlite3_vtab_cursor *cur){
          144  +  sqlite3_free(cur);
          145  +  return SQLITE_OK;
          146  +}
          147  +
          148  +
          149  +/*
          150  +** Advance a carray_cursor to its next row of output.
          151  +*/
          152  +static int carrayNext(sqlite3_vtab_cursor *cur){
          153  +  carray_cursor *pCur = (carray_cursor*)cur;
          154  +  pCur->iRowid++;
          155  +  return SQLITE_OK;
          156  +}
          157  +
          158  +/*
          159  +** Return values of columns for the row at which the carray_cursor
          160  +** is currently pointing.
          161  +*/
          162  +static int carrayColumn(
          163  +  sqlite3_vtab_cursor *cur,   /* The cursor */
          164  +  sqlite3_context *ctx,       /* First argument to sqlite3_result_...() */
          165  +  int i                       /* Which column to return */
          166  +){
          167  +  carray_cursor *pCur = (carray_cursor*)cur;
          168  +  sqlite3_int64 x = 0;
          169  +  switch( i ){
          170  +    case CARRAY_COLUMN_POINTER:   x = pCur->iPtr;   break;
          171  +    case CARRAY_COLUMN_COUNT:     x = pCur->iCnt;   break;
          172  +    case CARRAY_COLUMN_CTYPE: {
          173  +      sqlite3_result_text(ctx, azType[pCur->eType], -1, SQLITE_STATIC);
          174  +      return SQLITE_OK;
          175  +    }
          176  +    default: {
          177  +      switch( pCur->eType ){
          178  +        case CARRAY_INT32: {
          179  +          int *p = (int*)pCur->iPtr;
          180  +          sqlite3_result_int(ctx, p[pCur->iRowid-1]);
          181  +          return SQLITE_OK;
          182  +        }
          183  +        case CARRAY_INT64: {
          184  +          sqlite3_int64 *p = (sqlite3_int64*)pCur->iPtr;
          185  +          sqlite3_result_int64(ctx, p[pCur->iRowid-1]);
          186  +          return SQLITE_OK;
          187  +        }
          188  +        case CARRAY_DOUBLE: {
          189  +          double *p = (double*)pCur->iPtr;
          190  +          sqlite3_result_double(ctx, p[pCur->iRowid-1]);
          191  +          return SQLITE_OK;
          192  +        }
          193  +        case CARRAY_TEXT: {
          194  +          const char **p = (const char**)pCur->iPtr;
          195  +          sqlite3_result_text(ctx, p[pCur->iRowid-1], -1, SQLITE_TRANSIENT);
          196  +          return SQLITE_OK;
          197  +        }
          198  +      }
          199  +    }
          200  +  }
          201  +  sqlite3_result_int64(ctx, x);
          202  +  return SQLITE_OK;
          203  +}
          204  +
          205  +/*
          206  +** Return the rowid for the current row.  In this implementation, the
          207  +** rowid is the same as the output value.
          208  +*/
          209  +static int carrayRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){
          210  +  carray_cursor *pCur = (carray_cursor*)cur;
          211  +  *pRowid = pCur->iRowid;
          212  +  return SQLITE_OK;
          213  +}
          214  +
          215  +/*
          216  +** Return TRUE if the cursor has been moved off of the last
          217  +** row of output.
          218  +*/
          219  +static int carrayEof(sqlite3_vtab_cursor *cur){
          220  +  carray_cursor *pCur = (carray_cursor*)cur;
          221  +  return pCur->iRowid>pCur->iCnt;
          222  +}
          223  +
          224  +/*
          225  +** This method is called to "rewind" the carray_cursor object back
          226  +** to the first row of output.
          227  +*/
          228  +static int carrayFilter(
          229  +  sqlite3_vtab_cursor *pVtabCursor, 
          230  +  int idxNum, const char *idxStr,
          231  +  int argc, sqlite3_value **argv
          232  +){
          233  +  carray_cursor *pCur = (carray_cursor *)pVtabCursor;
          234  +  if( idxNum ){
          235  +    pCur->iPtr = sqlite3_value_int64(argv[0]);
          236  +    pCur->iCnt = sqlite3_value_int64(argv[1]);
          237  +    if( idxNum<3 ){
          238  +      pCur->eType = CARRAY_INT32;
          239  +    }else{
          240  +      int i;
          241  +      const char *zType = (const char*)sqlite3_value_text(argv[2]);
          242  +      for(i=0; i<sizeof(azType)/sizeof(azType[0]); i++){
          243  +        if( sqlite3_stricmp(zType, azType[i])==0 ) break;
          244  +      }
          245  +      if( i>=sizeof(azType)/sizeof(azType[0]) ){
          246  +        pVtabCursor->pVtab->zErrMsg = sqlite3_mprintf(
          247  +          "unknown datatype: %Q", zType);
          248  +        return SQLITE_ERROR;
          249  +      }else{
          250  +        pCur->eType = i;
          251  +      }
          252  +    }
          253  +  }else{
          254  +    pCur->iPtr = 0;
          255  +    pCur->iCnt = 0;
          256  +  }
          257  +  pCur->iRowid = 1;
          258  +  return SQLITE_OK;
          259  +}
          260  +
          261  +/*
          262  +** SQLite will invoke this method one or more times while planning a query
          263  +** that uses the carray virtual table.  This routine needs to create
          264  +** a query plan for each invocation and compute an estimated cost for that
          265  +** plan.
          266  +**
          267  +** In this implementation idxNum is used to represent the
          268  +** query plan.  idxStr is unused.
          269  +**
          270  +** idxNum is 2 if the pointer= and count= constraints exist,
          271  +** 3 if the ctype= constraint also exists, and is 0 otherwise.
          272  +** If idxNum is 0, then carray becomes an empty table.
          273  +*/
          274  +static int carrayBestIndex(
          275  +  sqlite3_vtab *tab,
          276  +  sqlite3_index_info *pIdxInfo
          277  +){
          278  +  int i;                 /* Loop over constraints */
          279  +  int ptrIdx = -1;       /* Index of the pointer= constraint, or -1 if none */
          280  +  int cntIdx = -1;       /* Index of the count= constraint, or -1 if none */
          281  +  int ctypeIdx = -1;     /* Index of the ctype= constraint, or -1 if none */
          282  +
          283  +  const struct sqlite3_index_constraint *pConstraint;
          284  +  pConstraint = pIdxInfo->aConstraint;
          285  +  for(i=0; i<pIdxInfo->nConstraint; i++, pConstraint++){
          286  +    if( pConstraint->usable==0 ) continue;
          287  +    if( pConstraint->op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue;
          288  +    switch( pConstraint->iColumn ){
          289  +      case CARRAY_COLUMN_POINTER:
          290  +        ptrIdx = i;
          291  +        break;
          292  +      case CARRAY_COLUMN_COUNT:
          293  +        cntIdx = i;
          294  +        break;
          295  +      case CARRAY_COLUMN_CTYPE:
          296  +        ctypeIdx = i;
          297  +        break;
          298  +    }
          299  +  }
          300  +  if( ptrIdx>=0 && cntIdx>=0 ){
          301  +    pIdxInfo->aConstraintUsage[ptrIdx].argvIndex = 1;
          302  +    pIdxInfo->aConstraintUsage[ptrIdx].omit = 1;
          303  +    pIdxInfo->aConstraintUsage[cntIdx].argvIndex = 2;
          304  +    pIdxInfo->aConstraintUsage[cntIdx].omit = 1;
          305  +    pIdxInfo->estimatedCost = (double)1;
          306  +    pIdxInfo->estimatedRows = (double)100;
          307  +    pIdxInfo->idxNum = 2;
          308  +    if( ctypeIdx>=0 ){
          309  +      pIdxInfo->aConstraintUsage[ctypeIdx].argvIndex = 3;
          310  +      pIdxInfo->aConstraintUsage[ctypeIdx].omit = 1;
          311  +      pIdxInfo->idxNum = 3;
          312  +    }
          313  +  }else{
          314  +    pIdxInfo->estimatedCost = (double)2147483647;
          315  +    pIdxInfo->estimatedRows = (double)2147483647;
          316  +    pIdxInfo->idxNum = 0;
          317  +  }
          318  +  return SQLITE_OK;
          319  +}
          320  +
          321  +/*
          322  +** This following structure defines all the methods for the 
          323  +** carray virtual table.
          324  +*/
          325  +static sqlite3_module carrayModule = {
          326  +  0,                         /* iVersion */
          327  +  0,                         /* xCreate */
          328  +  carrayConnect,             /* xConnect */
          329  +  carrayBestIndex,           /* xBestIndex */
          330  +  carrayDisconnect,          /* xDisconnect */
          331  +  0,                         /* xDestroy */
          332  +  carrayOpen,                /* xOpen - open a cursor */
          333  +  carrayClose,               /* xClose - close a cursor */
          334  +  carrayFilter,              /* xFilter - configure scan constraints */
          335  +  carrayNext,                /* xNext - advance a cursor */
          336  +  carrayEof,                 /* xEof - check for end of scan */
          337  +  carrayColumn,              /* xColumn - read data */
          338  +  carrayRowid,               /* xRowid - read data */
          339  +  0,                         /* xUpdate */
          340  +  0,                         /* xBegin */
          341  +  0,                         /* xSync */
          342  +  0,                         /* xCommit */
          343  +  0,                         /* xRollback */
          344  +  0,                         /* xFindMethod */
          345  +  0,                         /* xRename */
          346  +};
          347  +
          348  +#endif /* SQLITE_OMIT_VIRTUALTABLE */
          349  +
          350  +#ifdef _WIN32
          351  +__declspec(dllexport)
          352  +#endif
          353  +int sqlite3_carray_init(
          354  +  sqlite3 *db, 
          355  +  char **pzErrMsg, 
          356  +  const sqlite3_api_routines *pApi
          357  +){
          358  +  int rc = SQLITE_OK;
          359  +  SQLITE_EXTENSION_INIT2(pApi);
          360  +#ifndef SQLITE_OMIT_VIRTUALTABLE
          361  +  if( sqlite3_libversion_number()<3008012 ){
          362  +    *pzErrMsg = sqlite3_mprintf(
          363  +        "carray() requires SQLite 3.8.12 or later");
          364  +    return SQLITE_ERROR;
          365  +  }
          366  +  rc = sqlite3_create_module(db, "carray", &carrayModule, 0);
          367  +#endif
          368  +  return rc;
          369  +}

Changes to main.mk.

   320    320     $(TOP)/src/test_windirent.c \
   321    321     $(TOP)/src/test_wsd.c
   322    322   
   323    323   # Extensions to be statically loaded.
   324    324   #
   325    325   TESTSRC += \
   326    326     $(TOP)/ext/misc/amatch.c \
          327  +  $(TOP)/ext/misc/carray.c \
   327    328     $(TOP)/ext/misc/closure.c \
   328    329     $(TOP)/ext/misc/csv.c \
   329    330     $(TOP)/ext/misc/eval.c \
   330    331     $(TOP)/ext/misc/fileio.c \
   331    332     $(TOP)/ext/misc/fuzzer.c \
   332    333     $(TOP)/ext/misc/ieee754.c \
   333    334     $(TOP)/ext/misc/nextchar.c \

Changes to src/test1.c.

  3236   3236     if( rc!=SQLITE_OK ){
  3237   3237       return TCL_ERROR;
  3238   3238     }
  3239   3239   
  3240   3240     return TCL_OK;
  3241   3241   }
  3242   3242   
         3243  +
         3244  +/*
         3245  +** Usage:   intarray_addr  INT  ...
         3246  +**
         3247  +** Return the address of a C-language array of 32-bit integers.
         3248  +**
         3249  +** Space to hold the array is obtained from malloc().  Call this procedure once
         3250  +** with no arguments in order to release memory.  Each call to this procedure
         3251  +** overwrites the previous array.
         3252  +*/
         3253  +static int test_intarray_addr(
         3254  +  void * clientData,
         3255  +  Tcl_Interp *interp,
         3256  +  int objc,
         3257  +  Tcl_Obj *CONST objv[]
         3258  +){
         3259  +  int i;
         3260  +  static int *p = 0;
         3261  +
         3262  +  sqlite3_free(p);
         3263  +  p = 0;
         3264  +  if( objc>1 ){
         3265  +    p = sqlite3_malloc( sizeof(p[0])*(objc-1) );
         3266  +    if( p==0 ) return TCL_ERROR;
         3267  +    for(i=0; i<objc-1; i++){
         3268  +      if( Tcl_GetIntFromObj(interp, objv[1+i], &p[i]) ){
         3269  +        sqlite3_free(p);
         3270  +        p = 0;
         3271  +        return TCL_ERROR;
         3272  +      }
         3273  +    }
         3274  +  }  
         3275  +  Tcl_SetObjResult(interp, Tcl_NewWideIntObj((sqlite3_int64)p));
         3276  +  return TCL_OK;
         3277  +}
         3278  +/*
         3279  +** Usage:   intarray_addr  INT  ...
         3280  +**
         3281  +** Return the address of a C-language array of 32-bit integers.
         3282  +**
         3283  +** Space to hold the array is obtained from malloc().  Call this procedure once
         3284  +** with no arguments in order to release memory.  Each call to this procedure
         3285  +** overwrites the previous array.
         3286  +*/
         3287  +static int test_int64array_addr(
         3288  +  void * clientData,
         3289  +  Tcl_Interp *interp,
         3290  +  int objc,
         3291  +  Tcl_Obj *CONST objv[]
         3292  +){
         3293  +  int i;
         3294  +  static sqlite3_int64 *p = 0;
         3295  +
         3296  +  sqlite3_free(p);
         3297  +  p = 0;
         3298  +  if( objc>1 ){
         3299  +    p = sqlite3_malloc( sizeof(p[0])*(objc-1) );
         3300  +    if( p==0 ) return TCL_ERROR;
         3301  +    for(i=0; i<objc-1; i++){
         3302  +      if( Tcl_GetWideIntFromObj(interp, objv[1+i], &p[i]) ){
         3303  +        sqlite3_free(p);
         3304  +        p = 0;
         3305  +        return TCL_ERROR;
         3306  +      }
         3307  +    }
         3308  +  }  
         3309  +  Tcl_SetObjResult(interp, Tcl_NewWideIntObj((sqlite3_int64)p));
         3310  +  return TCL_OK;
         3311  +}
         3312  +/*
         3313  +** Usage:   doublearray_addr  INT  ...
         3314  +**
         3315  +** Return the address of a C-language array of doubles.
         3316  +**
         3317  +** Space to hold the array is obtained from malloc().  Call this procedure once
         3318  +** with no arguments in order to release memory.  Each call to this procedure
         3319  +** overwrites the previous array.
         3320  +*/
         3321  +static int test_doublearray_addr(
         3322  +  void * clientData,
         3323  +  Tcl_Interp *interp,
         3324  +  int objc,
         3325  +  Tcl_Obj *CONST objv[]
         3326  +){
         3327  +  int i;
         3328  +  static double *p = 0;
         3329  +
         3330  +  sqlite3_free(p);
         3331  +  p = 0;
         3332  +  if( objc>1 ){
         3333  +    p = sqlite3_malloc( sizeof(p[0])*(objc-1) );
         3334  +    if( p==0 ) return TCL_ERROR;
         3335  +    for(i=0; i<objc-1; i++){
         3336  +      if( Tcl_GetDoubleFromObj(interp, objv[1+i], &p[i]) ){
         3337  +        sqlite3_free(p);
         3338  +        p = 0;
         3339  +        return TCL_ERROR;
         3340  +      }
         3341  +    }
         3342  +  }  
         3343  +  Tcl_SetObjResult(interp, Tcl_NewWideIntObj((sqlite3_int64)p));
         3344  +  return TCL_OK;
         3345  +}
         3346  +/*
         3347  +** Usage:   textarray_addr  TEXT ...
         3348  +**
         3349  +** Return the address of a C-language array of strings.
         3350  +**
         3351  +** Space to hold the array is obtained from malloc().  Call this procedure once
         3352  +** with no arguments in order to release memory.  Each call to this procedure
         3353  +** overwrites the previous array.
         3354  +*/
         3355  +static int test_textarray_addr(
         3356  +  void * clientData,
         3357  +  Tcl_Interp *interp,
         3358  +  int objc,
         3359  +  Tcl_Obj *CONST objv[]
         3360  +){
         3361  +  int i;
         3362  +  static int n = 0;
         3363  +  static char **p = 0;
         3364  +
         3365  +  for(i=0; i<n; i++) sqlite3_free(p[i]);
         3366  +  sqlite3_free(p);
         3367  +  p = 0;
         3368  +  if( objc>1 ){
         3369  +    p = sqlite3_malloc( sizeof(p[0])*(objc-1) );
         3370  +    if( p==0 ) return TCL_ERROR;
         3371  +    for(i=0; i<objc-1; i++){
         3372  +      p[i] = sqlite3_mprintf("%s", Tcl_GetString(objv[1+i]));
         3373  +    }
         3374  +  }  
         3375  +  Tcl_SetObjResult(interp, Tcl_NewWideIntObj((sqlite3_int64)p));
         3376  +  return TCL_OK;
         3377  +}
         3378  +
  3243   3379   
  3244   3380   /*
  3245   3381   ** Usage:   sqlite3_bind_int64  STMT N VALUE
  3246   3382   **
  3247   3383   ** Test the sqlite3_bind_int64 interface.  STMT is a prepared statement.
  3248   3384   ** N is the index of a wildcard in the prepared statement.  This command
  3249   3385   ** binds a 64-bit integer VALUE to that wildcard.
................................................................................
  6579   6715   static int tclLoadStaticExtensionCmd(
  6580   6716     void * clientData,
  6581   6717     Tcl_Interp *interp,
  6582   6718     int objc,
  6583   6719     Tcl_Obj *CONST objv[]
  6584   6720   ){
  6585   6721     extern int sqlite3_amatch_init(sqlite3*,char**,const sqlite3_api_routines*);
         6722  +  extern int sqlite3_carray_init(sqlite3*,char**,const sqlite3_api_routines*);
  6586   6723     extern int sqlite3_closure_init(sqlite3*,char**,const sqlite3_api_routines*);
  6587   6724     extern int sqlite3_csv_init(sqlite3*,char**,const sqlite3_api_routines*);
  6588   6725     extern int sqlite3_eval_init(sqlite3*,char**,const sqlite3_api_routines*);
  6589   6726     extern int sqlite3_fileio_init(sqlite3*,char**,const sqlite3_api_routines*);
  6590   6727     extern int sqlite3_fuzzer_init(sqlite3*,char**,const sqlite3_api_routines*);
  6591   6728     extern int sqlite3_ieee_init(sqlite3*,char**,const sqlite3_api_routines*);
  6592   6729     extern int sqlite3_nextchar_init(sqlite3*,char**,const sqlite3_api_routines*);
................................................................................
  6597   6734     extern int sqlite3_totype_init(sqlite3*,char**,const sqlite3_api_routines*);
  6598   6735     extern int sqlite3_wholenumber_init(sqlite3*,char**,const sqlite3_api_routines*);
  6599   6736     static const struct {
  6600   6737       const char *zExtName;
  6601   6738       int (*pInit)(sqlite3*,char**,const sqlite3_api_routines*);
  6602   6739     } aExtension[] = {
  6603   6740       { "amatch",                sqlite3_amatch_init               },
         6741  +    { "carray",                sqlite3_carray_init               },
  6604   6742       { "closure",               sqlite3_closure_init              },
  6605   6743       { "csv",                   sqlite3_csv_init                  },
  6606   6744       { "eval",                  sqlite3_eval_init                 },
  6607   6745       { "fileio",                sqlite3_fileio_init               },
  6608   6746       { "fuzzer",                sqlite3_fuzzer_init               },
  6609   6747       { "ieee754",               sqlite3_ieee_init                 },
  6610   6748       { "nextchar",              sqlite3_nextchar_init             },
................................................................................
  7091   7229        Tcl_ObjCmdProc *xProc;
  7092   7230        void *clientData;
  7093   7231     } aObjCmd[] = {
  7094   7232        { "sqlite3_db_config",             test_sqlite3_db_config, 0 },
  7095   7233        { "bad_behavior",                  test_bad_behavior,  (void*)&iZero },
  7096   7234        { "register_dbstat_vtab",          test_register_dbstat_vtab  },
  7097   7235        { "sqlite3_connection_pointer",    get_sqlite_pointer, 0 },
         7236  +     { "intarray_addr",                 test_intarray_addr, 0 },
         7237  +     { "int64array_addr",               test_int64array_addr, 0 },
         7238  +     { "doublearray_addr",              test_doublearray_addr, 0 },
         7239  +     { "textarray_addr",                test_textarray_addr, 0 },
  7098   7240        { "sqlite3_bind_int",              test_bind_int,      0 },
  7099   7241        { "sqlite3_bind_zeroblob",         test_bind_zeroblob, 0 },
  7100   7242        { "sqlite3_bind_zeroblob64",       test_bind_zeroblob64, 0 },
  7101   7243        { "sqlite3_bind_int64",            test_bind_int64,    0 },
  7102   7244        { "sqlite3_bind_double",           test_bind_double,   0 },
  7103   7245        { "sqlite3_bind_null",             test_bind_null     ,0 },
  7104   7246        { "sqlite3_bind_text",             test_bind_text     ,0 },

Changes to test/tabfunc01.test.

    18     18   set testprefix tabfunc01
    19     19   
    20     20   ifcapable !vtab {
    21     21     finish_test
    22     22     return
    23     23   }
    24     24   load_static_extension db series
           25  +load_static_extension db carray
    25     26   
    26     27   do_execsql_test tabfunc01-1.1 {
    27     28     SELECT *, '|' FROM generate_series WHERE start=1 AND stop=9 AND step=2;
    28     29   } {1 | 3 | 5 | 7 | 9 |}
    29     30   do_execsql_test tabfunc01-1.2 {
    30     31     SELECT *, '|' FROM generate_series LIMIT 5;
    31     32   } {0 | 1 | 2 | 3 | 4 |}
................................................................................
   140    141   do_execsql_test tabfunc01-600 {
   141    142     CREATE TABLE t600(a INTEGER PRIMARY KEY, b TEXT);
   142    143     WITH RECURSIVE c(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM c WHERE x<100)
   143    144       INSERT INTO t600(a,b) SELECT x, printf('(%03d)',x) FROM c;
   144    145     SELECT b FROM t600 WHERE a IN generate_series(2,52,10);
   145    146   } {(002) (012) (022) (032) (042) (052)}
   146    147   
          148  +
          149  +do_test tabfunc01-700 {
          150  +  set PTR [intarray_addr 5 7 13 17 23]
          151  +  db eval {
          152  +    SELECT b FROM t600, carray($PTR,5) WHERE a=value;
          153  +  }
          154  +} {(005) (007) (013) (017) (023)}
          155  +do_test tabfunc01-701 {
          156  +  db eval {
          157  +    SELECT b FROM t600 WHERE a IN carray($PTR,5,'int32');
          158  +  }
          159  +} {(005) (007) (013) (017) (023)}
          160  +do_test tabfunc01-702 {
          161  +  db eval {
          162  +    SELECT b FROM t600 WHERE a IN carray($PTR,4,'int32');
          163  +  }
          164  +} {(005) (007) (013) (017)}
          165  +do_catchsql_test tabfunc01-710 {
          166  +  SELECT b FROM t600 WHERE a IN carray($PTR,5,'int33');
          167  +} {1 {unknown datatype: 'int33'}}
          168  +
          169  +do_test tabfunc01-720 {
          170  +  set PTR [int64array_addr 5 7 13 17 23]
          171  +  db eval {
          172  +    SELECT b FROM t600, carray($PTR,5,'int64') WHERE a=value;
          173  +  }
          174  +} {(005) (007) (013) (017) (023)}
          175  +
          176  +do_test tabfunc01-730 {
          177  +  set PTR [doublearray_addr 5.0 7.0 13.0 17.0 23.0]
          178  +  db eval {
          179  +    SELECT b FROM t600, carray($PTR,5,'double') WHERE a=value;
          180  +  }
          181  +} {(005) (007) (013) (017) (023)}
          182  +
          183  +do_test tabfunc01-740 {
          184  +  set PTR [textarray_addr 5 7 13 17 23]
          185  +  db eval {
          186  +    SELECT b FROM t600, carray($PTR,5,'char*') WHERE a=value;
          187  +  }
          188  +} {(005) (007) (013) (017) (023)}
          189  +
          190  +
          191  +intarray_addr
          192  +int64array_addr
          193  +doublearray_addr
          194  +textarray_addr
          195  +
   147    196   finish_test