int main (void)
{
sqlite3 *db;
//char *err = 0;
int ret = 0;
char **datatable1;
char **datatable3;
int nRow;
int nColumn;
char *sql;
int i;
char *zErrMsg = 0;
cgi_init();
cgi_init_headers();
cgi_process_form();
puts("<html><head><title>chaxun</title>");
puts("<meta http-equiv='Content-Type' content='text/html; charset=utf-8' />");
//puts("<link href=\"/Style.css\" rel=\"stylesheet\" type=\"text/css\" />");
puts("</head>");
puts("<body bgColor=#fffff0>");
db = open_db("OAK.db");
sql = sqlite3_mprintf("select * from IpInfo");
ret = sqlite3_get_table(db, sql, &datatable1, &nRow, &nColumn, &zErrMsg);
if (ret != SQLITE_OK) {
fprintf(stderr, "SQL error: %s\n", zErrMsg);
exit(1);
}
puts("<form action=\"load.cgi\">");
puts("<table width='70%' align='left' border=1 border-coer=#000066>");
puts("<tr><td width='20%'>");
puts("<select NAME = \"ip\">");
puts("<option value = \"\"> 选择IP</option> ");
if (!(0 == nRow && 0 == nColumn)) {
for (i = 1; i <= nRow*nColumn ; i += nColumn ) {
printf("<option value = \"%s\"", datatable1[i]);
if (cgi_param("company")) {
if (0 == strncmp(cgi_param("ip"), datatable1[i],strlen(datatable1[i])))
printf("SELECTED");
}
printf("> %s </option> ", datatable1[i]);
}
}
puts("</select>");
puts("</td>");
puts("<td>");
puts("<input type=\"submit\" value=\"上传\" name=\"action\" >");
puts("</td></tr></table>");
sql = sqlite3_mprintf("select R.R_id,R.R_name,R.R_flag,C.C_name from ResInfo R left join CompanyInfo C on R.C_id = C.C_id;");
puts("<br />");
puts("<br />");
ret = sqlite3_get_table(db, sql, &datatable3, &nRow, &nColumn, &zErrMsg);
if (ret != SQLITE_OK) {
fprintf(stderr, "SQL error: %s\n", zErrMsg);
exit(1);
}
puts("<table width='70%' align='left' border=1>");
puts("<tr><td style=\"width:50px\" align=center>选择</td>");
puts("<td style=\"width:150px\" align=center>媒体名称</td>");
puts("<td style=\"width:120px\" align=center>媒体类型</td>");
puts("<td style=\"width:170px\" align=center>所属公司</td>");
puts("</tr>");
if (!(0 == nRow && 0 == nColumn)) {
for (i = 4; i <= nRow*nColumn ; i += nColumn ) {
puts("<tr><td align='center'><input type = 'checkbox' name='xuanqu' ");
printf(" value=%s />", datatable3[i+0]);
puts("</td>");
printf("<td>%s</td>", datatable3[i+1]);
if(atoi(datatable3[i+2]) == 0){
printf("<td>视频文件</td>");
} else {
printf("<td>图片文件</td>");
}
printf("<td>%s</td></tr>",datatable3[i+3]);
}
}
puts("</table>");
puts("</form>");
puts("</body></html>");
cgi_end();
return 0;
}
/*
** xConnect/xCreate method for the amatch module. Arguments are:
**
** argv[0] -> module name ("approximate_match")
** argv[1] -> database name
** argv[2] -> table name
** argv[3...] -> arguments
*/
static int amatchConnect(
sqlite3 *db,
void *pAux,
int argc, const char *const*argv,
sqlite3_vtab **ppVtab,
char **pzErr
){
int rc = SQLITE_OK; /* Return code */
amatch_vtab *pNew = 0; /* New virtual table */
const char *zModule = argv[0];
const char *zDb = argv[1];
const char *zVal;
int i;
(void)pAux;
*ppVtab = 0;
pNew = sqlite3_malloc( sizeof(*pNew) );
if( pNew==0 ) return SQLITE_NOMEM;
rc = SQLITE_NOMEM;
memset(pNew, 0, sizeof(*pNew));
pNew->db = db;
pNew->zClassName = sqlite3_mprintf("%s", zModule);
if( pNew->zClassName==0 ) goto amatchConnectError;
pNew->zDb = sqlite3_mprintf("%s", zDb);
if( pNew->zDb==0 ) goto amatchConnectError;
pNew->zSelf = sqlite3_mprintf("%s", argv[2]);
if( pNew->zSelf==0 ) goto amatchConnectError;
for(i=3; i<argc; i++){
zVal = amatchValueOfKey("vocabulary_table", argv[i]);
if( zVal ){
sqlite3_free(pNew->zVocabTab);
pNew->zVocabTab = amatchDequote(zVal);
if( pNew->zVocabTab==0 ) goto amatchConnectError;
continue;
}
zVal = amatchValueOfKey("vocabulary_word", argv[i]);
if( zVal ){
sqlite3_free(pNew->zVocabWord);
pNew->zVocabWord = amatchDequote(zVal);
if( pNew->zVocabWord==0 ) goto amatchConnectError;
continue;
}
zVal = amatchValueOfKey("vocabulary_language", argv[i]);
if( zVal ){
sqlite3_free(pNew->zVocabLang);
pNew->zVocabLang = amatchDequote(zVal);
if( pNew->zVocabLang==0 ) goto amatchConnectError;
continue;
}
zVal = amatchValueOfKey("edit_distances", argv[i]);
if( zVal ){
sqlite3_free(pNew->zCostTab);
pNew->zCostTab = amatchDequote(zVal);
if( pNew->zCostTab==0 ) goto amatchConnectError;
continue;
}
*pzErr = sqlite3_mprintf("unrecognized argument: [%s]\n", argv[i]);
amatchFree(pNew);
*ppVtab = 0;
return SQLITE_ERROR;
}
rc = SQLITE_OK;
if( pNew->zCostTab==0 ){
*pzErr = sqlite3_mprintf("no edit_distances table specified");
rc = SQLITE_ERROR;
}else{
rc = amatchLoadRules(db, pNew, pzErr);
}
if( rc==SQLITE_OK ){
rc = sqlite3_declare_vtab(db,
"CREATE TABLE x(word,distance,language,"
"command HIDDEN,nword HIDDEN)"
);
#define AMATCH_COL_WORD 0
#define AMATCH_COL_DISTANCE 1
#define AMATCH_COL_LANGUAGE 2
#define AMATCH_COL_COMMAND 3
#define AMATCH_COL_NWORD 4
}
if( rc!=SQLITE_OK ){
amatchFree(pNew);
}
*ppVtab = &pNew->base;
return rc;
amatchConnectError:
amatchFree(pNew);
return rc;
}
gboolean dive_db_merge_next(gint dive_id,glong dive_number,MergeDiveData *merge_data)
{
gint rc;
gchar *sqlErrMsg=NULL,*sqlcmd,*tptr;
gboolean rval=TRUE;
glong sample_interval;
gdouble profile_temperature;
sqlcmd=sqlite3_mprintf(
"SELECT Dive.dive_id,dive_number,dive_datetime,dive_maxdepth,dive_duration,dive_maxtemp,dive_mintemp,Profile.dive_id FROM Dive LEFT JOIN Profile ON Profile.dive_id=Dive.dive_id WHERE dive_number=%d LIMIT 1",
dive_number+1
);
rc=sqlite3_exec(logbook_db,sqlcmd,(gpointer)dive_db_merge_next_callback,merge_data,&sqlErrMsg);
if(rc!=SQLITE_OK){
g_log (G_LOG_DOMAIN, G_LOG_LEVEL_ERROR,"Error in dive_db_merge_next()\nCode=%d\nError Message='%s'\n",rc,sqlErrMsg);
sqlite3_free(sqlErrMsg);
rval=FALSE;
}
else {
sqlite3_free(sqlcmd);
/* do merge
/* 1 - If both dives have profiles and the SI < 1 min, insert a profile segment */
/* one interval before second dive with same depth and temperature as last */
/* profile segment of dive 1 */
/* 2 - Update duration maxdepth and temperatures of dive one */
/* 3 - If dive 2 has profile update the profile segments for dive 2 to dive 1 by */
/* setting to id of dive one and adding time to profile_time */
/* 4 - delete dive two by calling dive_db_delete() */
sqlcmd=sqlite3_mprintf(
"UPDATE Dive SET dive_maxdepth=%f,dive_duration=%d,dive_maxtemp=%f,dive_mintemp=%f WHERE dive_id=%d",
merge_data->max_depth,merge_data->duration,merge_data->max_temperature,merge_data->min_temperature,dive_id
);
if(merge_data->has_profile) {
tptr=sqlcmd;
sqlcmd=sqlite3_mprintf(
"%s;UPDATE Profile SET profile_time=profile_time+%d,dive_id=%d WHERE dive_id=%d",
sqlcmd,merge_data->duration_mod,dive_id,merge_data->dive_id
);
sqlite3_free(tptr);
if(profile_exists() && merge_data->SI>60) {
tptr=sqlcmd;
sqlcmd=sqlite3_mprintf(
"INSERT INTO Profile (dive_id,profile_time,profile_depth,profile_temperature) "
"SELECT %d, %d-(SELECT MAX(profile_time)/COUNT(*) FROM Profile WHERE dive_id=%d),"
"profile_depth,profile_temperature FROM Profile WHERE dive_id=%d "
"ORDER BY profile_time DESC LIMIT 1;%s",
dive_id,merge_data->duration_mod,merge_data->dive_id,dive_id,sqlcmd
);
sqlite3_free(tptr);
}
}
rc=sqlite3_exec(logbook_db,sqlcmd,NULL,0,&sqlErrMsg);
if(rc!=SQLITE_OK) {
g_log (G_LOG_DOMAIN,G_LOG_LEVEL_ERROR,"Error in dive_db_merge_next()\nCode=%d\nError Message='%s'\n",rc,sqlErrMsg);
sqlite3_free(sqlErrMsg);
rval=FALSE;
}
else dive_db_delete(merge_data->dive_id,merge_data->dive_number);
}
sqlite3_free(sqlcmd);
return rval;
}
int
main (int argc, char *argv[])
{
int ret;
sqlite3 *handle;
char *err_msg = NULL;
char **results;
int rows;
int columns;
unsigned char *blob;
int blob_len;
char *hexBlob;
unsigned char *xml;
int len;
char *sql;
void *cache = spatialite_alloc_connection ();
if (argc > 1 || argv[0] == NULL)
argc = 1; /* silencing stupid compiler warnings */
ret =
sqlite3_open_v2 (":memory:", &handle,
SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
if (ret != SQLITE_OK)
{
fprintf (stderr, "cannot open in-memory db: %s\n",
sqlite3_errmsg (handle));
sqlite3_close (handle);
return -1;
}
spatialite_init_ex (handle, cache, 0);
ret =
sqlite3_exec (handle, "SELECT InitSpatialMetadata(1, 'WGS84')", NULL,
NULL, &err_msg);
if (ret != SQLITE_OK)
{
fprintf (stderr, "Unexpected InitSpatialMetadata result: %i, (%s)\n",
ret, err_msg);
sqlite3_free (err_msg);
return -2;
}
#ifdef ENABLE_LIBXML2 /* only if LIBXML2 is supported */
ret =
sqlite3_get_table (handle, "SELECT CreateStylingTables(1)", &results,
&rows, &columns, &err_msg);
if (ret != SQLITE_OK)
{
fprintf (stderr, "Error CreateStylingTables: %s\n", err_msg);
sqlite3_free (err_msg);
return -3;
}
if ((rows != 1) || (columns != 1))
{
sqlite3_free_table (results);
fprintf (stderr, "Unexpected row / column count: %i x %i\n", rows,
columns);
return -4;
}
if (strcmp (results[1 * columns + 0], "1") != 0)
{
fprintf (stderr, "Unexpected #0 result (got %s, expected 1)",
results[1 * columns + 0]);
sqlite3_free_table (results);
return -5;
}
sqlite3_free_table (results);
blob = load_blob ("empty.png", &blob_len);
if (blob == NULL)
return -6;
hexBlob = build_hex_blob (blob, blob_len);
free (blob);
if (hexBlob == NULL)
return -7;
sql =
sqlite3_mprintf ("SELECT RegisterExternalGraphic('url-A', x%Q)",
hexBlob);
ret = sqlite3_get_table (handle, sql, &results, &rows, &columns, &err_msg);
sqlite3_free (sql);
if (ret != SQLITE_OK)
{
fprintf (stderr, "Error RegisterExternalGraphic #1: %s\n", err_msg);
sqlite3_free (err_msg);
return -8;
}
if ((rows != 1) || (columns != 1))
{
sqlite3_free_table (results);
fprintf (stderr, "Unexpected row / column count: %i x %i\n", rows,
columns);
return -9;
}
if (strcmp (results[1 * columns + 0], "1") != 0)
{
fprintf (stderr, "Unexpected #1 result (got %s, expected 1)",
results[1 * columns + 0]);
sqlite3_free_table (results);
return -10;
}
sqlite3_free_table (results);
sql =
sqlite3_mprintf
("SELECT RegisterExternalGraphic('url-A', x%Q, 'title', 'abstract', 'file_name')",
hexBlob);
ret = sqlite3_get_table (handle, sql, &results, &rows, &columns, &err_msg);
free (hexBlob);
sqlite3_free (sql);
if (ret != SQLITE_OK)
{
fprintf (stderr, "Error RegisterExternalGraphic #2: %s\n", err_msg);
sqlite3_free (err_msg);
return -11;
}
if ((rows != 1) || (columns != 1))
{
sqlite3_free_table (results);
fprintf (stderr, "Unexpected row / column count: %i x %i\n", rows,
columns);
return -12;
}
if (strcmp (results[1 * columns + 0], "1") != 0)
{
fprintf (stderr, "Unexpected #2 result (got %s, expected 1)",
results[1 * columns + 0]);
sqlite3_free_table (results);
return -13;
}
sqlite3_free_table (results);
xml = load_xml ("thunderstorm_mild.svg", &len);
if (xml == NULL)
return -14;
gaiaXmlToBlob (cache, xml, len, 1, NULL, &blob, &blob_len, NULL, NULL);
free (xml);
if (blob == NULL)
{
fprintf (stderr, "this is not a well-formed XML !!!\n");
return -15;
}
hexBlob = build_hex_blob (blob, blob_len);
free (blob);
if (hexBlob == NULL)
return -16;
sql =
sqlite3_mprintf
("SELECT RegisterExternalGraphic('url-B', x%Q, 'title', 'abstract', 'file_name')",
hexBlob);
ret = sqlite3_get_table (handle, sql, &results, &rows, &columns, &err_msg);
sqlite3_free (sql);
if (ret != SQLITE_OK)
{
fprintf (stderr, "Error RegisterExternalGraphic #3: %s\n", err_msg);
sqlite3_free (err_msg);
return -17;
}
if ((rows != 1) || (columns != 1))
{
sqlite3_free_table (results);
fprintf (stderr, "Unexpected row / column count: %i x %i\n", rows,
columns);
return -18;
}
if (strcmp (results[1 * columns + 0], "1") != 0)
{
fprintf (stderr, "Unexpected #3 result (got %s, expected 1)",
results[1 * columns + 0]);
sqlite3_free_table (results);
return -19;
}
sqlite3_free_table (results);
sql =
sqlite3_mprintf ("SELECT RegisterExternalGraphic('url-B', x%Q)",
hexBlob);
ret = sqlite3_get_table (handle, sql, &results, &rows, &columns, &err_msg);
free (hexBlob);
sqlite3_free (sql);
if (ret != SQLITE_OK)
{
fprintf (stderr, "Error RegisterExternalGraphic #4: %s\n", err_msg);
sqlite3_free (err_msg);
return -20;
}
if ((rows != 1) || (columns != 1))
{
sqlite3_free_table (results);
fprintf (stderr, "Unexpected row / column count: %i x %i\n", rows,
columns);
return -21;
}
if (strcmp (results[1 * columns + 0], "1") != 0)
{
fprintf (stderr, "Unexpected #4 result (got %s, expected 1)",
results[1 * columns + 0]);
sqlite3_free_table (results);
return -22;
}
sqlite3_free_table (results);
ret =
sqlite3_exec (handle,
"CREATE TABLE table1 (id INTEGER PRIMARY KEY AUTOINCREMENT)",
NULL, NULL, &err_msg);
if (ret != SQLITE_OK)
{
fprintf (stderr, "Error Create Table table1: %s\n", err_msg);
sqlite3_free (err_msg);
return -23;
}
ret =
sqlite3_get_table (handle,
"SELECT AddGeometryColumn('table1', 'geom', 4326, 'POINT', 'XY')",
&results, &rows, &columns, &err_msg);
if (ret != SQLITE_OK)
{
fprintf (stderr, "Error AddGeometryColumn: %s\n", err_msg);
sqlite3_free (err_msg);
return -24;
}
if ((rows != 1) || (columns != 1))
{
sqlite3_free_table (results);
fprintf (stderr, "Unexpected row / column count: %i x %i\n", rows,
columns);
return -25;
}
if (strcmp (results[1 * columns + 0], "1") != 0)
{
fprintf (stderr, "Unexpected #5 result (got %s, expected 1)",
results[1 * columns + 0]);
sqlite3_free_table (results);
return -26;
}
sqlite3_free_table (results);
xml = load_xml ("stazioni_se.xml", &len);
if (xml == NULL)
return -27;
gaiaXmlToBlob (cache, xml, len, 1, NULL, &blob, &blob_len, NULL, NULL);
free (xml);
if (blob == NULL)
{
fprintf (stderr, "this is not a well-formed XML !!!\n");
return -28;
}
hexBlob = build_hex_blob (blob, blob_len);
free (blob);
if (hexBlob == NULL)
return -29;
sql =
sqlite3_mprintf
("SELECT RegisterVectorStyledLayer('table1', 'geom', x%Q)", hexBlob);
ret = sqlite3_get_table (handle, sql, &results, &rows, &columns, &err_msg);
sqlite3_free (sql);
if (ret != SQLITE_OK)
{
fprintf (stderr, "Error RegisterVectorStyledLayer #6: %s\n", err_msg);
sqlite3_free (err_msg);
return -30;
}
if ((rows != 1) || (columns != 1))
{
sqlite3_free_table (results);
fprintf (stderr, "Unexpected row / column count: %i x %i\n", rows,
columns);
return -31;
}
if (strcmp (results[1 * columns + 0], "1") != 0)
{
fprintf (stderr, "Unexpected #6 result (got %s, expected 1)",
results[1 * columns + 0]);
sqlite3_free_table (results);
return -32;
}
sqlite3_free_table (results);
sql =
sqlite3_mprintf
("SELECT RegisterVectorStyledLayer('table1', 'geom', 0, x%Q)", hexBlob);
free (hexBlob);
ret = sqlite3_get_table (handle, sql, &results, &rows, &columns, &err_msg);
sqlite3_free (sql);
if (ret != SQLITE_OK)
{
fprintf (stderr, "Error RegisterVectorStyledLayer #7: %s\n", err_msg);
sqlite3_free (err_msg);
return -33;
}
if ((rows != 1) || (columns != 1))
{
sqlite3_free_table (results);
fprintf (stderr, "Unexpected row / column count: %i x %i\n", rows,
columns);
return -34;
}
if (strcmp (results[1 * columns + 0], "1") != 0)
{
fprintf (stderr, "Unexpected #7 result (got %s, expected 1)",
results[1 * columns + 0]);
sqlite3_free_table (results);
return -35;
}
sqlite3_free_table (results);
xml = load_xml ("raster_se.xml", &len);
if (xml == NULL)
return -36;
gaiaXmlToBlob (cache, xml, len, 1, NULL, &blob, &blob_len, NULL, NULL);
free (xml);
if (blob == NULL)
{
fprintf (stderr, "this is not a well-formed XML !!!\n");
return -37;
}
hexBlob = build_hex_blob (blob, blob_len);
free (blob);
if (hexBlob == NULL)
return -38;
sql =
sqlite3_mprintf ("SELECT RegisterRasterStyledLayer('srtm', x%Q)",
hexBlob);
ret = sqlite3_get_table (handle, sql, &results, &rows, &columns, &err_msg);
sqlite3_free (sql);
if (ret != SQLITE_OK)
{
fprintf (stderr, "Error RegisterRasterStyledLayer #8: %s\n", err_msg);
sqlite3_free (err_msg);
return -39;
}
if ((rows != 1) || (columns != 1))
{
sqlite3_free_table (results);
fprintf (stderr, "Unexpected row / column count: %i x %i\n", rows,
columns);
return -40;
}
if (strcmp (results[1 * columns + 0], "1") != 0)
{
fprintf (stderr, "Unexpected #8 result (got %s, expected 1)",
results[1 * columns + 0]);
sqlite3_free_table (results);
return -41;
}
sqlite3_free_table (results);
sql =
sqlite3_mprintf ("SELECT RegisterRasterStyledLayer('srtm', 0, x%Q)",
hexBlob);
free (hexBlob);
ret = sqlite3_get_table (handle, sql, &results, &rows, &columns, &err_msg);
sqlite3_free (sql);
if (ret != SQLITE_OK)
{
fprintf (stderr, "Error RegisterRasterStyledLayer #9: %s\n", err_msg);
sqlite3_free (err_msg);
return -42;
}
if ((rows != 1) || (columns != 1))
{
sqlite3_free_table (results);
fprintf (stderr, "Unexpected row / column count: %i x %i\n", rows,
columns);
return -43;
}
if (strcmp (results[1 * columns + 0], "1") != 0)
{
fprintf (stderr, "Unexpected #9 result (got %s, expected 1)",
results[1 * columns + 0]);
sqlite3_free_table (results);
return -44;
}
sqlite3_free_table (results);
ret =
sqlite3_get_table (handle,
"SELECT RegisterStyledGroup('group', 'srtm')",
&results, &rows, &columns, &err_msg);
if (ret != SQLITE_OK)
{
fprintf (stderr, "Error RegisterStyledGroup #10: %s\n", err_msg);
sqlite3_free (err_msg);
return -45;
}
if ((rows != 1) || (columns != 1))
{
sqlite3_free_table (results);
fprintf (stderr, "Unexpected row / column count: %i x %i\n", rows,
columns);
return -46;
}
if (strcmp (results[1 * columns + 0], "1") != 0)
{
fprintf (stderr, "Unexpected #10 result (got %s, expected 1)",
results[1 * columns + 0]);
sqlite3_free_table (results);
return -47;
}
sqlite3_free_table (results);
ret =
sqlite3_get_table (handle,
"SELECT RegisterStyledGroup('group', 'table1', 'geom')",
&results, &rows, &columns, &err_msg);
if (ret != SQLITE_OK)
{
fprintf (stderr, "Error RegisterStyledGroup #11: %s\n", err_msg);
sqlite3_free (err_msg);
return -48;
}
if ((rows != 1) || (columns != 1))
{
sqlite3_free_table (results);
fprintf (stderr, "Unexpected row / column count: %i x %i\n", rows,
columns);
return -49;
}
if (strcmp (results[1 * columns + 0], "1") != 0)
{
fprintf (stderr, "Unexpected #12 result (got %s, expected 1)",
results[1 * columns + 0]);
sqlite3_free_table (results);
return -50;
}
sqlite3_free_table (results);
ret =
sqlite3_get_table (handle,
"SELECT RegisterStyledGroup('group', 'srtm', 4)",
&results, &rows, &columns, &err_msg);
if (ret != SQLITE_OK)
{
fprintf (stderr, "Error RegisterStyledGroup #13: %s\n", err_msg);
sqlite3_free (err_msg);
return -51;
}
if ((rows != 1) || (columns != 1))
{
sqlite3_free_table (results);
fprintf (stderr, "Unexpected row / column count: %i x %i\n", rows,
columns);
return -52;
}
if (strcmp (results[1 * columns + 0], "0") != 0)
{
fprintf (stderr, "Unexpected #13 result (got %s, expected 1)",
results[1 * columns + 0]);
sqlite3_free_table (results);
return -53;
}
sqlite3_free_table (results);
ret =
sqlite3_get_table (handle,
"SELECT RegisterStyledGroup('group', 'table1', 'geom', 1)",
&results, &rows, &columns, &err_msg);
if (ret != SQLITE_OK)
{
fprintf (stderr, "Error RegisterStyledGroup #14: %s\n", err_msg);
sqlite3_free (err_msg);
return -54;
}
if ((rows != 1) || (columns != 1))
{
sqlite3_free_table (results);
fprintf (stderr, "Unexpected row / column count: %i x %i\n", rows,
columns);
return -55;
}
if (strcmp (results[1 * columns + 0], "1") != 0)
{
fprintf (stderr, "Unexpected #14 result (got %s, expected 1)",
results[1 * columns + 0]);
sqlite3_free_table (results);
return -56;
}
sqlite3_free_table (results);
ret =
sqlite3_get_table (handle,
"SELECT SetStyledGroupInfos('group', 'title', 'abstract')",
&results, &rows, &columns, &err_msg);
if (ret != SQLITE_OK)
{
fprintf (stderr, "Error SetStyledGroupInfos #15: %s\n", err_msg);
sqlite3_free (err_msg);
return -57;
}
if ((rows != 1) || (columns != 1))
{
sqlite3_free_table (results);
fprintf (stderr, "Unexpected row / column count: %i x %i\n", rows,
columns);
return -58;
}
if (strcmp (results[1 * columns + 0], "1") != 0)
{
fprintf (stderr, "Unexpected #15 result (got %s, expected 1)",
results[1 * columns + 0]);
sqlite3_free_table (results);
return -59;
}
sqlite3_free_table (results);
ret =
sqlite3_get_table (handle,
"SELECT SetStyledGroupInfos('group-bis', 'title', 'abstract')",
&results, &rows, &columns, &err_msg);
if (ret != SQLITE_OK)
{
fprintf (stderr, "Error SetStyledGroupInfos #16: %s\n", err_msg);
sqlite3_free (err_msg);
return 60;
}
if ((rows != 1) || (columns != 1))
{
sqlite3_free_table (results);
fprintf (stderr, "Unexpected row / column count: %i x %i\n", rows,
columns);
return -61;
}
if (strcmp (results[1 * columns + 0], "1") != 0)
{
fprintf (stderr, "Unexpected #16 result (got %s, expected 1)",
results[1 * columns + 0]);
sqlite3_free_table (results);
return -62;
}
sqlite3_free_table (results);
xml = load_xml ("sld_sample.xml", &len);
if (xml == NULL)
return -63;
gaiaXmlToBlob (cache, xml, len, 1, NULL, &blob, &blob_len, NULL, NULL);
free (xml);
if (blob == NULL)
{
fprintf (stderr, "this is not a well-formed XML !!!\n");
return -64;
}
hexBlob = build_hex_blob (blob, blob_len);
free (blob);
if (hexBlob == NULL)
return -65;
sql = sqlite3_mprintf ("SELECT RegisterGroupStyle('group', x%Q)", hexBlob);
ret = sqlite3_get_table (handle, sql, &results, &rows, &columns, &err_msg);
sqlite3_free (sql);
if (ret != SQLITE_OK)
{
fprintf (stderr, "Error RegisterGroupStyle #1: %s\n", err_msg);
sqlite3_free (err_msg);
return -66;
}
if ((rows != 1) || (columns != 1))
{
sqlite3_free_table (results);
fprintf (stderr, "Unexpected row / column count: %i x %i\n", rows,
columns);
return -67;
}
if (strcmp (results[1 * columns + 0], "1") != 0)
{
fprintf (stderr, "Unexpected #1 result (got %s, expected 1)",
results[1 * columns + 0]);
sqlite3_free_table (results);
return -68;
}
sqlite3_free_table (results);
sql =
sqlite3_mprintf ("SELECT RegisterGroupStyle('group', 0, x%Q)", hexBlob);
free (hexBlob);
ret = sqlite3_get_table (handle, sql, &results, &rows, &columns, &err_msg);
sqlite3_free (sql);
if (ret != SQLITE_OK)
{
fprintf (stderr, "Error RegisterGroupStyle #2: %s\n", err_msg);
sqlite3_free (err_msg);
return -69;
}
if ((rows != 1) || (columns != 1))
{
sqlite3_free_table (results);
fprintf (stderr, "Unexpected row / column count: %i x %i\n", rows,
columns);
return -70;
}
if (strcmp (results[1 * columns + 0], "1") != 0)
{
fprintf (stderr, "Unexpected #2 result (got %s, expected 1)",
results[1 * columns + 0]);
sqlite3_free_table (results);
return -71;
}
sqlite3_free_table (results);
#endif
ret = sqlite3_close (handle);
if (ret != SQLITE_OK)
{
fprintf (stderr, "sqlite3_close() error: %s\n",
sqlite3_errmsg (handle));
return -57;
}
spatialite_cleanup_ex (cache);
spatialite_shutdown ();
return 0;
}
/*
** Statement pStmt currently points to a row in the amatch data table. This
** function allocates and populates a amatch_rule structure according to
** the content of the row.
**
** If successful, *ppRule is set to point to the new object and SQLITE_OK
** is returned. Otherwise, *ppRule is zeroed, *pzErr may be set to point
** to an error message and an SQLite error code returned.
*/
static int amatchLoadOneRule(
amatch_vtab *p, /* Fuzzer virtual table handle */
sqlite3_stmt *pStmt, /* Base rule on statements current row */
amatch_rule **ppRule, /* OUT: New rule object */
char **pzErr /* OUT: Error message */
){
sqlite3_int64 iLang = sqlite3_column_int64(pStmt, 0);
const char *zFrom = (const char *)sqlite3_column_text(pStmt, 1);
const char *zTo = (const char *)sqlite3_column_text(pStmt, 2);
amatch_cost rCost = sqlite3_column_int(pStmt, 3);
int rc = SQLITE_OK; /* Return code */
int nFrom; /* Size of string zFrom, in bytes */
int nTo; /* Size of string zTo, in bytes */
amatch_rule *pRule = 0; /* New rule object to return */
if( zFrom==0 ) zFrom = "";
if( zTo==0 ) zTo = "";
nFrom = (int)strlen(zFrom);
nTo = (int)strlen(zTo);
/* Silently ignore null transformations */
if( strcmp(zFrom, zTo)==0 ){
if( zFrom[0]=='?' && zFrom[1]==0 ){
if( p->rSub==0 || p->rSub>rCost ) p->rSub = rCost;
}
*ppRule = 0;
return SQLITE_OK;
}
if( rCost<=0 || rCost>AMATCH_MX_COST ){
*pzErr = sqlite3_mprintf("%s: cost must be between 1 and %d",
p->zClassName, AMATCH_MX_COST
);
rc = SQLITE_ERROR;
}else
if( nFrom>AMATCH_MX_LENGTH || nTo>AMATCH_MX_LENGTH ){
*pzErr = sqlite3_mprintf("%s: maximum string length is %d",
p->zClassName, AMATCH_MX_LENGTH
);
rc = SQLITE_ERROR;
}else
if( iLang<0 || iLang>AMATCH_MX_LANGID ){
*pzErr = sqlite3_mprintf("%s: iLang must be between 0 and %d",
p->zClassName, AMATCH_MX_LANGID
);
rc = SQLITE_ERROR;
}else
if( strcmp(zFrom,"")==0 && strcmp(zTo,"?")==0 ){
if( p->rIns==0 || p->rIns>rCost ) p->rIns = rCost;
}else
if( strcmp(zFrom,"?")==0 && strcmp(zTo,"")==0 ){
if( p->rDel==0 || p->rDel>rCost ) p->rDel = rCost;
}else
{
pRule = sqlite3_malloc( sizeof(*pRule) + nFrom + nTo );
if( pRule==0 ){
rc = SQLITE_NOMEM;
}else{
memset(pRule, 0, sizeof(*pRule));
pRule->zFrom = &pRule->zTo[nTo+1];
pRule->nFrom = (amatch_len)nFrom;
memcpy(pRule->zFrom, zFrom, nFrom+1);
memcpy(pRule->zTo, zTo, nTo+1);
pRule->nTo = (amatch_len)nTo;
pRule->rCost = rCost;
pRule->iLang = (int)iLang;
}
}
*ppRule = pRule;
return rc;
}
int cangjie_get_characters_by_shortcode(Cangjie *cj,
char *input_code,
CangjieCharList **l) {
CangjieCharList *tmp = NULL;
sqlite3_stmt *stmt;
int ret;
char *query;
if (input_code == NULL || strlen(input_code) != 1) {
return CANGJIE_INVALID;
}
query = sqlite3_mprintf(cj->shortcode_query, 0, input_code);
if (query == NULL) {
return CANGJIE_NOMEM;
}
ret = sqlite3_prepare_v2(cj->db, query, -1, &stmt, 0);
if (ret != SQLITE_OK) {
// FIXME: Unhandled error codes
return ret;
}
sqlite3_free(query);
while (1) {
ret = sqlite3_step(stmt);
if (ret == SQLITE_ROW) {
char *chchar = (char *)sqlite3_column_text(stmt, 0);
uint32_t frequency = (uint32_t)sqlite3_column_int(stmt, 2);
CangjieChar *c;
int ret = cangjie_char_new(&c, chchar, input_code, frequency);
if (ret != CANGJIE_OK) {
return ret;
}
ret = cangjie_char_list_prepend(&tmp, c);
if (ret != CANGJIE_OK) {
return ret;
}
} else if(ret == SQLITE_DONE) {
// All rows finished
sqlite3_finalize(stmt);
break;
} else {
// Some error encountered
return CANGJIE_DBERROR;
}
}
if (tmp == NULL) {
return CANGJIE_NOCHARS;
}
*l = tmp;
return CANGJIE_OK;
}
static void midorator_history_remove_item_cb(KatzeArray *a, const char *item, sqlite3 *db) {
char *cmd = sqlite3_mprintf("DELETE FROM midorator_command_history WHERE command = '%q';", item);
sqlite3_exec(db, cmd, NULL, NULL, NULL);
sqlite3_free(cmd);
}
SQLITE_EXTENSION_INIT1
#endif
#include "fts3_hash.h"
#include "fts3_tokenizer.h"
#include <assert.h>
/*
** Implementation of the SQL scalar function for accessing the underlying
** hash table. This function may be called as follows:
**
** SELECT <function-name>(<key-name>);
** SELECT <function-name>(<key-name>, <pointer>);
**
** where <function-name> is the name passed as the second argument
** to the sqlite3Fts3InitHashTable() function (e.g. 'fts3_tokenizer').
**
** If the <pointer> argument is specified, it must be a blob value
** containing a pointer to be stored as the hash data corresponding
** to the string <key-name>. If <pointer> is not specified, then
** the string <key-name> must already exist in the has table. Otherwise,
** an error is returned.
**
** Whether or not the <pointer> argument is specified, the value returned
** is a blob containing the pointer stored as the hash data corresponding
** to string <key-name> (after the hash-table is updated, if applicable).
*/
static void scalarFunc(
sqlite3_context *context,
int argc,
sqlite3_value **argv
){
fts3Hash *pHash;
void *pPtr = 0;
const unsigned char *zName;
int nName;
assert( argc==1 || argc==2 );
pHash = (fts3Hash *)sqlite3_user_data(context);
zName = sqlite3_value_text(argv[0]);
nName = sqlite3_value_bytes(argv[0])+1;
if( argc==2 ){
void *pOld;
int n = sqlite3_value_bytes(argv[1]);
if( n!=sizeof(pPtr) ){
sqlite3_result_error(context, "argument type mismatch", -1);
return;
}
pPtr = *(void **)sqlite3_value_blob(argv[1]);
pOld = sqlite3Fts3HashInsert(pHash, (void *)zName, nName, pPtr);
if( pOld==pPtr ){
sqlite3_result_error(context, "out of memory", -1);
return;
}
}else{
pPtr = sqlite3Fts3HashFind(pHash, zName, nName);
if( !pPtr ){
char *zErr = sqlite3_mprintf("unknown tokenizer: %s", zName);
sqlite3_result_error(context, zErr, -1);
sqlite3_free(zErr);
return;
}
}
sqlite3_result_blob(context, (void *)&pPtr, sizeof(pPtr), SQLITE_TRANSIENT);
}
static int
pkg_update_full(const char *repofile, struct pkg_repo *repo, time_t *mtime)
{
char repofile_unchecked[MAXPATHLEN];
int fd = -1, rc = EPKG_FATAL;
sqlite3 *sqlite = NULL;
char *req = NULL;
char *bad_abis = NULL;
const char *myarch;
snprintf(repofile_unchecked, sizeof(repofile_unchecked),
"%s.unchecked", repofile);
/* If the repo.sqlite file exists, test that we can write to
it. If it doesn't exist, assume we can create it */
if (eaccess(repofile, F_OK) == 0 && eaccess(repofile, W_OK) == -1) {
pkg_emit_error("Insufficient privilege to update %s\n",
repofile);
rc = EPKG_ENOACCESS;
goto cleanup;
}
if ((fd = repo_fetch_remote_tmp(repo, repo_db_archive, "txz", mtime, &rc)) == -1) {
goto cleanup;
}
if ((rc = repo_archive_extract_file(fd, repo_db_file, repofile_unchecked, repo->pubkey, -1)) != EPKG_OK) {
goto cleanup;
}
/* check if the repository is for valid architecture */
if (access(repofile_unchecked, R_OK|W_OK) == -1) {
pkg_emit_error("Archive file does not have repo.sqlite file");
rc = EPKG_FATAL;
goto cleanup;
}
if (sqlite3_open(repofile_unchecked, &sqlite) != SQLITE_OK) {
unlink(repofile_unchecked);
pkg_emit_error("Corrupted repository");
rc = EPKG_FATAL;
goto cleanup;
}
pkg_config_string(PKG_CONFIG_ABI, &myarch);
req = sqlite3_mprintf("select group_concat(arch, ', ') from "
"(select distinct arch from packages "
"where arch not GLOB '%q')", myarch);
if (get_sql_string(sqlite, req, &bad_abis) != EPKG_OK) {
sqlite3_free(req);
pkg_emit_error("Unable to query repository");
rc = EPKG_FATAL;
sqlite3_close(sqlite);
goto cleanup;
}
if (bad_abis != NULL) {
pkg_emit_error("At least one of the packages provided by "
"the repository is not compatible with your ABI:\n"
" Your ABI: %s\n"
" Incompatible ABIs found: %s",
myarch, bad_abis);
rc = EPKG_FATAL;
sqlite3_close(sqlite);
goto cleanup;
}
/* register the packagesite */
if (pkg_register_repo(repo, sqlite) != EPKG_OK) {
sqlite3_close(sqlite);
goto cleanup;
}
sqlite3_close(sqlite);
sqlite3_shutdown();
if (rename(repofile_unchecked, repofile) != 0) {
pkg_emit_errno("rename", "");
rc = EPKG_FATAL;
goto cleanup;
}
if ((rc = remote_add_indexes(pkg_repo_ident(repo))) != EPKG_OK)
goto cleanup;
rc = EPKG_OK;
cleanup:
if (fd != -1)
(void)close(fd);
return (rc);
}
static int
vspidx_filter (sqlite3_vtab_cursor * pCursor, int idxNum, const char *idxStr,
int argc, sqlite3_value ** argv)
{
/* setting up a cursor filter */
char *db_prefix = NULL;
char *table_name = NULL;
char *geom_column;
char *xtable = NULL;
char *xgeom = NULL;
char *idx_name;
char *idx_nameQ;
char *sql_statement;
gaiaGeomCollPtr geom = NULL;
int ok_table = 0;
int ok_geom = 0;
const unsigned char *blob;
int size;
int exists;
int ret;
sqlite3_stmt *stmt;
float minx;
float miny;
float maxx;
float maxy;
double tic;
double tic2;
VirtualSpatialIndexCursorPtr cursor =
(VirtualSpatialIndexCursorPtr) pCursor;
VirtualSpatialIndexPtr spidx = (VirtualSpatialIndexPtr) cursor->pVtab;
if (idxStr)
idxStr = idxStr; /* unused arg warning suppression */
cursor->eof = 1;
if (idxNum == 1 && argc == 3)
{
/* retrieving the Table/Column/MBR params */
if (sqlite3_value_type (argv[0]) == SQLITE_TEXT)
{
char *tn = (char *) sqlite3_value_text (argv[0]);
vspidx_parse_table_name (tn, &db_prefix, &table_name);
ok_table = 1;
}
if (sqlite3_value_type (argv[1]) == SQLITE_TEXT)
{
geom_column = (char *) sqlite3_value_text (argv[1]);
ok_geom = 1;
}
if (sqlite3_value_type (argv[2]) == SQLITE_BLOB)
{
blob = sqlite3_value_blob (argv[2]);
size = sqlite3_value_bytes (argv[2]);
geom = gaiaFromSpatiaLiteBlobWkb (blob, size);
}
if (ok_table && ok_geom && geom)
;
else
{
/* invalid args */
goto stop;
}
}
if (idxNum == 2 && argc == 2)
{
/* retrieving the Table/MBR params */
if (sqlite3_value_type (argv[0]) == SQLITE_TEXT)
{
char *tn = (char *) sqlite3_value_text (argv[0]);
vspidx_parse_table_name (tn, &db_prefix, &table_name);
ok_table = 1;
}
if (sqlite3_value_type (argv[1]) == SQLITE_BLOB)
{
blob = sqlite3_value_blob (argv[1]);
size = sqlite3_value_bytes (argv[1]);
geom = gaiaFromSpatiaLiteBlobWkb (blob, size);
}
if (ok_table && geom)
;
else
{
/* invalid args */
goto stop;
}
}
/* checking if the corresponding R*Tree exists */
if (ok_geom)
exists =
vspidx_check_rtree (spidx->db, db_prefix, table_name, geom_column,
&xtable, &xgeom);
else
exists =
vspidx_find_rtree (spidx->db, db_prefix, table_name, &xtable,
&xgeom);
if (!exists)
goto stop;
/* building the RTree query */
idx_name = sqlite3_mprintf ("idx_%s_%s", xtable, xgeom);
idx_nameQ = gaiaDoubleQuotedSql (idx_name);
if (db_prefix == NULL)
{
sql_statement = sqlite3_mprintf ("SELECT pkid FROM \"%s\" WHERE "
"xmin <= ? AND xmax >= ? AND ymin <= ? AND ymax >= ?",
idx_nameQ);
}
else
{
char *quoted_db = gaiaDoubleQuotedSql (db_prefix);
sql_statement =
sqlite3_mprintf ("SELECT pkid FROM \"%s\".\"%s\" WHERE "
"xmin <= ? AND xmax >= ? AND ymin <= ? AND ymax >= ?",
quoted_db, idx_nameQ);
free (quoted_db);
}
free (idx_nameQ);
sqlite3_free (idx_name);
ret =
sqlite3_prepare_v2 (spidx->db, sql_statement, strlen (sql_statement),
&stmt, NULL);
sqlite3_free (sql_statement);
if (ret != SQLITE_OK)
goto stop;
/* binding stmt params [MBR] */
gaiaMbrGeometry (geom);
/* adjusting the MBR so to compensate for DOUBLE/FLOAT truncations */
minx = (float) (geom->MinX);
miny = (float) (geom->MinY);
maxx = (float) (geom->MaxX);
maxy = (float) (geom->MaxY);
tic = fabs (geom->MinX - minx);
tic2 = fabs (geom->MinY - miny);
if (tic2 > tic)
tic = tic2;
tic2 = fabs (geom->MaxX - maxx);
if (tic2 > tic)
tic = tic2;
tic2 = fabs (geom->MaxY - maxy);
if (tic2 > tic)
tic = tic2;
tic *= 2.0;
sqlite3_bind_double (stmt, 1, geom->MaxX + tic);
sqlite3_bind_double (stmt, 2, geom->MinX - tic);
sqlite3_bind_double (stmt, 3, geom->MaxY + tic);
sqlite3_bind_double (stmt, 4, geom->MinY - tic);
cursor->stmt = stmt;
cursor->eof = 0;
/* fetching the first ResultSet's row */
ret = sqlite3_step (cursor->stmt);
if (ret == SQLITE_ROW)
cursor->CurrentRowId = sqlite3_column_int64 (cursor->stmt, 0);
else
cursor->eof = 1;
stop:
if (geom)
gaiaFreeGeomColl (geom);
if (xtable)
free (xtable);
if (xgeom)
free (xgeom);
if (db_prefix)
free (db_prefix);
if (table_name)
free (table_name);
return SQLITE_OK;
}
static int
vspidx_check_view_rtree (sqlite3 * sqlite, const char *table_name,
const char *geom_column, char **real_table,
char **real_geom)
{
/* checks if the required RTree is actually defined - SpatialView */
sqlite3_stmt *stmt;
char *sql_statement;
int ret;
int count = 0;
char *rt = NULL;
char *rg = NULL;
/* testing if views_geometry_columns exists */
sql_statement = sqlite3_mprintf ("SELECT tbl_name FROM sqlite_master "
"WHERE type = 'table' AND tbl_name = 'views_geometry_columns'");
ret =
sqlite3_prepare_v2 (sqlite, sql_statement, strlen (sql_statement),
&stmt, NULL);
sqlite3_free (sql_statement);
if (ret != SQLITE_OK)
return 0;
while (1)
{
/* scrolling the result set rows */
ret = sqlite3_step (stmt);
if (ret == SQLITE_DONE)
break; /* end of result set */
if (ret == SQLITE_ROW)
count++;
}
sqlite3_finalize (stmt);
if (count != 1)
return 0;
count = 0;
/* attempting to find the RTree Geometry Column */
sql_statement =
sqlite3_mprintf ("SELECT a.f_table_name, a.f_geometry_column "
"FROM views_geometry_columns AS a "
"JOIN geometry_columns AS b ON ("
"Upper(a.f_table_name) = Upper(b.f_table_name) AND "
"Upper(a.f_geometry_column) = Upper(b.f_geometry_column)) "
"WHERE Upper(a.view_name) = Upper(%Q) "
"AND Upper(a.view_geometry) = Upper(%Q) AND b.spatial_index_enabled = 1",
table_name, geom_column);
ret =
sqlite3_prepare_v2 (sqlite, sql_statement, strlen (sql_statement),
&stmt, NULL);
sqlite3_free (sql_statement);
if (ret != SQLITE_OK)
return 0;
while (1)
{
/* scrolling the result set rows */
ret = sqlite3_step (stmt);
if (ret == SQLITE_DONE)
break; /* end of result set */
if (ret == SQLITE_ROW)
{
const char *v = (const char *) sqlite3_column_text (stmt, 0);
int len = sqlite3_column_bytes (stmt, 0);
if (rt)
free (rt);
rt = malloc (len + 1);
strcpy (rt, v);
v = (const char *) sqlite3_column_text (stmt, 1);
len = sqlite3_column_bytes (stmt, 1);
if (rg)
free (rg);
rg = malloc (len + 1);
strcpy (rg, v);
count++;
}
}
sqlite3_finalize (stmt);
if (count != 1)
return 0;
*real_table = rt;
*real_geom = rg;
return 1;
}
static int
vspidx_find_rtree (sqlite3 * sqlite, const char *db_prefix,
const char *table_name, char **real_table, char **real_geom)
{
/* attempts to find the corresponding RTree Geometry Column */
sqlite3_stmt *stmt;
char *sql_statement;
int ret;
int count = 0;
char *rt = NULL;
char *rg = NULL;
if (db_prefix == NULL)
{
sql_statement =
sqlite3_mprintf
("SELECT f_table_name, f_geometry_column FROM geometry_columns "
"WHERE Upper(f_table_name) = Upper(%Q) AND spatial_index_enabled = 1",
table_name);
}
else
{
char *quoted_db = gaiaDoubleQuotedSql (db_prefix);
sql_statement =
sqlite3_mprintf
("SELECT f_table_name, f_geometry_column FROM \"%s\".geometry_columns "
"WHERE Upper(f_table_name) = Upper(%Q) AND spatial_index_enabled = 1",
quoted_db, table_name);
free (quoted_db);
}
ret =
sqlite3_prepare_v2 (sqlite, sql_statement, strlen (sql_statement),
&stmt, NULL);
sqlite3_free (sql_statement);
if (ret != SQLITE_OK)
return 0;
while (1)
{
/* scrolling the result set rows */
ret = sqlite3_step (stmt);
if (ret == SQLITE_DONE)
break; /* end of result set */
if (ret == SQLITE_ROW)
{
const char *v = (const char *) sqlite3_column_text (stmt, 0);
int len = sqlite3_column_bytes (stmt, 0);
if (rt)
free (rt);
rt = malloc (len + 1);
strcpy (rt, v);
v = (const char *) sqlite3_column_text (stmt, 1);
len = sqlite3_column_bytes (stmt, 1);
if (rg)
free (rg);
rg = malloc (len + 1);
strcpy (rg, v);
count++;
}
}
sqlite3_finalize (stmt);
if (count != 1)
return vspidx_find_view_rtree (sqlite, db_prefix, table_name,
real_table, real_geom);
else
{
*real_table = rt;
*real_geom = rg;
}
return 1;
}
static int
vspidx_find_view_rtree (sqlite3 * sqlite, const char *db_prefix,
const char *table_name, char **real_table,
char **real_geom)
{
/* attempts to find the corresponding RTree Geometry Column - SpatialView */
sqlite3_stmt *stmt;
char *sql_statement;
int ret;
int count = 0;
char *rt = NULL;
char *rg = NULL;
/* testing if views_geometry_columns exists */
if (db_prefix == NULL)
{
sql_statement = sqlite3_mprintf ("SELECT tbl_name FROM sqlite_master "
"WHERE type = 'table' AND tbl_name = 'views_geometry_columns'");
}
else
{
char *quoted_db = gaiaDoubleQuotedSql (db_prefix);
sql_statement =
sqlite3_mprintf ("SELECT tbl_name FROM \"%s\".sqlite_master "
"WHERE type = 'table' AND tbl_name = 'views_geometry_columns'",
quoted_db);
free (quoted_db);
}
ret =
sqlite3_prepare_v2 (sqlite, sql_statement, strlen (sql_statement),
&stmt, NULL);
sqlite3_free (sql_statement);
if (ret != SQLITE_OK)
return 0;
while (1)
{
/* scrolling the result set rows */
ret = sqlite3_step (stmt);
if (ret == SQLITE_DONE)
break; /* end of result set */
if (ret == SQLITE_ROW)
count++;
}
sqlite3_finalize (stmt);
if (count != 1)
return 0;
count = 0;
/* attempting to find the RTree Geometry Column */
if (db_prefix == NULL)
{
sql_statement =
sqlite3_mprintf ("SELECT a.f_table_name, a.f_geometry_column "
"FROM views_geometry_columns AS a "
"JOIN geometry_columns AS b ON ("
"Upper(a.f_table_name) = Upper(b.f_table_name) AND "
"Upper(a.f_geometry_column) = Upper(b.f_geometry_column)) "
"WHERE Upper(a.view_name) = Upper(%Q) AND b.spatial_index_enabled = 1",
table_name);
}
else
{
char *quoted_db = gaiaDoubleQuotedSql (db_prefix);
sql_statement =
sqlite3_mprintf ("SELECT a.f_table_name, a.f_geometry_column "
"FROM \"%s\".views_geometry_columns AS a "
"JOIN \"%s\".geometry_columns AS b ON ("
"Upper(a.f_table_name) = Upper(b.f_table_name) AND "
"Upper(a.f_geometry_column) = Upper(b.f_geometry_column)) "
"WHERE Upper(a.view_name) = Upper(%Q) AND b.spatial_index_enabled = 1",
quoted_db, quoted_db, table_name);
free (quoted_db);
}
ret =
sqlite3_prepare_v2 (sqlite, sql_statement, strlen (sql_statement),
&stmt, NULL);
sqlite3_free (sql_statement);
if (ret != SQLITE_OK)
return 0;
while (1)
{
/* scrolling the result set rows */
ret = sqlite3_step (stmt);
if (ret == SQLITE_DONE)
break; /* end of result set */
if (ret == SQLITE_ROW)
{
const char *v = (const char *) sqlite3_column_text (stmt, 0);
int len = sqlite3_column_bytes (stmt, 0);
if (rt)
free (rt);
rt = malloc (len + 1);
strcpy (rt, v);
v = (const char *) sqlite3_column_text (stmt, 1);
len = sqlite3_column_bytes (stmt, 1);
if (rg)
free (rg);
rg = malloc (len + 1);
strcpy (rg, v);
count++;
}
}
sqlite3_finalize (stmt);
if (count != 1)
return 0;
*real_table = rt;
*real_geom = rg;
return 1;
}
int flexi_init(sqlite3 *db,
char **pzErrMsg,
const sqlite3_api_routines *pApi, FlexiliteContext_t **pDBCtx)
{
int result;
*pDBCtx = (FlexiliteContext_t *) sqlite3_malloc(sizeof(FlexiliteContext_t));
FlexiliteContext_t *pCtx = *pDBCtx;
pCtx->db = db;
pCtx->L = lua_newstate(lua_alloc_handler, pDBCtx);
if (pCtx->L == nullptr)
{
*pzErrMsg = sqlite3_mprintf("Flexilite: cannot initialize LuaJIT");
result = SQLITE_ERROR;
goto ONERROR;
}
lua_gc(pCtx->L, LUA_GCSTOP, 0);
luaL_openlibs(pCtx->L);
lua_gc(pCtx->L, LUA_GCRESTART, -1);
/*
* Open other Lua modules implemented in C
*/
luaopen_lfs(pCtx->L);
luaopen_base64(pCtx->L);
luaopen_lsqlite3(pCtx->L);
luaopen_cjson(pCtx->L);
luaopen_cjson_safe(pCtx->L);
// Create context, by passing SQLite db connection
if (luaL_dostring(pCtx->L, "return require 'sqlite3'"))
{
*pzErrMsg = sqlite3_mprintf("Flexilite require sqlite3: %s\n", lua_tostring(pCtx->L, -1));
result = SQLITE_ERROR;
goto ONERROR;
}
lua_getfield(pCtx->L, -1, "open_ptr");
lua_pushlightuserdata(pCtx->L, db);
if (lua_pcall(pCtx->L, 1, 1, 0))
{
*pzErrMsg = sqlite3_mprintf("Flexilite sqlite.open_ptr: %s\n", lua_tostring(pCtx->L, -1));
result = SQLITE_ERROR;
goto ONERROR;
}
pCtx->SQLiteConn_Index = luaL_ref(pCtx->L, LUA_REGISTRYINDEX);
// Create context, by passing SQLite db connection
if (luaL_dostring(pCtx->L,
"package.cpath = package.cpath .. ';./libFlexilite.dll'; return require ('DBContext')"))
{
*pzErrMsg = sqlite3_mprintf("Flexilite require DBContext: %s\n", lua_tostring(pCtx->L, -1));
result = SQLITE_ERROR;
goto ONERROR;
}
lua_rawgeti(pCtx->L, LUA_REGISTRYINDEX, pCtx->SQLiteConn_Index);
if (lua_pcall(pCtx->L, 1, 1, 0))
{
*pzErrMsg = sqlite3_mprintf("Flexilite DBContext(db): %s\n", lua_tostring(pCtx->L, -1));
result = SQLITE_ERROR;
goto ONERROR;
}
pCtx->DBContext_Index = luaL_ref(pCtx->L, LUA_REGISTRYINDEX);
result = SQLITE_OK;
goto EXIT;
ONERROR:
flexi_free(pCtx);
*pDBCtx = nullptr;
EXIT:
return result;
}
/*
** Implementation of a special SQL scalar function for testing tokenizers
** designed to be used in concert with the Tcl testing framework. This
** function must be called with two arguments:
**
** SELECT <function-name>(<key-name>, <input-string>);
** SELECT <function-name>(<key-name>, <pointer>);
**
** where <function-name> is the name passed as the second argument
** to the sqlite3Fts3InitHashTable() function (e.g. 'fts3_tokenizer')
** concatenated with the string '_test' (e.g. 'fts3_tokenizer_test').
**
** The return value is a string that may be interpreted as a Tcl
** list. For each token in the <input-string>, three elements are
** added to the returned list. The first is the token position, the
** second is the token text (folded, stemmed, etc.) and the third is the
** substring of <input-string> associated with the token. For example,
** using the built-in "simple" tokenizer:
**
** SELECT fts_tokenizer_test('simple', 'I don't see how');
**
** will return the string:
**
** "{0 i I 1 dont don't 2 see see 3 how how}"
**
*/
static void testFunc(
sqlite3_context *context,
int argc,
sqlite3_value **argv
){
Fts3Hash *pHash;
sqlite3_tokenizer_module *p;
sqlite3_tokenizer *pTokenizer = 0;
sqlite3_tokenizer_cursor *pCsr = 0;
const char *zErr = 0;
const char *zName;
int nName;
const char *zInput;
int nInput;
const char *zArg = 0;
const char *zToken;
int nToken;
int iStart;
int iEnd;
int iPos;
Tcl_Obj *pRet;
assert( argc==2 || argc==3 );
nName = sqlite3_value_bytes(argv[0]);
zName = (const char *)sqlite3_value_text(argv[0]);
nInput = sqlite3_value_bytes(argv[argc-1]);
zInput = (const char *)sqlite3_value_text(argv[argc-1]);
if( argc==3 ){
zArg = (const char *)sqlite3_value_text(argv[1]);
}
pHash = (Fts3Hash *)sqlite3_user_data(context);
p = (sqlite3_tokenizer_module *)sqlite3Fts3HashFind(pHash, zName, nName+1);
if( !p ){
char *zErr = sqlite3_mprintf("unknown tokenizer: %s", zName);
sqlite3_result_error(context, zErr, -1);
sqlite3_free(zErr);
return;
}
pRet = Tcl_NewObj();
Tcl_IncrRefCount(pRet);
if( SQLITE_OK!=p->xCreate(zArg ? 1 : 0, &zArg, &pTokenizer) ){
zErr = "error in xCreate()";
goto finish;
}
pTokenizer->pModule = p;
if( SQLITE_OK!=p->xOpen(pTokenizer, zInput, nInput, &pCsr) ){
zErr = "error in xOpen()";
goto finish;
}
pCsr->pTokenizer = pTokenizer;
while( SQLITE_OK==p->xNext(pCsr, &zToken, &nToken, &iStart, &iEnd, &iPos) ){
Tcl_ListObjAppendElement(0, pRet, Tcl_NewIntObj(iPos));
Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj(zToken, nToken));
zToken = &zInput[iStart];
nToken = iEnd-iStart;
Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj(zToken, nToken));
}
if( SQLITE_OK!=p->xClose(pCsr) ){
zErr = "error in xClose()";
goto finish;
}
if( SQLITE_OK!=p->xDestroy(pTokenizer) ){
zErr = "error in xDestroy()";
goto finish;
}
finish:
if( zErr ){
sqlite3_result_error(context, zErr, -1);
}else{
sqlite3_result_text(context, Tcl_GetString(pRet), -1, SQLITE_TRANSIENT);
}
Tcl_DecrRefCount(pRet);
}
int
pkg_update(struct pkg_repo *repo, bool force)
{
char repofile[MAXPATHLEN];
const char *dbdir = NULL;
struct stat st;
time_t t = 0;
sqlite3 *sqlite = NULL;
char *req = NULL;
int64_t res;
sqlite3_initialize();
if (pkg_config_string(PKG_CONFIG_DBDIR, &dbdir) != EPKG_OK) {
pkg_emit_error("Cant get dbdir config entry");
return (EPKG_FATAL);
}
snprintf(repofile, sizeof(repofile), "%s/%s.sqlite", dbdir, pkg_repo_name(repo));
if (stat(repofile, &st) != -1)
t = force ? 0 : st.st_mtime;
if (t != 0) {
if (sqlite3_open(repofile, &sqlite) != SQLITE_OK) {
pkg_emit_error("Unable to open local database");
return (EPKG_FATAL);
}
if (get_pragma(sqlite, "SELECT count(name) FROM sqlite_master "
"WHERE type='table' AND name='repodata';", &res) != EPKG_OK) {
pkg_emit_error("Unable to query repository");
sqlite3_close(sqlite);
return (EPKG_FATAL);
}
if (res != 1) {
t = 0;
if (sqlite != NULL) {
sqlite3_close(sqlite);
sqlite = NULL;
}
}
}
if (t != 0) {
req = sqlite3_mprintf("select count(key) from repodata "
"WHERE key = \"packagesite\" and value = '%q'", pkg_repo_url(repo));
if (get_pragma(sqlite, req, &res) != EPKG_OK) {
sqlite3_free(req);
pkg_emit_error("Unable to query repository");
sqlite3_close(sqlite);
return (EPKG_FATAL);
}
sqlite3_free(req);
if (res != 1) {
t = 0;
if (sqlite != NULL) {
sqlite3_close(sqlite);
sqlite = NULL;
}
unlink(repofile);
}
}
res = pkg_update_incremental(repofile, repo, &t);
if (res != EPKG_OK && res != EPKG_UPTODATE) {
pkg_emit_notice("No digest falling back on legacy catalog format");
/* Still try to do full upgrade */
if ((res = pkg_update_full(repofile, repo, &t)) != EPKG_OK)
goto cleanup;
}
res = EPKG_OK;
cleanup:
/* Set mtime from http request if possible */
if (t != 0) {
struct timeval ftimes[2] = {
{
.tv_sec = t,
.tv_usec = 0
},
{
.tv_sec = t,
.tv_usec = 0
}
};
int cangjie_get_characters(Cangjie *cj,
char *input_code,
CangjieCharList **l) {
CangjieCharList *tmp = NULL;
sqlite3_stmt *stmt;
char *cj_query;
char *query_code;
char *star_ptr;
char *query;
int ret;
if (input_code == NULL || strlen(input_code) == 0 || strlen(input_code) > 5) {
return CANGJIE_INVALID;
}
if (input_code[0] == '*' || input_code[strlen(input_code) - 1] == '*') {
return CANGJIE_INVALID;
}
// Start with the Cangjie instance's cj_query
cj_query = calloc(strlen(cj->cj_query) + MAX_LEN_CODE_QUERY + 1,
sizeof(char));
if (cj_query == NULL) {
return CANGJIE_NOMEM;
}
strcpy(cj_query, cj->cj_query);
query_code = calloc(6, sizeof(char));
if (query_code == NULL) {
free(cj_query);
return CANGJIE_NOMEM;
}
strncpy(query_code, input_code, 5);
// Handle optional wildcards
star_ptr = strchr(query_code, '*');
if (star_ptr == NULL) {
strcat(cj_query, "AND code = '%q';");
} else {
strcat(cj_query, "AND code GLOB '%q';");
}
query = sqlite3_mprintf(cj_query, cj->version, query_code);
free(query_code);
free(cj_query);
if (query == NULL) {
return CANGJIE_NOMEM;
}
ret = sqlite3_prepare_v2(cj->db, query, -1, &stmt, 0);
if (ret != SQLITE_OK) {
// FIXME: Unhandled error codes
return ret;
}
sqlite3_free(query);
while (1) {
ret = sqlite3_step(stmt);
if (ret == SQLITE_ROW) {
char *chchar = (char *)sqlite3_column_text(stmt, 0);
char *code = (char *)sqlite3_column_text(stmt, 1);
uint32_t frequency = (uint32_t)sqlite3_column_int(stmt, 2);
CangjieChar *c;
int ret = cangjie_char_new(&c, chchar, code, frequency);
if (ret != CANGJIE_OK) {
return ret;
}
ret = cangjie_char_list_prepend(&tmp, c);
if (ret != CANGJIE_OK) {
return ret;
}
} else if(ret == SQLITE_DONE) {
// All rows finished
sqlite3_finalize(stmt);
break;
} else {
// Some error encountered
return CANGJIE_DBERROR;
}
}
if (tmp == NULL) {
return CANGJIE_NOCHARS;
}
*l = tmp;
return CANGJIE_OK;
}
/*
** Attempt to load an SQLite extension library contained in the file
** zFile. The entry point is zProc. zProc may be 0 in which case a
** default entry point name (sqlite3_extension_init) is used. Use
** of the default name is recommended.
**
** Return SQLITE_OK on success and SQLITE_ERROR if something goes wrong.
**
** If an error occurs and pzErrMsg is not 0, then fill *pzErrMsg with
** error message text. The calling function should free this memory
** by calling sqlite3DbFree(db, ).
*/
static int sqlite3LoadExtension(
sqlite3 *db, /* Load the extension into this database connection */
const char *zFile, /* Name of the shared library containing extension */
const char *zProc, /* Entry point. Use "sqlite3_extension_init" if 0 */
char **pzErrMsg /* Put error message here if not 0 */
){
sqlite3_vfs *pVfs = db->pVfs;
void *handle;
int (*xInit)(sqlite3*,char**,const sqlite3_api_routines*);
char *zErrmsg = 0;
const char *zEntry;
char *zAltEntry = 0;
void **aHandle;
u64 nMsg = 300 + sqlite3Strlen30(zFile);
int ii;
/* Shared library endings to try if zFile cannot be loaded as written */
static const char *azEndings[] = {
#if SQLITE_OS_WIN
"dll"
#elif defined(__APPLE__)
"dylib"
#else
"so"
#endif
};
if( pzErrMsg ) *pzErrMsg = 0;
/* Ticket #1863. To avoid a creating security problems for older
** applications that relink against newer versions of SQLite, the
** ability to run load_extension is turned off by default. One
** must call sqlite3_enable_load_extension() to turn on extension
** loading. Otherwise you get the following error.
*/
if( (db->flags & SQLITE_LoadExtension)==0 ){
if( pzErrMsg ){
*pzErrMsg = sqlite3_mprintf("not authorized");
}
return SQLITE_ERROR;
}
zEntry = zProc ? zProc : "sqlite3_extension_init";
handle = sqlite3OsDlOpen(pVfs, zFile);
#if SQLITE_OS_UNIX || SQLITE_OS_WIN
for(ii=0; ii<ArraySize(azEndings) && handle==0; ii++){
char *zAltFile = sqlite3_mprintf("%s.%s", zFile, azEndings[ii]);
if( zAltFile==0 ) return SQLITE_NOMEM;
handle = sqlite3OsDlOpen(pVfs, zAltFile);
sqlite3_free(zAltFile);
}
#endif
if( handle==0 ){
if( pzErrMsg ){
*pzErrMsg = zErrmsg = sqlite3_malloc64(nMsg);
if( zErrmsg ){
sqlite3_snprintf(nMsg, zErrmsg,
"unable to open shared library [%s]", zFile);
sqlite3OsDlError(pVfs, nMsg-1, zErrmsg);
}
}
return SQLITE_ERROR;
}
xInit = (int(*)(sqlite3*,char**,const sqlite3_api_routines*))
sqlite3OsDlSym(pVfs, handle, zEntry);
/* If no entry point was specified and the default legacy
** entry point name "sqlite3_extension_init" was not found, then
** construct an entry point name "sqlite3_X_init" where the X is
** replaced by the lowercase value of every ASCII alphabetic
** character in the filename after the last "/" upto the first ".",
** and eliding the first three characters if they are "lib".
** Examples:
**
** /usr/local/lib/libExample5.4.3.so ==> sqlite3_example_init
** C:/lib/mathfuncs.dll ==> sqlite3_mathfuncs_init
*/
if( xInit==0 && zProc==0 ){
int iFile, iEntry, c;
int ncFile = sqlite3Strlen30(zFile);
zAltEntry = sqlite3_malloc64(ncFile+30);
if( zAltEntry==0 ){
sqlite3OsDlClose(pVfs, handle);
return SQLITE_NOMEM;
}
memcpy(zAltEntry, "sqlite3_", 8);
for(iFile=ncFile-1; iFile>=0 && zFile[iFile]!='/'; iFile--){}
iFile++;
if( sqlite3_strnicmp(zFile+iFile, "lib", 3)==0 ) iFile += 3;
for(iEntry=8; (c = zFile[iFile])!=0 && c!='.'; iFile++){
if( sqlite3Isalpha(c) ){
zAltEntry[iEntry++] = (char)sqlite3UpperToLower[(unsigned)c];
}
}
memcpy(zAltEntry+iEntry, "_init", 6);
zEntry = zAltEntry;
xInit = (int(*)(sqlite3*,char**,const sqlite3_api_routines*))
sqlite3OsDlSym(pVfs, handle, zEntry);
}
if( xInit==0 ){
if( pzErrMsg ){
nMsg += sqlite3Strlen30(zEntry);
*pzErrMsg = zErrmsg = sqlite3_malloc64(nMsg);
if( zErrmsg ){
sqlite3_snprintf(nMsg, zErrmsg,
"no entry point [%s] in shared library [%s]", zEntry, zFile);
sqlite3OsDlError(pVfs, nMsg-1, zErrmsg);
}
}
sqlite3OsDlClose(pVfs, handle);
sqlite3_free(zAltEntry);
return SQLITE_ERROR;
}
sqlite3_free(zAltEntry);
if( xInit(db, &zErrmsg, &sqlite3Apis) ){
if( pzErrMsg ){
*pzErrMsg = sqlite3_mprintf("error during initialization: %s", zErrmsg);
}
sqlite3_free(zErrmsg);
sqlite3OsDlClose(pVfs, handle);
return SQLITE_ERROR;
}
/* Append the new shared library handle to the db->aExtension array. */
aHandle = sqlite3DbMallocZero(db, sizeof(handle)*(db->nExtension+1));
if( aHandle==0 ){
return SQLITE_NOMEM;
}
if( db->nExtension>0 ){
memcpy(aHandle, db->aExtension, sizeof(handle)*db->nExtension);
}
sqlite3DbFree(db, db->aExtension);
db->aExtension = aHandle;
db->aExtension[db->nExtension++] = handle;
return SQLITE_OK;
}
void mbtiles_write_metadata(sqlite3 *outdb, const char *fname, char **layername, int minzoom, int maxzoom, double minlat, double minlon, double maxlat, double maxlon, double midlat, double midlon, struct pool **file_keys, int nlayers, int forcetable) {
char *sql, *err;
sql = sqlite3_mprintf("INSERT INTO metadata (name, value) VALUES ('name', %Q);", fname);
if (sqlite3_exec(outdb, sql, NULL, NULL, &err) != SQLITE_OK) {
fprintf(stderr, "set name in metadata: %s\n", err);
if (!forcetable) {
exit(EXIT_FAILURE);
}
}
sqlite3_free(sql);
sql = sqlite3_mprintf("INSERT INTO metadata (name, value) VALUES ('description', %Q);", fname);
if (sqlite3_exec(outdb, sql, NULL, NULL, &err) != SQLITE_OK) {
fprintf(stderr, "set description in metadata: %s\n", err);
if (!forcetable) {
exit(EXIT_FAILURE);
}
}
sqlite3_free(sql);
sql = sqlite3_mprintf("INSERT INTO metadata (name, value) VALUES ('version', %d);", 1);
if (sqlite3_exec(outdb, sql, NULL, NULL, &err) != SQLITE_OK) {
fprintf(stderr, "set version : %s\n", err);
if (!forcetable) {
exit(EXIT_FAILURE);
}
}
sqlite3_free(sql);
sql = sqlite3_mprintf("INSERT INTO metadata (name, value) VALUES ('minzoom', %d);", minzoom);
if (sqlite3_exec(outdb, sql, NULL, NULL, &err) != SQLITE_OK) {
fprintf(stderr, "set minzoom: %s\n", err);
if (!forcetable) {
exit(EXIT_FAILURE);
}
}
sqlite3_free(sql);
sql = sqlite3_mprintf("INSERT INTO metadata (name, value) VALUES ('maxzoom', %d);", maxzoom);
if (sqlite3_exec(outdb, sql, NULL, NULL, &err) != SQLITE_OK) {
fprintf(stderr, "set maxzoom: %s\n", err);
if (!forcetable) {
exit(EXIT_FAILURE);
}
}
sqlite3_free(sql);
sql = sqlite3_mprintf("INSERT INTO metadata (name, value) VALUES ('center', '%f,%f,%d');", midlon, midlat, maxzoom);
if (sqlite3_exec(outdb, sql, NULL, NULL, &err) != SQLITE_OK) {
fprintf(stderr, "set center: %s\n", err);
if (!forcetable) {
exit(EXIT_FAILURE);
}
}
sqlite3_free(sql);
sql = sqlite3_mprintf("INSERT INTO metadata (name, value) VALUES ('bounds', '%f,%f,%f,%f');", minlon, minlat, maxlon, maxlat);
if (sqlite3_exec(outdb, sql, NULL, NULL, &err) != SQLITE_OK) {
fprintf(stderr, "set bounds: %s\n", err);
if (!forcetable) {
exit(EXIT_FAILURE);
}
}
sqlite3_free(sql);
sql = sqlite3_mprintf("INSERT INTO metadata (name, value) VALUES ('type', %Q);", "overlay");
if (sqlite3_exec(outdb, sql, NULL, NULL, &err) != SQLITE_OK) {
fprintf(stderr, "set type: %s\n", err);
if (!forcetable) {
exit(EXIT_FAILURE);
}
}
sqlite3_free(sql);
sql = sqlite3_mprintf("INSERT INTO metadata (name, value) VALUES ('format', %Q);", "pbf");
if (sqlite3_exec(outdb, sql, NULL, NULL, &err) != SQLITE_OK) {
fprintf(stderr, "set format: %s\n", err);
if (!forcetable) {
exit(EXIT_FAILURE);
}
}
sqlite3_free(sql);
char *buf = strdup("{");
aprintf(&buf, "\"vector_layers\": [ ");
int i;
for (i = 0; i < nlayers; i++) {
if (i != 0) {
aprintf(&buf, ", ");
}
aprintf(&buf, "{ \"id\": \"");
quote(&buf, layername[i]);
aprintf(&buf, "\", \"description\": \"\", \"minzoom\": %d, \"maxzoom\": %d, \"fields\": {", minzoom, maxzoom);
int n = 0;
struct pool_val *pv;
for (pv = file_keys[i]->head; pv != NULL; pv = pv->next) {
n++;
}
struct pool_val *vals[n];
n = 0;
for (pv = file_keys[i]->head; pv != NULL; pv = pv->next) {
vals[n++] = pv;
}
qsort(vals, n, sizeof(struct pool_val *), pvcmp);
int j;
for (j = 0; j < n; j++) {
pv = vals[j];
aprintf(&buf, "\"");
quote(&buf, pv->s);
if (pv->type == VT_NUMBER) {
aprintf(&buf, "\": \"Number\"");
} else if (pv->type == VT_BOOLEAN) {
aprintf(&buf, "\": \"Boolean\"");
} else {
aprintf(&buf, "\": \"String\"");
}
if (j + 1 < n) {
aprintf(&buf, ", ");
}
}
aprintf(&buf, "} }");
}
aprintf(&buf, " ] }");
sql = sqlite3_mprintf("INSERT INTO metadata (name, value) VALUES ('json', %Q);", buf);
if (sqlite3_exec(outdb, sql, NULL, NULL, &err) != SQLITE_OK) {
fprintf(stderr, "set json: %s\n", err);
if (!forcetable) {
exit(EXIT_FAILURE);
}
}
sqlite3_free(sql);
free(buf);
}
/*
** This function is the implementation of both the xConnect and xCreate
** methods of the CSV virtual table.
**
** argv[0] -> module name
** argv[1] -> database name
** argv[2] -> table name
** argv[3] -> csv file name
** argv[4] -> custom delimiter
** argv[5] -> optional: use header row for column names
**
** TODO
** File encoding problem
** Column/Cell type (in declaration and in result)
*/
static int csvInit(
sqlite3 *db, /* Database connection */
void *pAux, /* Unused */
int argc, const char *const*argv, /* Parameters to CREATE TABLE statement */
sqlite3_vtab **ppVtab, /* OUT: New virtual table */
char **pzErr, /* OUT: Error message, if any */
int isCreate /* True for xCreate, false for xConnect */
){
int rc = SQLITE_OK;
int i;
CSV *pCSV;
char *zSql;
char cDelim = ','; /* Default col delimiter */
int bUseHeaderRow = 0; /* Default to not use zRow headers */
size_t nDb; /* Length of string argv[1] */
size_t nName; /* Length of string argv[2] */
size_t nFile; /* Length of string argv[3] */
CSVCursor csvCsr; /* Used for calling csvNext */
const char *aErrMsg[] = {
0, /* 0 */
"No CSV file specified", /* 1 */
"Error opening CSV file: '%s'", /* 2 */
"No columns found", /* 3 */
"No column name found", /* 4 */
"Out of memory", /* 5 */
};
UNUSED_PARAMETER(pAux);
UNUSED_PARAMETER(isCreate);
if( argc < 4 ){
*pzErr = sqlite3_mprintf("%s", aErrMsg[1]);
return SQLITE_ERROR;
}
/* allocate space for the virtual table object */
nDb = strlen(argv[1]);
nName = strlen(argv[2]);
nFile = strlen(argv[3]);
pCSV = (CSV *)sqlite3_malloc( (int)(sizeof(CSV)+nDb+nName+nFile+3) );
if( !pCSV ){
/* out of memory */
*pzErr = sqlite3_mprintf("%s", aErrMsg[5]);
return SQLITE_NOMEM;
}
/* intialize virtual table object */
memset(pCSV, 0, sizeof(CSV)+nDb+nName+nFile+3);
pCSV->db = db;
pCSV->nBusy = 1;
pCSV->base.pModule = &csvModule;
pCSV->cDelim = cDelim;
pCSV->zDb = (char *)&pCSV[1];
pCSV->zName = &pCSV->zDb[nDb+1];
pCSV->zFile = &pCSV->zName[nName+1];
memcpy(pCSV->zDb, argv[1], nDb);
memcpy(pCSV->zName, argv[2], nName);
/* pull out name of csv file (remove quotes) */
if( argv[3][0] == '\'' ){
memcpy( pCSV->zFile, argv[3]+1, nFile-2 );
pCSV->zFile[nFile-2] = '\0';
}else{
memcpy( pCSV->zFile, argv[3], nFile );
}
/* if a custom delimiter specified, pull it out */
if( argc > 4 ){
if( argv[4][0] == '\'' ){
pCSV->cDelim = argv[4][1];
}else{
pCSV->cDelim = argv[4][0];
}
}
/* should the header zRow be used */
if( argc > 5 ){
if( !strcmp(argv[5], "USE_HEADER_ROW") ){
bUseHeaderRow = -1;
}
}
/* open the source csv file */
pCSV->f = csv_open( pCSV );
if( !pCSV->f ){
*pzErr = sqlite3_mprintf(aErrMsg[2], pCSV->zFile);
csvRelease( pCSV );
return SQLITE_ERROR;
}
/* Read first zRow to obtain column names/number */
csvCsr.base.pVtab = (sqlite3_vtab *)pCSV;
rc = csvNext( (sqlite3_vtab_cursor *)&csvCsr );
if( (SQLITE_OK!=rc) || (pCSV->nCol<=0) ){
*pzErr = sqlite3_mprintf("%s", aErrMsg[3]);
csvRelease( pCSV );
return SQLITE_ERROR;
}
if( bUseHeaderRow ){
pCSV->offsetFirstRow = csv_tell( pCSV );
}
/* Create the underlying relational database schema. If
** that is successful, call sqlite3_declare_vtab() to configure
** the csv table schema.
*/
zSql = sqlite3_mprintf("CREATE TABLE x(");
for(i=0; zSql && i<pCSV->nCol; i++){
const char *zTail = (i+1<pCSV->nCol) ? ", " : ");";
char *zTmp = zSql;
if( bUseHeaderRow ){
const char *zCol = pCSV->aCols[i];
if( !zCol ){
*pzErr = sqlite3_mprintf("%s", aErrMsg[4]);
sqlite3_free(zSql);
csvRelease( pCSV );
return SQLITE_ERROR;
}
zSql = sqlite3_mprintf("%s\"%s\"%s", zTmp, zCol, zTail); // FIXME Column type (INT/REAL/TEXT)
}else{
zSql = sqlite3_mprintf("%scol%d%s", zTmp, i+1, zTail); // FIXME Column type (INT/REAL/TEXT)
}
sqlite3_free(zTmp);
}
if( !zSql ){
*pzErr = sqlite3_mprintf("%s", aErrMsg[5]);
csvRelease( pCSV );
return SQLITE_NOMEM;
}
rc = sqlite3_declare_vtab( db, zSql );
sqlite3_free(zSql);
if( SQLITE_OK != rc ){
*pzErr = sqlite3_mprintf("%s", sqlite3_errmsg(db));
csvRelease( pCSV );
return SQLITE_ERROR;
}
*ppVtab = (sqlite3_vtab *)pCSV;
*pzErr = NULL;
return SQLITE_OK;
}
/*
** xConnect/xCreate method for the closure module. Arguments are:
**
** argv[0] -> module name ("transitive_closure")
** argv[1] -> database name
** argv[2] -> table name
** argv[3...] -> arguments
*/
static int closureConnect(
sqlite3 *db,
void *pAux,
int argc, const char *const*argv,
sqlite3_vtab **ppVtab,
char **pzErr
){
int rc = SQLITE_OK; /* Return code */
closure_vtab *pNew = 0; /* New virtual table */
const char *zDb = argv[1];
const char *zVal;
int i;
(void)pAux;
*ppVtab = 0;
pNew = sqlite3_malloc( sizeof(*pNew) );
if( pNew==0 ) return SQLITE_NOMEM;
rc = SQLITE_NOMEM;
memset(pNew, 0, sizeof(*pNew));
pNew->db = db;
pNew->zDb = sqlite3_mprintf("%s", zDb);
if( pNew->zDb==0 ) goto closureConnectError;
pNew->zSelf = sqlite3_mprintf("%s", argv[2]);
if( pNew->zSelf==0 ) goto closureConnectError;
for(i=3; i<argc; i++){
zVal = closureValueOfKey("tablename", argv[i]);
if( zVal ){
sqlite3_free(pNew->zTableName);
pNew->zTableName = closureDequote(zVal);
if( pNew->zTableName==0 ) goto closureConnectError;
continue;
}
zVal = closureValueOfKey("idcolumn", argv[i]);
if( zVal ){
sqlite3_free(pNew->zIdColumn);
pNew->zIdColumn = closureDequote(zVal);
if( pNew->zIdColumn==0 ) goto closureConnectError;
continue;
}
zVal = closureValueOfKey("parentcolumn", argv[i]);
if( zVal ){
sqlite3_free(pNew->zParentColumn);
pNew->zParentColumn = closureDequote(zVal);
if( pNew->zParentColumn==0 ) goto closureConnectError;
continue;
}
*pzErr = sqlite3_mprintf("unrecognized argument: [%s]\n", argv[i]);
closureFree(pNew);
*ppVtab = 0;
return SQLITE_ERROR;
}
rc = sqlite3_declare_vtab(db,
"CREATE TABLE x(id,depth,root HIDDEN,tablename HIDDEN,"
"idcolumn HIDDEN,parentcolumn HIDDEN)"
);
#define CLOSURE_COL_ID 0
#define CLOSURE_COL_DEPTH 1
#define CLOSURE_COL_ROOT 2
#define CLOSURE_COL_TABLENAME 3
#define CLOSURE_COL_IDCOLUMN 4
#define CLOSURE_COL_PARENTCOLUMN 5
if( rc!=SQLITE_OK ){
closureFree(pNew);
}
*ppVtab = &pNew->base;
return rc;
closureConnectError:
closureFree(pNew);
return rc;
}
static void SetVTableError(VTableInfo *vtabP, const char *msg)
{
if (vtabP->vtab.zErrMsg)
sqlite3_free(vtabP->vtab.zErrMsg);
vtabP->vtab.zErrMsg = sqlite3_mprintf("%s", msg);
}
/*
** Advance a cursor to its next row of output
*/
static int amatchNext(sqlite3_vtab_cursor *cur){
amatch_cursor *pCur = (amatch_cursor*)cur;
amatch_word *pWord = 0;
amatch_avl *pNode;
int isMatch = 0;
amatch_vtab *p = pCur->pVtab;
int nWord;
int rc;
int i;
const char *zW;
amatch_rule *pRule;
char *zBuf = 0;
char nBuf = 0;
char zNext[8];
char zNextIn[8];
int nNextIn;
if( p->pVCheck==0 ){
char *zSql;
if( p->zVocabLang && p->zVocabLang[0] ){
zSql = sqlite3_mprintf(
"SELECT \"%w\" FROM \"%w\"",
" WHERE \"%w\">=?1 AND \"%w\"=?2"
" ORDER BY 1",
p->zVocabWord, p->zVocabTab,
p->zVocabWord, p->zVocabLang
);
}else{
zSql = sqlite3_mprintf(
"SELECT \"%w\" FROM \"%w\""
" WHERE \"%w\">=?1"
" ORDER BY 1",
p->zVocabWord, p->zVocabTab,
p->zVocabWord
);
}
rc = sqlite3_prepare_v2(p->db, zSql, -1, &p->pVCheck, 0);
sqlite3_free(zSql);
if( rc ) return rc;
}
sqlite3_bind_int(p->pVCheck, 2, pCur->iLang);
do{
pNode = amatchAvlFirst(pCur->pCost);
if( pNode==0 ){
pWord = 0;
break;
}
pWord = pNode->pWord;
amatchAvlRemove(&pCur->pCost, &pWord->sCost);
#ifdef AMATCH_TRACE_1
printf("PROCESS [%s][%.*s^%s] %d (\"%s\" \"%s\")\n",
pWord->zWord+2, pWord->nMatch, pCur->zInput, pCur->zInput+pWord->nMatch,
pWord->rCost, pWord->zWord, pWord->zCost);
#endif
nWord = (int)strlen(pWord->zWord+2);
if( nWord+20>nBuf ){
nBuf = (char)(nWord+100);
zBuf = sqlite3_realloc(zBuf, nBuf);
if( zBuf==0 ) return SQLITE_NOMEM;
}
amatchStrcpy(zBuf, pWord->zWord+2);
zNext[0] = 0;
zNextIn[0] = pCur->zInput[pWord->nMatch];
if( zNextIn[0] ){
for(i=1; i<=4 && (pCur->zInput[pWord->nMatch+i]&0xc0)==0x80; i++){
zNextIn[i] = pCur->zInput[pWord->nMatch+i];
}
zNextIn[i] = 0;
nNextIn = i;
}else{
nNextIn = 0;
}
if( zNextIn[0] && zNextIn[0]!='*' ){
sqlite3_reset(p->pVCheck);
amatchStrcat(zBuf, zNextIn);
sqlite3_bind_text(p->pVCheck, 1, zBuf, nWord+nNextIn, SQLITE_STATIC);
rc = sqlite3_step(p->pVCheck);
if( rc==SQLITE_ROW ){
zW = (const char*)sqlite3_column_text(p->pVCheck, 0);
if( strncmp(zBuf, zW, nWord+nNextIn)==0 ){
amatchAddWord(pCur, pWord->rCost, pWord->nMatch+nNextIn, zBuf, "");
}
}
zBuf[nWord] = 0;
}
while( 1 ){
amatchStrcpy(zBuf+nWord, zNext);
sqlite3_reset(p->pVCheck);
sqlite3_bind_text(p->pVCheck, 1, zBuf, -1, SQLITE_TRANSIENT);
rc = sqlite3_step(p->pVCheck);
if( rc!=SQLITE_ROW ) break;
zW = (const char*)sqlite3_column_text(p->pVCheck, 0);
amatchStrcpy(zBuf+nWord, zNext);
if( strncmp(zW, zBuf, nWord)!=0 ) break;
if( (zNextIn[0]=='*' && zNextIn[1]==0)
|| (zNextIn[0]==0 && zW[nWord]==0)
){
isMatch = 1;
zNextIn[0] = 0;
nNextIn = 0;
break;
}
zNext[0] = zW[nWord];
for(i=1; i<=4 && (zW[nWord+i]&0xc0)==0x80; i++){
zNext[i] = zW[nWord+i];
}
zNext[i] = 0;
zBuf[nWord] = 0;
if( p->rIns>0 ){
amatchAddWord(pCur, pWord->rCost+p->rIns, pWord->nMatch,
zBuf, zNext);
}
if( p->rSub>0 ){
amatchAddWord(pCur, pWord->rCost+p->rSub, pWord->nMatch+nNextIn,
zBuf, zNext);
}
if( p->rIns<0 && p->rSub<0 ) break;
zNext[i-1]++; /* FIX ME */
}
sqlite3_reset(p->pVCheck);
if( p->rDel>0 ){
zBuf[nWord] = 0;
amatchAddWord(pCur, pWord->rCost+p->rDel, pWord->nMatch+nNextIn,
zBuf, "");
}
for(pRule=p->pRule; pRule; pRule=pRule->pNext){
if( pRule->iLang!=pCur->iLang ) continue;
if( strncmp(pRule->zFrom, pCur->zInput+pWord->nMatch, pRule->nFrom)==0 ){
amatchAddWord(pCur, pWord->rCost+pRule->rCost,
pWord->nMatch+pRule->nFrom, pWord->zWord+2, pRule->zTo);
}
}
}while( !isMatch );
pCur->pCurrent = pWord;
sqlite3_free(zBuf);
return SQLITE_OK;
}
static int VTableCreateOrConnect(
sqlite3 *sqliteP,
void *clientdata,
int argc,
const char *const *argv,
sqlite3_vtab **vtabPP,
char **errstrP,
int create)
{
VTableDB *vtdbP = (VTableDB *)clientdata;
VTableInfo *vtabP;
int status;
int i;
Tcl_Obj *objv[4];
Tcl_Interp *interp = vtdbP->vticP->interp;
/*
* argv[0] - name of our module (i.e. PACKAGE_NAME)
* argv[1] - name of database where the virtual table is being created
* argv[2] - name of the table
* argv[3..argc-1] - arguments passed to CREATE VIRTUAL TABLE. argv[3]
* is the script to invoke, remaining are arguments passed
* only to the create and connect methods.
*/
VTABLE_ASSERT(vtdbP->sqliteP == sqliteP);
if (argc < 4) {
*errstrP = sqlite3_mprintf("Insufficient number of arguments for virtual table");
return SQLITE_ERROR;
}
vtabP = VTableInfoNew(vtdbP, argv[2]);
/*
* argv[3] is the command prefix to be invoked for virtual
* table operations.
*/
vtabP->cmdprefixP = Tcl_NewStringObj(argv[3], -1);
Tcl_IncrRefCount(vtabP->cmdprefixP);
if (Tcl_ListObjLength(interp, vtabP->cmdprefixP, &i) != TCL_OK) {
*errstrP = sqlite3_mprintf("Command prefix '%s' does not have a valid list format.", argv[3]);
VTableInfoDelete(vtabP);
return SQLITE_ERROR;
}
objv[0] = vtdbP->dbcmd_objP;
objv[1] = Tcl_NewStringObj(argv[1], -1); /* DB name */
objv[2] = Tcl_NewStringObj(argv[2], -1); /* virtual table name */
objv[3] = Tcl_NewListObj(0, NULL);
for (i = 4; i < argc; ++i) {
Tcl_ListObjAppendElement(interp, objv[3], Tcl_NewStringObj(argv[i],-1));
}
if (VTableInvokeCmd(interp, vtabP, create ? "xCreate" : "xConnect",
4, objv) != TCL_OK) {
*errstrP = sqlite3_mprintf("%s", Tcl_GetStringResult(interp));
VTableInfoDelete(vtabP);
return SQLITE_ERROR;
}
/* Return value is DDL that we have to use to create the table */
status = sqlite3_declare_vtab(sqliteP, Tcl_GetStringResult(interp));
if (status != SQLITE_OK) {
VTableDisconnectOrDestroy(vtabP, create); /* Will also delete vtabP */
return status;
}
*vtabPP = &vtabP->vtab;
return SQLITE_OK;
}
/*
** Load the content of the amatch data table into memory.
*/
static int amatchLoadRules(
sqlite3 *db, /* Database handle */
amatch_vtab *p, /* Virtual amatch table to configure */
char **pzErr /* OUT: Error message */
){
int rc = SQLITE_OK; /* Return code */
char *zSql; /* SELECT used to read from rules table */
amatch_rule *pHead = 0;
zSql = sqlite3_mprintf("SELECT * FROM %Q.%Q", p->zDb, p->zCostTab);
if( zSql==0 ){
rc = SQLITE_NOMEM;
}else{
int rc2; /* finalize() return code */
sqlite3_stmt *pStmt = 0;
rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
if( rc!=SQLITE_OK ){
*pzErr = sqlite3_mprintf("%s: %s", p->zClassName, sqlite3_errmsg(db));
}else if( sqlite3_column_count(pStmt)!=4 ){
*pzErr = sqlite3_mprintf("%s: %s has %d columns, expected 4",
p->zClassName, p->zCostTab, sqlite3_column_count(pStmt)
);
rc = SQLITE_ERROR;
}else{
while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
amatch_rule *pRule = 0;
rc = amatchLoadOneRule(p, pStmt, &pRule, pzErr);
if( pRule ){
pRule->pNext = pHead;
pHead = pRule;
}
}
}
rc2 = sqlite3_finalize(pStmt);
if( rc==SQLITE_OK ) rc = rc2;
}
sqlite3_free(zSql);
/* All rules are now in a singly linked list starting at pHead. This
** block sorts them by cost and then sets amatch_vtab.pRule to point to
** point to the head of the sorted list.
*/
if( rc==SQLITE_OK ){
unsigned int i;
amatch_rule *pX;
amatch_rule *a[15];
for(i=0; i<sizeof(a)/sizeof(a[0]); i++) a[i] = 0;
while( (pX = pHead)!=0 ){
pHead = pX->pNext;
pX->pNext = 0;
for(i=0; a[i] && i<sizeof(a)/sizeof(a[0])-1; i++){
pX = amatchMergeRules(a[i], pX);
a[i] = 0;
}
a[i] = amatchMergeRules(a[i], pX);
}
for(pX=a[0], i=1; i<sizeof(a)/sizeof(a[0]); i++){
pX = amatchMergeRules(a[i], pX);
}
p->pRule = amatchMergeRules(p->pRule, pX);
}else{
/* An error has occurred. Setting p->pRule to point to the head of the
** allocated list ensures that the list will be cleaned up in this case.
*/
assert( p->pRule==0 );
p->pRule = pHead;
}
return rc;
}
int xBestIndex(sqlite3_vtab *sqltabP, sqlite3_index_info *infoP)
{
VTableInfo *vtabP = (VTableInfo *) sqltabP;
Tcl_Obj *objv[3];
Tcl_Interp *interp;
Tcl_Obj *constraints;
Tcl_Obj *order;
int i;
char *s;
Tcl_Obj **response;
int nobjs;
Tcl_Obj **usage;
int nusage;
if (vtabP->vtdbP == NULL || (interp = vtabP->vtdbP->vticP->interp) == NULL) {
/* Should not really happen */
SetVTableError(vtabP, gNullInterpError);
return SQLITE_ERROR;
}
constraints = Tcl_NewListObj(0, NULL);
for (i = 0; i < infoP->nConstraint; ++i) {
objv[0] = Tcl_NewIntObj(infoP->aConstraint[i].iColumn);
switch (infoP->aConstraint[i].op) {
case 2: s = "eq" ; break;
case 4: s = "gt" ; break;
case 8: s = "le" ; break;
case 16: s = "lt" ; break;
case 32: s = "ge" ; break;
case 64: s = "match"; break;
default:
SetVTableError(vtabP, "Unknown or unsupported constraint operator.");
return SQLITE_ERROR;
}
objv[1] = Tcl_NewStringObj(s, -1);
objv[2] = Tcl_NewBooleanObj(infoP->aConstraint[i].usable);
Tcl_ListObjAppendElement(interp, constraints, Tcl_NewListObj(3, objv));
}
order = Tcl_NewListObj(0, NULL);
for (i = 0; i < infoP->nOrderBy; ++i) {
objv[0] = Tcl_NewIntObj(infoP->aOrderBy[i].iColumn);
objv[1] = Tcl_NewBooleanObj(infoP->aOrderBy[i].desc);
Tcl_ListObjAppendElement(interp, order, Tcl_NewListObj(2, objv));
}
objv[0] = constraints;
objv[1] = order;
if (VTableInvokeCmd(interp, vtabP, "xBestIndex", 2, objv) != TCL_OK) {
SetVTableErrorFromInterp(vtabP, interp);
return SQLITE_ERROR;
}
/* Parse and return the response */
if (Tcl_ListObjGetElements(interp, Tcl_GetObjResult(interp),
&nobjs, &response) != TCL_OK)
goto bad_response;
if (nobjs == 0)
return SQLITE_OK;
if (nobjs != 5) {
/* If non-empty, list must have exactly five elements */
goto bad_response;
}
if (Tcl_ListObjGetElements(interp, response[0],
&nusage, &usage) != TCL_OK
|| nusage > infoP->nConstraint) {
/*
* Length of constraints used must not be greater than original
* number of constraints
* TBD - should it be exactly equal ?
*/
goto bad_response;
}
for (i = 0; i < nusage; ++i) {
Tcl_Obj **usage_constraint;
int nusage_constraint;
int argindex;
int omit;
if (Tcl_ListObjGetElements(interp, usage[i],
&nusage_constraint, &usage_constraint) != TCL_OK
|| nusage_constraint != 2
|| Tcl_GetIntFromObj(interp, usage_constraint[0], &argindex) != TCL_OK
|| Tcl_GetBooleanFromObj(interp, usage_constraint[1], &omit) != TCL_OK
) {
goto bad_response;
}
infoP->aConstraintUsage[i].argvIndex = argindex;
infoP->aConstraintUsage[i].omit = omit;
}
if (Tcl_GetIntFromObj(interp, response[1], &infoP->idxNum) != TCL_OK)
goto bad_response;
s = Tcl_GetStringFromObj(response[2], &i);
if (i) {
infoP->idxStr = sqlite3_mprintf("%s", s);
infoP->needToFreeIdxStr = 1;
}
if (Tcl_GetIntFromObj(interp, response[3], &infoP->orderByConsumed) != TCL_OK)
goto bad_response;
if (Tcl_GetDoubleFromObj(interp, response[4], &infoP->estimatedCost) != TCL_OK)
goto bad_response;
return SQLITE_OK;
bad_response:
SetVTableError(vtabP, "Malformed response from virtual table script.");
return SQLITE_ERROR;
}
/*
** Advance the cursor to the next row.
*/
static int schemaNext(sqlite3_vtab_cursor *cur){
int rc = SQLITE_OK;
schema_cursor *pCur = (schema_cursor *)cur;
schema_vtab *pVtab = (schema_vtab *)(cur->pVtab);
char *zSql = 0;
while( !pCur->pColumnList || SQLITE_ROW!=sqlite3_step(pCur->pColumnList) ){
if( SQLITE_OK!=(rc = finalize(&pCur->pColumnList)) ) goto next_exit;
while( !pCur->pTableList || SQLITE_ROW!=sqlite3_step(pCur->pTableList) ){
if( SQLITE_OK!=(rc = finalize(&pCur->pTableList)) ) goto next_exit;
assert(pCur->pDbList);
while( SQLITE_ROW!=sqlite3_step(pCur->pDbList) ){
rc = finalize(&pCur->pDbList);
goto next_exit;
}
/* Set zSql to the SQL to pull the list of tables from the
** sqlite_master (or sqlite_temp_master) table of the database
** identfied by the row pointed to by the SQL statement pCur->pDbList
** (iterating through a "PRAGMA database_list;" statement).
*/
if( sqlite3_column_int(pCur->pDbList, 0)==1 ){
zSql = sqlite3_mprintf(
"SELECT name FROM sqlite_temp_master WHERE type='table'"
);
}else{
sqlite3_stmt *pDbList = pCur->pDbList;
zSql = sqlite3_mprintf(
"SELECT name FROM %Q.sqlite_master WHERE type='table'",
sqlite3_column_text(pDbList, 1)
);
}
if( !zSql ){
rc = SQLITE_NOMEM;
goto next_exit;
}
rc = sqlite3_prepare(pVtab->db, zSql, -1, &pCur->pTableList, 0);
sqlite3_free(zSql);
if( rc!=SQLITE_OK ) goto next_exit;
}
/* Set zSql to the SQL to the table_info pragma for the table currently
** identified by the rows pointed to by statements pCur->pDbList and
** pCur->pTableList.
*/
zSql = sqlite3_mprintf("PRAGMA %Q.table_info(%Q)",
sqlite3_column_text(pCur->pDbList, 1),
sqlite3_column_text(pCur->pTableList, 0)
);
if( !zSql ){
rc = SQLITE_NOMEM;
goto next_exit;
}
rc = sqlite3_prepare(pVtab->db, zSql, -1, &pCur->pColumnList, 0);
sqlite3_free(zSql);
if( rc!=SQLITE_OK ) goto next_exit;
}
pCur->rowid++;
next_exit:
/* TODO: Handle rc */
return rc;
}
static int
vtxt_create (sqlite3 * db, void *pAux, int argc, const char *const *argv,
sqlite3_vtab ** ppVTab, char **pzErr)
{
/* creates the virtual table connected to some TEXT file */
char path[2048];
char encoding[128];
const char *vtable;
const char *pEncoding = NULL;
int len;
gaiaTextReaderPtr text = NULL;
const char *pPath = NULL;
char field_separator = '\t';
char text_separator = '"';
char decimal_separator = '.';
char first_line_titles = 1;
int i;
char sql[65535];
int seed;
int dup;
int idup;
char dummyName[4096];
char **col_name = NULL;
VirtualTextPtr p_vt;
if (pAux)
pAux = pAux; /* unused arg warning suppression */
/* checking for TEXTfile PATH */
if (argc >= 5 && argc <= 9)
{
vtable = argv[1];
pPath = argv[3];
len = strlen (pPath);
if ((*(pPath + 0) == '\'' || *(pPath + 0) == '"')
&& (*(pPath + len - 1) == '\'' || *(pPath + len - 1) == '"'))
{
/* the path is enclosed between quotes - we need to dequote it */
strcpy (path, pPath + 1);
len = strlen (path);
*(path + len - 1) = '\0';
}
else
strcpy (path, pPath);
pEncoding = argv[4];
len = strlen (pEncoding);
if ((*(pEncoding + 0) == '\'' || *(pEncoding + 0) == '"')
&& (*(pEncoding + len - 1) == '\''
|| *(pEncoding + len - 1) == '"'))
{
/* the charset-name is enclosed between quotes - we need to dequote it */
strcpy (encoding, pEncoding + 1);
len = strlen (encoding);
*(encoding + len - 1) = '\0';
}
else
strcpy (encoding, pEncoding);
if (argc >= 6)
{
if (*(argv[5]) == '0' || *(argv[5]) == 'n' || *(argv[5]) == 'N')
first_line_titles = 0;
}
if (argc >= 7)
{
if (strcasecmp (argv[6], "COMMA") == 0)
decimal_separator = ',';
if (strcasecmp (argv[6], "POINT") == 0)
decimal_separator = '.';
}
if (argc >= 8)
{
if (strcasecmp (argv[7], "SINGLEQUOTE") == 0)
text_separator = '\'';
if (strcasecmp (argv[7], "DOUBLEQUOTE") == 0)
text_separator = '"';
if (strcasecmp (argv[7], "NONE") == 0)
text_separator = '\0';
}
if (argc == 9)
{
if (strlen (argv[8]) == 3)
{
if (strcasecmp (argv[8], "TAB") == 0)
field_separator = '\t';
if (*(argv[8] + 0) == '\'' && *(argv[8] + 2) == '\'')
field_separator = *(argv[8] + 1);
}
}
}
else
{
*pzErr =
sqlite3_mprintf
("[VirtualText module] CREATE VIRTUAL: illegal arg list\n"
"\t\t{ text_path, encoding [, first_row_as_titles [, [decimal_separator [, text_separator, [field_separator] ] ] ] }\n");
return SQLITE_ERROR;
}
p_vt = (VirtualTextPtr) sqlite3_malloc (sizeof (VirtualText));
if (!p_vt)
return SQLITE_NOMEM;
p_vt->pModule = &virtualtext_module;
p_vt->nRef = 0;
p_vt->zErrMsg = NULL;
p_vt->db = db;
text = gaiaTextReaderAlloc (path, field_separator,
text_separator, decimal_separator,
first_line_titles, encoding);
if (text)
{
if (gaiaTextReaderParse (text) == 0)
{
gaiaTextReaderDestroy (text);
text = NULL;
}
}
if (!text)
{
/* something is going the wrong way; creating a stupid default table */
spatialite_e ("VirtualText: invalid data source\n");
sprintf (sql, "CREATE TABLE %s (ROWNO INTEGER)", vtable);
if (sqlite3_declare_vtab (db, sql) != SQLITE_OK)
{
*pzErr =
sqlite3_mprintf
("[VirtualText module] cannot build a table from TEXT file\n");
return SQLITE_ERROR;
}
p_vt->reader = NULL;
*ppVTab = (sqlite3_vtab *) p_vt;
return SQLITE_OK;
}
p_vt->reader = text;
/* preparing the COLUMNs for this VIRTUAL TABLE */
sprintf (sql, "CREATE TABLE %s (ROWNO INTEGER", vtable);
col_name = malloc (sizeof (char *) * text->max_fields);
seed = 0;
for (i = 0; i < text->max_fields; i++)
{
strcat (sql, ", ");
sprintf (dummyName, "\"%s\"", text->columns[i].name);
dup = 0;
for (idup = 0; idup < i; idup++)
{
if (strcasecmp (dummyName, *(col_name + idup)) == 0)
dup = 1;
}
if (strcasecmp (dummyName, "ROWNO") == 0)
dup = 1;
if (dup)
sprintf (dummyName, "DUPCOL_%d", seed++);
len = strlen (dummyName);
*(col_name + i) = malloc (len + 1);
strcpy (*(col_name + i), dummyName);
strcat (sql, dummyName);
if (text->columns[i].type == VRTTXT_INTEGER)
strcat (sql, " INTEGER");
else if (text->columns[i].type == VRTTXT_DOUBLE)
strcat (sql, " DOUBLE");
else
strcat (sql, " TEXT");
}
strcat (sql, ")");
if (col_name)
{
/* releasing memory allocation for column names */
for (i = 0; i < text->max_fields; i++)
free (*(col_name + i));
free (col_name);
}
if (sqlite3_declare_vtab (db, sql) != SQLITE_OK)
{
*pzErr =
sqlite3_mprintf
("[VirtualText module] CREATE VIRTUAL: invalid SQL statement \"%s\"",
sql);
return SQLITE_ERROR;
}
*ppVTab = (sqlite3_vtab *) p_vt;
return SQLITE_OK;
}
/*
** Attempt to load an SQLite extension library contained in the file
** zFile. The entry point is zProc. zProc may be 0 in which case a
** default entry point name (sqlite3_extension_init) is used. Use
** of the default name is recommended.
**
** Return SQLITE_OK on success and SQLITE_ERROR if something goes wrong.
**
** If an error occurs and pzErrMsg is not 0, then fill *pzErrMsg with
** error message text. The calling function should free this memory
** by calling sqlite3DbFree(db, ).
*/
static int sqlite3LoadExtension(
sqlite3 *db, /* Load the extension into this database connection */
const char *zFile, /* Name of the shared library containing extension */
const char *zProc, /* Entry point. Use "sqlite3_extension_init" if 0 */
char **pzErrMsg /* Put error message here if not 0 */
){
sqlite3_vfs *pVfs = db->pVfs;
void *handle;
int (*xInit)(sqlite3*,char**,const sqlite3_api_routines*);
char *zErrmsg = 0;
void **aHandle;
/* Ticket #1863. To avoid a creating security problems for older
** applications that relink against newer versions of SQLite, the
** ability to run load_extension is turned off by default. One
** must call sqlite3_enable_load_extension() to turn on extension
** loading. Otherwise you get the following error.
*/
if( (db->flags & SQLITE_LoadExtension)==0 ){
if( pzErrMsg ){
*pzErrMsg = sqlite3_mprintf("not authorized");
}
return SQLITE_ERROR;
}
if( zProc==0 ){
zProc = "sqlite3_extension_init";
}
handle = sqlite3OsDlOpen(pVfs, zFile);
if( handle==0 ){
if( pzErrMsg ){
char zErr[256];
zErr[sizeof(zErr)-1] = '\0';
sqlite3_snprintf(sizeof(zErr)-1, zErr,
"unable to open shared library [%s]", zFile);
sqlite3OsDlError(pVfs, sizeof(zErr)-1, zErr);
*pzErrMsg = sqlite3DbStrDup(0, zErr);
}
return SQLITE_ERROR;
}
xInit = (int(*)(sqlite3*,char**,const sqlite3_api_routines*))
sqlite3OsDlSym(pVfs, handle, zProc);
if( xInit==0 ){
if( pzErrMsg ){
char zErr[256];
zErr[sizeof(zErr)-1] = '\0';
sqlite3_snprintf(sizeof(zErr)-1, zErr,
"no entry point [%s] in shared library [%s]", zProc,zFile);
sqlite3OsDlError(pVfs, sizeof(zErr)-1, zErr);
*pzErrMsg = sqlite3DbStrDup(0, zErr);
sqlite3OsDlClose(pVfs, handle);
}
return SQLITE_ERROR;
}else if( xInit(db, &zErrmsg, &sqlite3Apis) ){
if( pzErrMsg ){
*pzErrMsg = sqlite3_mprintf("error during initialization: %s", zErrmsg);
}
sqlite3_free(zErrmsg);
sqlite3OsDlClose(pVfs, handle);
return SQLITE_ERROR;
}
/* Append the new shared library handle to the db->aExtension array. */
aHandle = sqlite3DbMallocZero(db, sizeof(handle)*(db->nExtension+1));
if( aHandle==0 ){
return SQLITE_NOMEM;
}
if( db->nExtension>0 ){
memcpy(aHandle, db->aExtension, sizeof(handle)*db->nExtension);
}
sqlite3DbFree(db, db->aExtension);
db->aExtension = aHandle;
db->aExtension[db->nExtension++] = handle;
return SQLITE_OK;
}
void ImportCsvDialog::accept()
{
// save settings
QSettings settings(QApplication::organizationName(), QApplication::organizationName());
settings.beginGroup("importcsv");
settings.setValue("firstrowheader", ui->checkboxHeader->isChecked());
settings.setValue("separator", currentSeparatorChar());
settings.setValue("quotecharacter", currentQuoteChar());
settings.setValue("trimfields", ui->checkBoxTrimFields->isChecked());
settings.setValue("encoding", currentEncoding());
settings.endGroup();
// Parse all csv data
QFile file(csvFilename);
file.open(QIODevice::ReadOnly);
CSVParser csv(ui->checkBoxTrimFields->isChecked(), currentSeparatorChar(), currentQuoteChar());
csv.setCSVProgress(new CSVImportProgress(file.size()));
QTextStream tstream(&file);
tstream.setCodec(currentEncoding().toUtf8());
csv.parse(tstream);
file.close();
if(csv.csv().size() == 0)
return;
// Generate field names. These are either taken from the first CSV row or are generated in the format of "fieldXY" depending on the user input
sqlb::FieldVector fieldList;
CSVParser::TCSVResult::const_iterator itBegin = csv.csv().begin();
if(ui->checkboxHeader->isChecked())
{
++itBegin;
for(QStringList::const_iterator it = csv.csv().at(0).begin();
it != csv.csv().at(0).end();
++it)
{
// Remove invalid characters
QString thisfield = *it;
thisfield.replace("`", "");
thisfield.replace(" ", "");
thisfield.replace('"', "");
thisfield.replace("'","");
thisfield.replace(",","");
thisfield.replace(";","");
// Avoid empty field names
if(thisfield.isEmpty())
thisfield = QString("field%1").arg(std::distance(csv.csv().at(0).begin(), it) + 1);
fieldList.push_back(sqlb::FieldPtr(new sqlb::Field(thisfield, "")));
}
} else {
for(size_t i=0; i < csv.columns(); ++i)
fieldList.push_back(sqlb::FieldPtr(new sqlb::Field(QString("field%1").arg(i+1), "")));
}
// Show progress dialog
QProgressDialog progress(tr("Inserting data..."), tr("Cancel"), 0, csv.csv().size());
progress.setWindowModality(Qt::ApplicationModal);
progress.show();
// Are we importing into an existing table?
bool importToExistingTable = false;
objectMap objects = pdb->getBrowsableObjects();
for(objectMap::ConstIterator i=objects.begin();i!=objects.end();++i)
{
if(i.value().gettype() == "table" && i.value().getname() == ui->editName->text())
{
if((size_t)i.value().table.fields().size() != csv.columns())
{
QMessageBox::warning(this, QApplication::applicationName(),
tr("There is already a table of that name and an import into an existing table is only possible if the number of columns match."));
return;
} else {
if(QMessageBox::question(this, QApplication::applicationName(), tr("There is already a table of that name. Do you want to import the data into it?"), QMessageBox::Yes, QMessageBox::No) == QMessageBox::Yes)
{
importToExistingTable = true;
break;
} else {
return;
}
}
}
}
// Create a savepoint, so we can rollback in case of any errors during importing
// db needs to be saved or an error will occur
QString restorepointName = QString("CSVIMPORT_%1").arg(QDateTime::currentMSecsSinceEpoch());
if(!pdb->setSavepoint(restorepointName))
return rollback(this, pdb, progress, restorepointName, 0, tr("Creating restore point failed: %1").arg(pdb->lastErrorMessage));
// Create table
if(!importToExistingTable)
{
if(!pdb->createTable(ui->editName->text(), fieldList))
return rollback(this, pdb, progress, restorepointName, 0, tr("Creating the table failed: %1").arg(pdb->lastErrorMessage));
}
// now lets import all data, one row at a time
for(CSVParser::TCSVResult::const_iterator it = itBegin;
it != csv.csv().end();
++it)
{
QString sql = QString("INSERT INTO `%1` VALUES(").arg(ui->editName->text());
QStringList insertlist;
for(QStringList::const_iterator jt = it->begin(); jt != it->end(); ++jt)
{
// need to mprintf here
char* formSQL = sqlite3_mprintf("%Q", (const char*)jt->toUtf8());
insertlist << formSQL;
if(formSQL)
sqlite3_free(formSQL);
}
// add missing fields with empty values
for(unsigned int i = insertlist.size(); i < csv.columns(); ++i)
{
qWarning() << "ImportCSV" << tr("Missing field for record %1").arg(std::distance(itBegin, it) + 1);
insertlist << "NULL";
}
sql.append(insertlist.join(QChar(',')));
sql.append(");");
if(!pdb->executeSQL(sql, false, false))
return rollback(this, pdb, progress, restorepointName, std::distance(itBegin, it) + 1, tr("Inserting row failed: %1").arg(pdb->lastErrorMessage));
// Update progress bar and check if cancel button was clicked
unsigned int prog = std::distance(csv.csv().begin(), it);
if(prog % 100 == 0)
progress.setValue(prog);
if(progress.wasCanceled())
return rollback(this, pdb, progress, restorepointName, std::distance(itBegin, it) + 1, "");
}
QApplication::restoreOverrideCursor(); // restore original cursor
QDialog::accept();
}
