// copyright nobody

// LINT_C_FILE

/*

file sqlmath.h

*/

// header

#include <assert.h>

#include <ctype.h>

#include <errno.h>

#include <math.h>

#include <stdint.h>

// #include <stdio.h>

#include <stdlib.h>

#include <string.h>

#ifdef WIN32

#include <windows.h>

#endif

#include <sqlite3ext.h>

static const sqlite3_api_routines *sqlite3_api;

// define

#define ALLOCF free

#define ALLOCM malloc

#define ALLOCR realloc

#define EOF -1

#define SIZEOF_BUFFER_DEFAULT 1024

#define SQLITE_MAX_LENGTH 1000000000

#define SQLMATH_API

#define UNUSED(x) (void)(x)

/*

** A macro to hint to the compiler that a function should not be

** inlined.

*/

#if defined(__GNUC__)

# define NOINLINE __attribute__((noinline))

#elif defined(_MSC_VER) && _MSC_VER >= 1310

# define NOINLINE __declspec(noinline)

#else

# define NOINLINE

#endif

/*

file sqlmath_str99.c

*/

// dynamically growable string

#define STR99_NOMEM -1

#define STR99_TOOBIG -2

// this macro will append <cc> to <str99> or goto label_error

#define STR99_APPEND_CHAR(cc) \

errcode = str99AppendChar(str99, cc, errcode); \

if (errcode != SQLITE_OK && errcode != SQLITE_ROW && \

errcode != SQLITE_DONE) {goto label_error;}

// this macro will json-escape-and-append <zz> to <str99> or goto label_error

#define STR99_APPEND_JSON(zz, nn) \

errcode = str99AppendJson(str99, zz, nn, errcode); \

if (errcode != SQLITE_OK && errcode != SQLITE_ROW && \

errcode != SQLITE_DONE) {goto label_error;}

// this macro will append <zz> to <str99> or goto label_error

#define STR99_APPEND_RAW(zz, nn) \

errcode = str99AppendRaw(str99, zz, nn, errcode); \

if (errcode != SQLITE_OK && errcode != SQLITE_ROW && \

errcode != SQLITE_DONE) {goto label_error;}

typedef struct Str99 {

char *zBuf; /* Accumulated string */

int nAlloced; /* Space allocated for zBuf[] */

int nUsed; /* Number of used-bytes in zBuf[] */

} Str99;

static int NOINLINE str99Resize(

Str99 * str99,

const char *zz,

int nn,

int errcode

);

static int str99AppendChar(

Str99 * str99,

const char cc,

int errcode

) {

/*

** Append <cc> to <str99->zBuf>.

** Increase the size of the memory allocation for <str99->zBuf> if necessary.

*/

// write <zz> to <str99->zBuf> if space available

if (str99->nUsed < str99->nAlloced) {

str99->zBuf[str99->nUsed] = cc;

str99->nUsed += 1;

return errcode;

}

// else resize and retry

return str99Resize(str99, &cc, 1, errcode);

}

static int str99AppendRaw(

Str99 * str99,

const char *zz,

int nn,

int errcode

) {

/*

** Append <nn> bytes of text from <zz> to <str99->zBuf>.

** Increase the size of the memory allocation for <str99->zBuf> if necessary.

*/

if (nn == 0) {

return errcode;

}

// write <zz> to <str99->zBuf> if space available

if (0 < nn && str99->nUsed + nn <= str99->nAlloced) {

memcpy(str99->zBuf + str99->nUsed, zz, nn);

str99->nUsed += nn;

return errcode;

}

// else resize and retry

return str99Resize(str99, zz, nn, errcode);

}

static int NOINLINE str99Resize(

Str99 * str99,

const char *zz,

int nn,

int errcode

) {

/*

** Increase the size of the memory allocation for <str99->zBuf>.

*/

// declare var

char *zTmp;

int nAlloc;

// sanity check

if (errcode != SQLITE_OK && errcode != SQLITE_ROW) {

return errcode;

}

// check SQLITE_MAX_LENGTH

if (nn < 0 || nn > SQLITE_MAX_LENGTH) {

return STR99_TOOBIG;

}

// grow nalloc exponentially

nAlloc = str99->nAlloced;

while (nAlloc < str99->nUsed + nn) {

nAlloc *= 2;

if (nAlloc > SQLITE_MAX_LENGTH) {

return STR99_TOOBIG;

}

}

zTmp = ALLOCR(str99->zBuf, nAlloc);

if (zTmp == NULL) {

return STR99_NOMEM;

}

str99->nAlloced = nAlloc;

str99->zBuf = zTmp;

// recurse

return str99AppendRaw(str99, zz, nn, errcode);

}

static int str99AppendJson(

Str99 * str99,

const char *zz,

int nn,

int errcode

) {

/*

** Append <nn> bytes of text from <zz> to <str99->zBuf> with json-escaping.

** Increase the size of the memory allocation for <str99->zBuf> if necessary.

*/

// declare var

const char *zz2 = zz + nn;

// double-quote open

STR99_APPEND_RAW("\"", 1);

while (zz < zz2) {

switch (*zz) {

case '\x00':

STR99_APPEND_RAW("\\u0000", 6);

break;

case '\x01':

STR99_APPEND_RAW("\\u0001", 6);

break;

case '\x02':

STR99_APPEND_RAW("\\u0002", 6);

break;

case '\x03':

STR99_APPEND_RAW("\\u0003", 6);

break;

case '\x04':

STR99_APPEND_RAW("\\u0004", 6);

break;

case '\x05':

STR99_APPEND_RAW("\\u0005", 6);

break;

case '\x06':

STR99_APPEND_RAW("\\u0006", 6);

break;

case '\x07':

STR99_APPEND_RAW("\\u0007", 6);

break;

case '\x08':

STR99_APPEND_CHAR('\\');

STR99_APPEND_CHAR('b');

break;

case '\x09':

STR99_APPEND_CHAR('\\');

STR99_APPEND_CHAR('t');

break;

case '\x0a':

STR99_APPEND_CHAR('\\');

STR99_APPEND_CHAR('n');

break;

case '\x0b':

STR99_APPEND_RAW("\\u000b", 6);

break;

case '\x0c':

STR99_APPEND_CHAR('\\');

STR99_APPEND_CHAR('f');

break;

case '\x0d':

STR99_APPEND_CHAR('\\');

STR99_APPEND_CHAR('r');

break;

case '\x0e':

STR99_APPEND_RAW("\\u000e", 6);

break;

case '\x0f':

STR99_APPEND_RAW("\\u000f", 6);

break;

case '\x10':

STR99_APPEND_RAW("\\u0010", 6);

break;

case '\x11':

STR99_APPEND_RAW("\\u0011", 6);

break;

case '\x12':

STR99_APPEND_RAW("\\u0012", 6);

break;

case '\x13':

STR99_APPEND_RAW("\\u0013", 6);

break;

case '\x14':

STR99_APPEND_RAW("\\u0014", 6);

break;

case '\x15':

STR99_APPEND_RAW("\\u0015", 6);

break;

case '\x16':

STR99_APPEND_RAW("\\u0016", 6);

break;

case '\x17':

STR99_APPEND_RAW("\\u0017", 6);

break;

case '\x18':

STR99_APPEND_RAW("\\u0018", 6);

break;

case '\x19':

STR99_APPEND_RAW("\\u0019", 6);

break;

case '\x1a':

STR99_APPEND_RAW("\\u001a", 6);

break;

case '\x1b':

STR99_APPEND_RAW("\\u001b", 6);

break;

case '\x1c':

STR99_APPEND_RAW("\\u001c", 6);

break;

case '\x1d':

STR99_APPEND_RAW("\\u001d", 6);

break;

case '\x22':

STR99_APPEND_CHAR('\\');

STR99_APPEND_CHAR('\"');

break;

case '\x5c':

STR99_APPEND_CHAR('\\');

STR99_APPEND_CHAR('\\');

break;

default:

STR99_APPEND_CHAR(*zz);

}

zz += 1;

}

// double-quote close

return STR99_APPEND_RAW("\"", 1);

label_error:

return 0;

}

/*

file sqlmath_blobtable.c

*/

// https://github.com/sqlite/sqlite/blob/version-3.36.0/ext/misc/csv.c

/*

** 2016-05-28

**

** The author disclaims copyright to this source code. In place of

** a legal notice, here is a blessing:

**

** May you do good and not evil.

** May you find forgiveness for yourself and forgive others.

** May you share freely, never taking more than you give.

**

******************************************************************************

**

** This file contains the implementation of an SQLite virtual table for

** reading CSV files.

**

** Usage:

**

** .load ./csv

** CREATE VIRTUAL TABLE temp.csv USING csv(data=DATA);

** SELECT * FROM csv;

**

** The columns are named "c1", "c2", "c3", ... by default. Or the

** application can define its own CREATE TABLE statement using the

** schema= parameter, like this:

**

** CREATE VIRTUAL TABLE temp.csv2 USING csv(

** data = "c1,c2\n1,2",

** schema = "CREATE TABLE x(date,ipaddr,url,referrer,userAgent)"

** );

**

** Instead of specifying a file, the text of the CSV can be loaded using

** the data= parameter.

**

** If the columns=NN parameter is supplied, then the CSV file is assumed to have

** NN columns. If both the columns= and schema= parameters are omitted, then

** the number and names of the columns is determined by the first line of

** the CSV input.

*/

/* Max size of the error message in a CsvReader */

#define CSV_MXERR 200

/* An instance of the CSV virtual table */

typedef struct CsvTable {

sqlite3_vtab base; /* Base class. Must be first */

char *zData; /* Raw CSV data in lieu of zFilename */

int nAlloced; /* Space allocated for zBuf[] */

int nUsed; /* Number of used-bytes in zBuf[] */

int iStart; /* Offset to start of data in zFilename */

int nCol; /* Number of columns in the CSV file */

} CsvTable;

/* A context object used when read a CSV file. */

typedef struct CsvReader {

char *zBuf; /* Accumulated string */

int nAlloced; /* Space allocated for zBuf[] */

int nUsed; /* Number of used-bytes in zBuf[] */

int nLine; /* Current line number */

int bNotFirst; /* True if prior text has been seen */

int cTerm; /* Char that terminated most recent field */

size_t iIn; /* Next unread character in the input buffer */

size_t nIn; /* Number of characters in the input buffer */

char *zIn; /* The input buffer */

char zErr[CSV_MXERR]; /* Error message */

} CsvReader;

/* A cursor for the CSV virtual table */

typedef struct CsvCursor {

sqlite3_vtab_cursor base; /* Base class. Must be first */

CsvReader rdr; /* The CsvReader object */

char **azVal; /* Value of the current row */

int *aLen; /* Length of each entry */

sqlite3_int64 iRowid; /* The current rowid. Negative for EOF */

} CsvCursor;

static void csv_reader_init(

CsvReader * pRdr

) {

/* Initialize a CsvReader object */

pRdr->zBuf = 0;

pRdr->nUsed = 0;

pRdr->nAlloced = 0;

pRdr->nLine = 0;

pRdr->bNotFirst = 0;

pRdr->nIn = 0;

pRdr->zIn = 0;

pRdr->zErr[0] = 0;

}

static void csv_reader_reset(

CsvReader * pRdr

) {

/* Close and reset a CsvReader object */

sqlite3_free(pRdr->zBuf);

csv_reader_init(pRdr);

}

static void csv_errmsg(

CsvReader * pRdr,

const char *zFormat,

...

) {

/* Report an error on a CsvReader */

va_list ap;

va_start(ap, zFormat);

sqlite3_vsnprintf(CSV_MXERR, pRdr->zErr, zFormat, ap);

va_end(ap);

}

static int csv_getc(

/* Return the next character of input. Return EOF at end of input. */

CsvReader * pRdr

) {

if (pRdr->iIn >= pRdr->nIn) {

return EOF;

}

return ((unsigned char *) pRdr->zIn)[pRdr->iIn++];

}

static int NOINLINE csv_resize_and_append(

/* Increase the size of pRdr->zBuf and append character c to the end.

** Return 0 on success and non-zero if there is an OOM error */

CsvReader * pRdr,

char c

) {

char *zNew;

int nNew = pRdr->nAlloced * 2 + 100;

zNew = sqlite3_realloc64(pRdr->zBuf, nNew);

if (zNew) {

pRdr->zBuf = zNew;

pRdr->nAlloced = nNew;

pRdr->zBuf[pRdr->nUsed++] = c;

return 0;

} else {

csv_errmsg(pRdr, "out of memory");

return 1;

}

}

/* Append a single character to the CsvReader.zBuf[] array.

** Return 0 on success and non-zero if there is an OOM error */

static int csv_append(

CsvReader * pRdr,

char c

) {

if (pRdr->nUsed >= pRdr->nAlloced - 1)

return csv_resize_and_append(pRdr, c);

pRdr->zBuf[pRdr->nUsed++] = c;

return 0;

}

/* Read a single field of CSV text. Compatible with rfc4180 and extended

** with the option of having a separator other than ",".

**

** + Input comes from pRdr->in.

** + Store results in pRdr->zBuf of length pRdr->nUsed. Space to hold pRdr->zBuf comes

** from sqlite3_malloc64().

** + Keep track of the line number in pRdr->nLine.

** + Store the character that terminates the field in pRdr->cTerm. Store

** EOF on end-of-file.

**

** Return 0 at EOF or on OOM. On EOF, the pRdr->cTerm character will have

** been set to EOF.

*/

static char *csv_read_one_field(

CsvReader * pRdr

) {

int c;

pRdr->nUsed = 0;

c = csv_getc(pRdr);

if (c == EOF) {

pRdr->cTerm = EOF;

return 0;

}

if (c == '"') {

int pc;

int ppc;

int startLine = pRdr->nLine;

pc = ppc = 0;

while (1) {

c = csv_getc(pRdr);

if (c <= '"' || pc == '"') {

if (c == '\n')

pRdr->nLine++;

if (c == '"') {

if (pc == '"') {

pc = 0;

continue;

}

}

if ((c == ',' && pc == '"')

|| (c == '\n' && pc == '"')

|| (c == '\n' && pc == '\r' && ppc == '"')

|| (c == EOF && pc == '"')

) {

while (1) {

pRdr->nUsed--;

if (pRdr->zBuf[pRdr->nUsed] == '"') {

break;

}

}

pRdr->cTerm = (char) c;

break;

}

if (pc == '"' && c != '\r') {

csv_errmsg(pRdr, "line %d: unescaped %c character",

pRdr->nLine, '"');

break;

}

if (c == EOF) {

csv_errmsg(pRdr,

"line %d: unterminated %c-quoted field\n", startLine,

'"');

pRdr->cTerm = (char) c;

break;

}

}

if (csv_append(pRdr, (char) c))

return 0;

ppc = pc;

pc = c;

}

} else {

/* If this is the first field being parsed and it begins with the

** UTF-8 BOM (0xEF BB BF) then skip the BOM */

// if (...) {...}

while (c > ',' || (c != EOF && c != ',' && c != '\n')) {

if (csv_append(pRdr, (char) c))

return 0;

c = csv_getc(pRdr);

}

if (c == '\n') {

pRdr->nLine++;

if (pRdr->nUsed > 0 && pRdr->zBuf[pRdr->nUsed - 1] == '\r')

pRdr->nUsed--;

}

pRdr->cTerm = (char) c;

}

if (pRdr->zBuf)

pRdr->zBuf[pRdr->nUsed] = 0;

pRdr->bNotFirst = 1;

return pRdr->zBuf;

}

/*

** This method is the destructor fo a CsvTable object.

*/

static int csvtabDisconnect(

sqlite3_vtab * pVtab

) {

CsvTable *pRdr = (CsvTable *) pVtab;

sqlite3_free(pRdr->zData);

sqlite3_free(pRdr);

return SQLITE_OK;

}

/* Skip leading whitespace. Return a pointer to the first non-whitespace

** character, or to the zero terminator if the string has only whitespace */

static const char *csv_skip_whitespace(

const char *buf

) {

while (isspace((unsigned char) buf[0]))

buf++;

return buf;

}

/* Remove trailing whitespace from the end of string buf[] */

static void csv_trim_whitespace(

char *buf

) {

size_t nn = strlen(buf);

while (nn > 0 && isspace((unsigned char) buf[nn]))

nn--;

buf[nn] = 0;

}

/* Dequote the string */

static void csv_dequote(

char *buf

) {

int jj;

char cQuote = buf[0];

size_t ii,

nn;

if (cQuote != '\'' && cQuote != '"')

return;

nn = strlen(buf);

if (nn < 2 || buf[nn - 1] != buf[0])

return;

for (ii = 1, jj = 0; ii < nn - 1; ii++) {

if (buf[ii] == cQuote && buf[ii + 1] == cQuote)

ii++;

buf[jj++] = buf[ii];

}

buf[jj] = 0;

}

/* Check to see if the string is of the form: "TAG = VALUE" with optional

** whitespace before and around tokens. If it is, return a pointer to the

** first character of VALUE. If it is not, return NULL.

*/

static const char *csv_parameter(

const char *zTag,

int nTag,

const char *buf

) {

buf = csv_skip_whitespace(buf);

if (strncmp(zTag, buf, nTag) != 0)

return 0;

buf = csv_skip_whitespace(buf + nTag);

if (buf[0] != '=')

return 0;

return csv_skip_whitespace(buf + 1);

}

/* Decode a parameter that requires a dequoted string.

**

** Return 1 if the parameter is seen, or 0 if not. 1 is returned

** even if there is an error. If an error occurs, then an error message

** is left in pRdr->zErr. If there are no errors, pRdr->zErr[0]==0.

*/

static int csv_string_parameter(

CsvReader * pRdr, /* Leave error message here, if there is one */

const char *zParam, /* Parameter we are checking for */

const char *zArg, /* Raw text of the virtual table argment */

char **pzVal /* Write the dequoted string value here */

) {

const char *zValue;

zValue = csv_parameter(zParam, (int) strlen(zParam), zArg);

if (zValue == 0)

return 0;

pRdr->zErr[0] = 0;

if (*pzVal) {

csv_errmsg(pRdr, "more than one '%s' parameter", zParam);

return 1;

}

*pzVal = sqlite3_mprintf("%s", zValue);

if (*pzVal == 0) {

csv_errmsg(pRdr, "out of memory");

return 1;

}

csv_trim_whitespace(*pzVal);

csv_dequote(*pzVal);

return 1;

}

/* Return 0 if the argument is false and 1 if it is true. Return -1 if

** we cannot really tell.

*/

static int csv_boolean(

const char *buf

) {

if (sqlite3_stricmp("yes", buf) == 0

|| sqlite3_stricmp("on", buf) == 0

|| sqlite3_stricmp("true", buf) == 0 || (buf[0] == '1' && buf[1] == 0)

) {

return 1;

}

if (sqlite3_stricmp("no", buf) == 0

|| sqlite3_stricmp("off", buf) == 0

|| sqlite3_stricmp("false", buf) == 0 || (buf[0] == '0'

&& buf[1] == 0)

) {

return 0;

}

return -1;

}

/* Check to see if the string is of the form: "TAG = BOOLEAN" or just "TAG".

** If it is, set *pValue to be the value of the boolean ("true" if there is

** not "= BOOLEAN" component) and return non-zero. If the input string

** does not begin with TAG, return zero.

*/

static int csv_boolean_parameter(

const char *zTag, /* Tag we are looking for */

int nTag, /* Size of the tag in bytes */

const char *buf, /* Input parameter */

int *pValue /* Write boolean value here */

) {

int b;

buf = csv_skip_whitespace(buf);

if (strncmp(zTag, buf, nTag) != 0)

return 0;

buf = csv_skip_whitespace(buf + nTag);

if (buf[0] == 0) {

*pValue = 1;

return 1;

}

if (buf[0] != '=')

return 0;

buf = csv_skip_whitespace(buf + 1);

b = csv_boolean(buf);

if (b >= 0) {

*pValue = b;

return 1;

}

return 0;

}

/*

** Parameters:

** filename=FILENAME Name of file containing CSV content

** data=TEXT Direct CSV content.

** schema=SCHEMA Alternative CSV schema.

** columns=NN Assume the CSV file contains NN columns.

**

** If schema= is omitted, then the columns are named "c0", "c1", "c2",

** and so forth. If columns=NN is omitted, then the file is opened and

** the number of columns in the first row is counted to determine the

** column count. first row is skipped as header.

*/

static int csvtabConnect(

sqlite3 * db,

void *pAux,

int argc,

const char *const *argv,

sqlite3_vtab ** ppVtab,

char **pzErr

) {

UNUSED(pAux);

// declare var

CsvTable *pNew = 0; /* The CsvTable object to construct */

int rc = SQLITE_OK; /* Result code from this routine */

size_t ii; /* Loop counters */

size_t jj; /* Loop counters */

int nCol = -99; /* Value of the columns= parameter */

/* A CSV file reader used to store an error

** message and/or to count the number of columns */

CsvReader sRdr;

static const char *azParam[] = {

"filename", "data", "schema",

};

char *azPValue[3]; /* Parameter values */

# define CSV_FILENAME (azPValue[0])

# define CSV_DATA (azPValue[1])

# define CSV_SCHEMA (azPValue[2])

assert(sizeof(azPValue) == sizeof(azParam));

memset(&sRdr, 0, sizeof(sRdr));

memset(azPValue, 0, sizeof(azPValue));

for (ii = 3; ii < argc; ii++) {

const char *buf = argv[ii];

const char *zValue;

for (jj = 0; jj < sizeof(azParam) / sizeof(azParam[0]); jj++) {

if (csv_string_parameter(&sRdr, azParam[jj], buf, &azPValue[jj]))

break;

}

if (jj < sizeof(azParam) / sizeof(azParam[0])) {

if (sRdr.zErr[0])

goto csvtab_connect_error;

} else if ((zValue = csv_parameter("columns", 7, buf)) != 0) {

if (nCol > 0) {

csv_errmsg(&sRdr, "more than one 'columns' parameter");

goto csvtab_connect_error;

}

nCol = atoi(zValue);

if (nCol <= 0) {

csv_errmsg(&sRdr, "column= value must be positive");

goto csvtab_connect_error;

}

} else {

csv_errmsg(&sRdr, "bad parameter: '%s'", buf);

goto csvtab_connect_error;

}

}

if ((CSV_FILENAME == 0) == (CSV_DATA == 0)) {

csv_errmsg(&sRdr,

"must specify either filename= or data= but not both");

goto csvtab_connect_error;

}

//!! csv_reader_open(&sRdr, CSV_DATA);

sRdr.zIn = (char *) CSV_DATA;

sRdr.nIn = strlen(CSV_DATA);

pNew = sqlite3_malloc(sizeof(*pNew));

*ppVtab = (sqlite3_vtab *) pNew;

if (pNew == 0)

goto csvtab_connect_oom;

memset(pNew, 0, sizeof(*pNew));

sqlite3_str *pStr = sqlite3_str_new(0);

char *zSep = "";

int iCol = 0;

sqlite3_str_appendf(pStr, "CREATE TABLE x(");

// read columns from first row

while (1) {

char *buf = csv_read_one_field(&sRdr);

if ((nCol > 0 && iCol < nCol) || nCol < 0) {

sqlite3_str_appendf(pStr, "%s\"%w\" TEXT", zSep, buf);

zSep = ",";

iCol++;

}

if (sRdr.cTerm != ',') {

break;

}

}

if (nCol < 0) {

nCol = iCol;

} else {

while (iCol < nCol) {

sqlite3_str_appendf(pStr, "%sc%d TEXT", zSep, ++iCol);

zSep = ",";

}

}

pNew->nCol = nCol;

sqlite3_str_appendf(pStr, ")");

CSV_SCHEMA = sqlite3_str_finish(pStr);

if (CSV_SCHEMA == 0)

goto csvtab_connect_oom;

pNew->zData = CSV_DATA;

CSV_DATA = 0;

// skip first row of headers

pNew->iStart = (int) sRdr.iIn;

csv_reader_reset(&sRdr);

rc = sqlite3_declare_vtab(db, CSV_SCHEMA);

if (rc) {

csv_errmsg(&sRdr, "bad schema: '%s' - %s", CSV_SCHEMA,

sqlite3_errmsg(db));

goto csvtab_connect_error;

}

for (ii = 0; ii < sizeof(azPValue) / sizeof(azPValue[0]); ii++) {

sqlite3_free(azPValue[ii]);

}

/* Rationale for DIRECTONLY:

** An attacker who controls a database schema could use this vtab

** to exfiltrate sensitive data from other files in the filesystem.

** And, recommended practice is to put all CSV virtual tables in the

** TEMP namespace, so they should still be usable from within TEMP

** views, so there shouldn't be a serious loss of functionality by

** prohibiting the use of this vtab from persistent triggers and views.

*/

sqlite3_vtab_config(db, SQLITE_VTAB_DIRECTONLY);

return SQLITE_OK;

csvtab_connect_oom:

rc = SQLITE_NOMEM;

csv_errmsg(&sRdr, "out of memory");

csvtab_connect_error:

if (pNew)

csvtabDisconnect(&pNew->base);

for (ii = 0; ii < sizeof(azPValue) / sizeof(azPValue[0]); ii++) {

sqlite3_free(azPValue[ii]);

}

if (sRdr.zErr[0]) {

sqlite3_free(*pzErr);

*pzErr = sqlite3_mprintf("%s", sRdr.zErr);

}

csv_reader_reset(&sRdr);

if (rc == SQLITE_OK)

rc = SQLITE_ERROR;

return rc;

}

/*

** Reset the current row content held by a CsvCursor.

*/

static void csvtabCursorRowReset(

CsvCursor * pCur

) {

CsvTable *pTab = (CsvTable *) pCur->base.pVtab;

int ii;

for (ii = 0; ii < pTab->nCol; ii++) {

sqlite3_free(pCur->azVal[ii]);

pCur->azVal[ii] = 0;

pCur->aLen[ii] = 0;

}

}

/*

** The xConnect and xCreate methods do the same thing, but they must be

** different so that the virtual table is not an eponymous virtual table.

*/

static int csvtabCreate(

sqlite3 * db,

void *pAux,

int argc,

const char *const *argv,

sqlite3_vtab ** ppVtab,

char **pzErr

) {

return csvtabConnect(db, pAux, argc, argv, ppVtab, pzErr);

}

/*

** Destructor for a CsvCursor.

*/

static int csvtabClose(

sqlite3_vtab_cursor * cur

) {

CsvCursor *pCur = (CsvCursor *) cur;

csvtabCursorRowReset(pCur);

csv_reader_reset(&pCur->rdr);

sqlite3_free(cur);

return SQLITE_OK;

}

/*

** Constructor for a new CsvTable cursor object.

*/

static int csvtabOpen(

sqlite3_vtab * pRdr,

sqlite3_vtab_cursor ** ppCursor

) {

CsvTable *pTab = (CsvTable *) pRdr;

CsvCursor *pCur;

size_t nByte;

nByte = sizeof(*pCur) + (sizeof(char *) + sizeof(int)) * pTab->nCol;

pCur = sqlite3_malloc64(nByte);

if (pCur == 0)

return SQLITE_NOMEM;

memset(pCur, 0, nByte);

pCur->azVal = (char **) &pCur[1];

pCur->aLen = (int *) &pCur->azVal[pTab->nCol];

*ppCursor = &pCur->base;

//!! csv_reader_open(&pCur->rdr, pTab->zData);

pCur->rdr.zIn = (char *) pTab->zData;

pCur->rdr.nIn = strlen(pTab->zData);

return SQLITE_OK;

}

/*

** Advance a CsvCursor to its next row of input.

** Set the EOF marker if we reach the end of input.

*/

static int csvtabNext(

sqlite3_vtab_cursor * cur

) {

CsvCursor *pCur = (CsvCursor *) cur;

CsvTable *pTab = (CsvTable *) cur->pVtab;

int ii = 0;

char *buf;

while (1) {

buf = csv_read_one_field(&pCur->rdr);

if (buf == 0) {

break;

}

if (ii < pTab->nCol) {

if (pCur->aLen[ii] < pCur->rdr.nUsed + 1) {

char *zNew =

sqlite3_realloc64(pCur->azVal[ii], pCur->rdr.nUsed + 1);

/* Transfer error message text from a reader into a CsvTable */

if (zNew == 0) {

csv_errmsg(&pCur->rdr, "out of memory");

sqlite3_free(pTab->base.zErrMsg);

pTab->base.zErrMsg =

sqlite3_mprintf("%s", pCur->rdr.zErr);

break;

}

pCur->azVal[ii] = zNew;

pCur->aLen[ii] = pCur->rdr.nUsed + 1;

}

memcpy(pCur->azVal[ii], buf, pCur->rdr.nUsed + 1);

ii++;

}

if (pCur->rdr.cTerm != ',') {

break;

}

}

if (buf == 0 || (pCur->rdr.cTerm == EOF && ii < pTab->nCol)) {

pCur->iRowid = -1;

} else {

pCur->iRowid++;

while (ii < pTab->nCol) {

sqlite3_free(pCur->azVal[ii]);

pCur->azVal[ii] = 0;

pCur->aLen[ii] = 0;

ii++;

}

}

return SQLITE_OK;

}

/*

** Return values of columns for the row at which the CsvCursor

** is currently pointing.

*/

static int csvtabColumn(

sqlite3_vtab_cursor * cur, /* The cursor */

sqlite3_context * ctx, /* First argument to sqlite3_result_...() */

int ii /* Which column to return */

) {

CsvCursor *pCur = (CsvCursor *) cur;

CsvTable *pTab = (CsvTable *) cur->pVtab;

if (ii >= 0 && ii < pTab->nCol && pCur->azVal[ii] != 0) {

sqlite3_result_text(ctx, pCur->azVal[ii], -1, SQLITE_TRANSIENT);

}

return SQLITE_OK;

}

/*

** Return the rowid for the current row.

*/

static int csvtabRowid(

sqlite3_vtab_cursor * cur,

sqlite_int64 * pRowid

) {

CsvCursor *pCur = (CsvCursor *) cur;

*pRowid = pCur->iRowid;

return SQLITE_OK;

}

/*