/*
* Copyright (c) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2006,
* 2009, 2010, 2014, 2016
* Tama Communications Corporation
*
* This file is part of GNU GLOBAL.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#ifdef HAVE_CONFIG_H
#include
#endif
#include
#include
#include
#include
#include
#ifdef STDC_HEADERS
#include
#endif
#ifdef HAVE_STRING_H
#include
#else
#include
#endif
#ifdef HAVE_UNISTD_H
#include
#endif
#include
#include "char.h"
#include "checkalloc.h"
#include "dbop.h"
#include "die.h"
#include "env.h"
#include "locatestring.h"
#include "strbuf.h"
#include "strlimcpy.h"
#include "test.h"
#ifdef USE_SQLITE3
int is_sqlite3(const char *);
DBOP *dbop3_open(const char *, int, int, int);
const char *dbop3_get(DBOP *, const char *);
const char *dbop3_getflag(DBOP *);
char *dbop3_quote(char *);
void dbop3_put(DBOP *, const char *, const char *, const char *);
void dbop3_delete(DBOP *, const char *);
void dbop3_update(DBOP *, const char *, const char *);
const char *dbop3_first(DBOP *, const char *, regex_t *, int);
const char *dbop3_next(DBOP *);
void dbop3_close(DBOP *);
#endif
/**
* Though the prefix of the key of meta record is currently only a ' ' (blank),
* this will be enhanced in the future.
*/
#define ismeta(p) (*((char *)(p)) <= ' ')
/**
* Stuff for DBOP_SORTED_WRITE
*/
#define SORT_SEP '\t'
/**
* Two functions required for sorted writing.
*
* static void start_sort_process(DBOP *dbop)
* (1) start_sort_process: start sort process for sorted writing
*
* @param[in] dbop DBOP descriptor
*
* static void terminate_sort_process(DBOP *dbop)
* (2) terminate_sort_process: terminate sort process
*
* @param[in] dbop DBOP descriptor
*/
static void start_sort_process(DBOP *);
static void terminate_sort_process(DBOP *);
static char *sortnotfound = "POSIX sort program not found. If available, the program will be speed up.\nPlease see ./configure --help.";
/*
* 1. DJGPP/Windows
*/
#if defined(__DJGPP__) || defined(_WIN32)
/*
* Just ignored. DJGPP version doesn't use sorted writing; Windows (including
* Cygwin) is slightly quicker without it.
*/
static void
start_sort_process(DBOP *dbop) {
return;
}
static void
terminate_sort_process(DBOP *dbop) {
return;
}
/*
* 2. UNIX
*/
#else
#include
/*
* Though it doesn't understand why, GNU sort with no option is faster
* than 'sort -k 1,1'. But we should use '-k 1,1' here not to rely on
* a specific command.
*/
static char *argv[] = {
POSIX_SORT,
"-k",
"1,1",
NULL
};
static void
start_sort_process(DBOP *dbop) {
int opipe[2], ipipe[2];
if (!strcmp(POSIX_SORT, "no"))
return;
if (!test("fx", POSIX_SORT)) {
static int informed;
if (!informed) {
warning("%s", sortnotfound);
informed = 1;
}
return;
}
/*
* Setup pipe for two way communication
*
* Parent(gtags) Child(sort)
* ---------------------------------------------------
* (dbop->sortout) opipe[1] =====> opipe[0] (stdin)
* (dbop->sortin) ipipe[0] <===== ipipe[1] (stdout)
*/
if (pipe(opipe) < 0 || pipe(ipipe) < 0)
die("pipe(2) failed.");
dbop->pid = fork();
if (dbop->pid == 0) {
/* child process */
close(opipe[1]);
close(ipipe[0]);
if (dup2(opipe[0], 0) < 0 || dup2(ipipe[1], 1) < 0)
die("dup2(2) failed.");
close(opipe[0]);
close(ipipe[1]);
/*
* Use C locale in order to avoid the degradation of performance
* by internationalized sort command.
*/
set_env("LC_ALL", "C");
execvp(POSIX_SORT, argv);
die("cannot execute '%s'. (execvp failed)", POSIX_SORT);
} else if (dbop->pid < 0)
die("fork(2) failed.");
/* parent process */
close(opipe[0]);
close(ipipe[1]);
fcntl(ipipe[0], F_SETFD, FD_CLOEXEC);
fcntl(opipe[1], F_SETFD, FD_CLOEXEC);
dbop->sortout = fdopen(opipe[1], "w");
dbop->sortin = fdopen(ipipe[0], "r");
if (dbop->sortout == NULL || dbop->sortin == NULL)
die("fdopen(3) failed.");
}
static void
terminate_sort_process(DBOP *dbop) {
int ret, status;
while ((ret = waitpid(dbop->pid, &status, 0)) < 0 && errno == EINTR)
;
if (ret < 0)
die("waitpid(2) failed.");
if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)
die("terminated abnormally. '%s'", POSIX_SORT);
}
#endif
#ifdef USE_SQLITE3
static const char *sqlite_header = "SQLite format 3";
int
is_sqlite3(const char *path) {
char buf[32];
int sqlite3 = 0;
int fd = open(path, 0);
if (fd >= 0) {
if (read(fd, buf, sizeof(buf)) == sizeof(buf)) {
if (!strncmp(sqlite_header, buf, strlen(sqlite_header)))
sqlite3 = 1;
}
close(fd);
}
return sqlite3;
}
#endif
/**
* dbop_open: open db database.
*
* @param[in] path database name
* @param[in] mode 0: read only, 1: create, 2: modify
* @param[in] perm file permission
* @param[in] flags
* DBOP_DUP: allow duplicate records.
* DBOP_SORTED_WRITE: use sorted writing. This requires POSIX sort.
* @return descripter for dbop_xxx() or NULL
*
* Sorted wirting is fast because all writing is done by not insertion but addition.
*/
DBOP *
dbop_open(const char *path, int mode, int perm, int flags)
{
DB *db;
int rw = 0;
DBOP *dbop;
BTREEINFO info;
#ifdef USE_SQLITE3
if (mode != 1 && is_sqlite3(path))
flags |= DBOP_SQLITE3;
if (flags & DBOP_SQLITE3) {
dbop = dbop3_open(path, mode, perm, flags);
goto finish;
}
#endif
/*
* setup arguments.
*/
switch (mode) {
case 0:
rw = O_RDONLY;
break;
case 1:
rw = O_RDWR|O_CREAT|O_TRUNC;
break;
case 2:
rw = O_RDWR;
break;
default:
assert(0);
}
memset(&info, 0, sizeof(info));
if (flags & DBOP_DUP)
info.flags |= R_DUP;
info.psize = DBOP_PAGESIZE;
/*
* Decide cache size. The default value is 5MB.
* See libutil/gparam.h for the details.
*/
info.cachesize = GTAGSCACHE;
if (getenv("GTAGSCACHE") != NULL)
info.cachesize = atoi(getenv("GTAGSCACHE"));
if (info.cachesize < GTAGSMINCACHE)
info.cachesize = GTAGSMINCACHE;
/*
* if unlink do job normally, those who already open tag file can use
* it until closing.
*/
if (path != NULL && mode == 1 && test("f", path))
(void)unlink(path);
db = dbopen(path, rw, 0600, DB_BTREE, &info);
if (!db)
return NULL;
/*
* if file size == 0 then it should be corrupted.
*/
if (mode != 1) {
int fd = (*db->fd)(db);
struct stat stat;
if (fstat(fd, &stat) < 0)
die("fstat failed.");
if (stat.st_size == 0) {
errno = EFTYPE;
return NULL;
}
}
dbop = (DBOP *)check_calloc(sizeof(DBOP), 1);
if (path == NULL)
dbop->dbname[0] = '\0';
else
strlimcpy(dbop->dbname, path, sizeof(dbop->dbname));
dbop->db = db;
dbop->openflags = flags;
dbop->perm = (mode == 1) ? perm : 0;
dbop->lastdat = NULL;
dbop->lastsize = 0;
dbop->sortout = NULL;
dbop->sortin = NULL;
/*
* Setup sorted writing.
*/
if (mode != 0 && dbop->openflags & DBOP_SORTED_WRITE)
start_sort_process(dbop);
#ifdef USE_SQLITE3
finish:
#endif
return dbop;
}
/**
* dbop_get: get data by a key.
*
* @param[in] dbop descripter
* @param[in] name name
* @return pointer to data or NULL
*/
const char *
dbop_get(DBOP *dbop, const char *name)
{
DB *db = dbop->db;
DBT key, dat;
int status;
#ifdef USE_SQLITE3
if (dbop->openflags & DBOP_SQLITE3)
return dbop3_get(dbop, name);
#endif
key.data = (char *)name;
key.size = strlen(name)+1;
status = (*db->get)(db, &key, &dat, 0);
dbop->lastdat = (char *)dat.data;
dbop->lastsize = dat.size;
switch (status) {
case RET_SUCCESS:
break;
case RET_ERROR:
die("dbop_get failed.");
case RET_SPECIAL:
return (NULL);
}
return (dat.data);
}
/**
* dbop_put: put data by a key.
*
* @param[in] dbop descripter
* @param[in] name key
* @param[in] data data
*/
void
dbop_put(DBOP *dbop, const char *name, const char *data)
{
DB *db = dbop->db;
DBT key, dat;
int status;
int len;
#ifdef USE_SQLITE3
if (dbop->openflags & DBOP_SQLITE3) {
dbop3_put(dbop, name, data, NULL);
return;
}
#endif
if (!(len = strlen(name)))
die("primary key size == 0.");
if (len > MAXKEYLEN)
die("primary key too long.");
/* sorted writing */
if (dbop->sortout != NULL) {
fputs(name, dbop->sortout);
putc(SORT_SEP, dbop->sortout);
fputs(data, dbop->sortout);
putc('\n', dbop->sortout);
return;
}
key.data = (char *)name;
key.size = len+1;
dat.data = (char *)data;
dat.size = strlen(data)+1;
status = (*db->put)(db, &key, &dat, 0);
switch (status) {
case RET_SUCCESS:
break;
case RET_ERROR:
case RET_SPECIAL:
die("%s", dbop->put_errmsg ? dbop->put_errmsg : "dbop_put failed.");
}
}
/**
* dbop_put_tag: put a tag
*
* @param[in] dbop descripter
* @param[in] name key
* @param[in] data data
*/
void
dbop_put_tag(DBOP *dbop, const char *name, const char *data)
{
#ifdef USE_SQLITE3
if (dbop->openflags & DBOP_SQLITE3) {
int len;
char fid[MAXFIDLEN], *q = fid;
const char *p = data;
/* extract fid */
while (*p && isdigit(*p))
*q++ = *p++;
*q = '\0';
/* trim line */
len = strlen(data);
if (data[len-1] == '\n')
len--;
if (data[len-1] == '\r')
len--;
if (data[len] == '\r' || data[len] == '\n') {
STATIC_STRBUF(sb);
strbuf_clear(sb);
strbuf_nputs(sb, data, len);
data = strbuf_value(sb);
}
dbop3_put(dbop, name, data, fid);
return;
}
#endif
dbop_put(dbop, name, data);
return;
}
/**
* dbop_put_path: put data and flag by a key.
*
* @param[in] dbop descripter
* @param[in] name key
* @param[in] data data
* @param[in] flag flag
*
* [Note] This function doesn't support sorted writing.
*/
void
dbop_put_path(DBOP *dbop, const char *name, const char *data, const char *flag)
{
STATIC_STRBUF(sb);
DB *db = dbop->db;
DBT key, dat;
int status;
int len;
#ifdef USE_SQLITE3
if (dbop->openflags & DBOP_SQLITE3) {
dbop3_put(dbop, name, data, flag);
return;
}
#endif
if (!(len = strlen(name)))
die("primary key size == 0.");
if (len > MAXKEYLEN)
die("primary key too long.");
strbuf_clear(sb);
strbuf_puts0(sb, data);
if (flag)
strbuf_puts0(sb, flag);
key.data = (char *)name;
key.size = len+1;
dat.data = strbuf_value(sb);
dat.size = strbuf_getlen(sb);
status = (*db->put)(db, &key, &dat, 0);
switch (status) {
case RET_SUCCESS:
break;
case RET_ERROR:
case RET_SPECIAL:
die("%s", dbop->put_errmsg ? dbop->put_errmsg : "dbop_put_path failed.");
}
}
/**
* dbop_delete: delete record by path name.
*
* @param[in] dbop descripter
* @param[in] path path name
*/
void
dbop_delete(DBOP *dbop, const char *path)
{
DB *db = dbop->db;
DBT key;
int status;
#ifdef USE_SQLITE3
if (dbop->openflags & DBOP_SQLITE3) {
dbop3_delete(dbop, path);
return;
}
#endif
if (path) {
key.data = (char *)path;
key.size = strlen(path)+1;
status = (*db->del)(db, &key, 0);
} else
status = (*db->del)(db, &key, R_CURSOR);
if (status == RET_ERROR)
die("dbop_delete failed.");
}
/**
* dbop_update: update record.
*
* @param[in] dbop descripter
* @param[in] key key
* @param[in] dat data
*/
void
dbop_update(DBOP *dbop, const char *key, const char *dat)
{
#ifdef USE_SQLITE3
if (dbop->openflags & DBOP_SQLITE3)
return dbop3_update(dbop, key, dat);
#endif
dbop_put(dbop, key, dat);
}
/**
* dbop_first: get first record.
*
* @param[in] dbop dbop descripter
* @param[in] name key value or prefix,
* !=NULL: indexed read by key,
* ==NULL: sequential read
* @param[in] preg compiled regular expression if any.
* @param[in] flags following dbop_next call take over this.
* DBOP_KEY: read key part,
* DBOP_PREFIX: prefix read; only valid when sequential read
* @return data or NULL
*/
const char *
dbop_first(DBOP *dbop, const char *name, regex_t *preg, int flags)
{
DB *db = dbop->db;
DBT key, dat;
int status;
int len;
dbop->preg = preg;
dbop->ioflags = flags;
if (flags & DBOP_PREFIX && !name)
flags &= ~DBOP_PREFIX;
#ifdef USE_SQLITE3
if (dbop->openflags & DBOP_SQLITE3)
return dbop3_first(dbop, name, preg, flags);
#endif
if (name) {
if ((len = strlen(name)) > MAXKEYLEN)
die("primary key too long.");
strlimcpy(dbop->key, name, sizeof(dbop->key));
key.data = (char *)name;
key.size = len;
/*
* includes NULL character unless prefix read.
*/
if (!(flags & DBOP_PREFIX))
key.size++;
dbop->keylen = key.size;
for (status = (*db->seq)(db, &key, &dat, R_CURSOR);
status == RET_SUCCESS;
status = (*db->seq)(db, &key, &dat, R_NEXT)) {
dbop->readcount++;
if (flags & DBOP_PREFIX) {
if (strncmp((char *)key.data, dbop->key, dbop->keylen))
return NULL;
} else {
if (strcmp((char *)key.data, dbop->key))
return NULL;
}
if (preg && regexec(preg, (char *)key.data, 0, 0, 0) != 0)
continue;
break;
}
} else {
dbop->keylen = dbop->key[0] = 0;
for (status = (*db->seq)(db, &key, &dat, R_FIRST);
status == RET_SUCCESS;
status = (*db->seq)(db, &key, &dat, R_NEXT)) {
dbop->readcount++;
/* skip meta records */
if (ismeta(key.data) && !(dbop->openflags & DBOP_RAW))
continue;
if (preg && regexec(preg, (char *)key.data, 0, 0, 0) != 0)
continue;
break;
}
}
dbop->lastdat = (char *)dat.data;
dbop->lastsize = dat.size;
dbop->lastkey = (char *)key.data;
dbop->lastkeysize = key.size;
switch (status) {
case RET_SUCCESS:
break;
case RET_ERROR:
die("dbop_first failed.");
case RET_SPECIAL:
return (NULL);
}
if (flags & DBOP_KEY) {
strlimcpy(dbop->prev, (char *)key.data, sizeof(dbop->prev));
return (char *)key.data;
}
return ((char *)dat.data);
}
/**
* dbop_next: get next record.
*
* @param[in] dbop dbop descripter
* @return data or NULL
*
* [Note] dbop_next() always skip meta records.
*/
const char *
dbop_next(DBOP *dbop)
{
DB *db = dbop->db;
int flags = dbop->ioflags;
DBT key, dat;
int status;
if (dbop->unread) {
dbop->unread = 0;
return dbop->lastdat;
}
#ifdef USE_SQLITE3
if (dbop->openflags & DBOP_SQLITE3)
return dbop3_next(dbop);
#endif
while ((status = (*db->seq)(db, &key, &dat, R_NEXT)) == RET_SUCCESS) {
dbop->readcount++;
assert(dat.data != NULL);
/* skip meta records */
if (!(dbop->openflags & DBOP_RAW)) {
if (flags & DBOP_KEY && ismeta(key.data))
continue;
else if (ismeta(dat.data))
continue;
}
if (flags & DBOP_KEY) {
if (!strcmp(dbop->prev, (char *)key.data))
continue;
if (strlen((char *)key.data) > MAXKEYLEN)
die("primary key too long.");
strlimcpy(dbop->prev, (char *)key.data, sizeof(dbop->prev));
}
dbop->lastdat = (char *)dat.data;
dbop->lastsize = dat.size;
dbop->lastkey = (char *)key.data;
dbop->lastkeysize = key.size;
if (flags & DBOP_PREFIX) {
if (strncmp((char *)key.data, dbop->key, dbop->keylen))
return NULL;
} else if (dbop->keylen) {
if (strcmp((char *)key.data, dbop->key))
return NULL;
}
if (dbop->preg && regexec(dbop->preg, (char *)key.data, 0, 0, 0) != 0)
continue;
return (flags & DBOP_KEY) ? (char *)key.data : (char *)dat.data;
}
if (status == RET_ERROR)
die("dbop_next failed.");
return NULL;
}
/**
* dbop_unread: unread record to read again.
*
* @param[in] dbop dbop descripter
*
* [Note] dbop_next() will read this record later.
*/
void
dbop_unread(DBOP *dbop)
{
dbop->unread = 1;
}
/**
* dbop_lastdat: get last data
*
* @param[in] dbop dbop descripter
* @param[out] size
* @return last data
*/
const char *
dbop_lastdat(DBOP *dbop, int *size)
{
if (size)
*size = dbop->lastsize;
return dbop->lastdat;
}
/**
* get_flag: get flag value
*
* [Note] Will return an empty string (not NULL), if not found/can't get.
*/
const char *
dbop_getflag(DBOP *dbop)
{
int size;
const char *dat = dbop_lastdat(dbop, &size);
const char *flag = "";
#ifdef USE_SQLITE3
if (dbop->openflags & DBOP_SQLITE3)
return dbop3_getflag(dbop);
#endif
/*
* Dat format is like follows.
* dat 'xxxxxxx\0ffff\0'
* (data) (flag)
*/
if (dat) {
int i = strlen(dat) + 1;
if (size > i)
flag = dat + i;
}
return flag;
}
/**
* dbop_getoption: get option
*
* @return the option's value or NULL
*/
const char *
dbop_getoption(DBOP *dbop, const char *key)
{
static char buf[1024];
const char *p;
int keysize;
if ((p = dbop_get(dbop, key)) == NULL)
return NULL;
keysize = strlen(key);
if (dbop->lastsize < keysize)
die("invalid format (dbop_getoption).");
for (p += keysize; *p && isspace((unsigned char)*p); p++)
;
strlimcpy(buf, p, sizeof(buf));
return buf;
}
/**
* dbop_putoption: put option
*/
void
dbop_putoption(DBOP *dbop, const char *key, const char *string)
{
char buf[1024];
if (string)
snprintf(buf, sizeof(buf), "%s %s", key, string);
else
snprintf(buf, sizeof(buf), "%s", key);
dbop_put(dbop, key, buf);
}
/**
* dbop_getversion: get format version
*/
int
dbop_getversion(DBOP *dbop)
{
int format_version = 1; /* default format version */
const char *p;
if ((p = dbop_getoption(dbop, VERSIONKEY)) != NULL)
format_version = atoi(p);
return format_version;
}
/**
* dbop_putversion: put format version
*/
void
dbop_putversion(DBOP *dbop, int version)
{
char number[32];
snprintf(number, sizeof(number), "%d", version);
dbop_putoption(dbop, VERSIONKEY, number);
}
/**
* dbop_close: close db
*
* @param[in] dbop dbop descripter
*/
void
dbop_close(DBOP *dbop)
{
DB *db = dbop->db;
/*
* Load sorted tag records and write them to the tag file.
*/
if (dbop->sortout != NULL) {
STRBUF *sb = strbuf_open(256);
char *p;
/*
* End of the former stage of sorted writing.
* fclose() and sortout = NULL is important.
*
* fclose(): enables reading from sortin descriptor.
* sortout = NULL: makes the following dbop_put write to the tag file directly.
*/
fclose(dbop->sortout);
dbop->sortout = NULL;
/*
* The last stage of sorted writing.
*/
while (strbuf_fgets(sb, dbop->sortin, STRBUF_NOCRLF)) {
for (p = strbuf_value(sb); *p && *p != SORT_SEP; p++)
;
if (!*p)
die("unexpected end of record.");
*p++ = '\0';
dbop_put(dbop, strbuf_value(sb), p);
}
fclose(dbop->sortin);
strbuf_close(sb);
terminate_sort_process(dbop);
}
#ifdef USE_SQLITE3
if (dbop->openflags & DBOP_SQLITE3) {
dbop3_close(dbop);
return;
}
#endif
#ifdef USE_DB185_COMPAT
(void)db->close(db);
#else
/*
* If dbname = NULL, omit writing to the disk in __bt_close().
*/
(void)db->close(db, dbop->dbname[0] == '\0' ? 1 : 0);
#endif
if (dbop->dbname[0] != '\0') {
if (dbop->perm && chmod(dbop->dbname, dbop->perm) < 0)
die("chmod(2) failed.");
}
(void)free(dbop);
}
#ifdef USE_SQLITE3
DBOP *
dbop3_open(const char *path, int mode, int perm, int flags) {
int rc, rw = 0;
char *errmsg = 0;
DBOP *dbop;
sqlite3 *db3;
const char *tblname;
int cache_size = 0;
STRBUF *sql = strbuf_open_tempbuf();
char buf[1024];
/*
* When the path is NULL string and private, temporary file is used.
* The database will be removed when the session is closed.
*/
if (path == NULL) {
path = "";
tblname = "temp";
} else {
/*
* In case of creation.
*/
if (mode == 1) {
#ifndef _WIN32
(void)truncate(path, 0);
#else
FILE* f = fopen(path, "w");
if (f)
fclose(f);
#endif
}
tblname = "db";
}
/*
* setup arguments.
*/
switch (mode) {
case 0:
rw = SQLITE_OPEN_READONLY;
break;
case 1:
rw = SQLITE_OPEN_CREATE|SQLITE_OPEN_READWRITE;
break;
case 2:
rw = SQLITE_OPEN_READWRITE;
break;
default:
assert(0);
}
/*
* When the fourth argument is NULL, sqlite3_vfs is used.
*/
rc = sqlite3_open_v2(path, &db3, rw, NULL);
if (rc != SQLITE_OK)
die("sqlite3_open_v2 failed. (rc = %d)", rc);
dbop = (DBOP *)check_calloc(sizeof(DBOP), 1);
strlimcpy(dbop->dbname, path, sizeof(dbop->dbname));
dbop->sb = strbuf_open(0);
dbop->db3 = db3;
dbop->openflags = flags;
dbop->perm = (mode == 1) ? perm : 0;
dbop->mode = mode;
dbop->lastdat = NULL;
dbop->lastflag = NULL;
dbop->lastsize = 0;
dbop->sortout = NULL;
dbop->sortin = NULL;
dbop->stmt = NULL;
dbop->tblname = check_strdup(tblname);
/*
* Maximum file size is DBOP_PAGESIZE * 2147483646.
* if DBOP_PAGESIZE == 8192 then maximum file size is 17592186028032 (17T).
*/
snprintf(buf, sizeof(buf), "pragma page_size=%d", DBOP_PAGESIZE);
rc = sqlite3_exec(dbop->db3, buf, NULL, NULL, &errmsg);
if (rc != SQLITE_OK)
die("pragma page_size error: %s", errmsg);
/*
* create table (GTAGS, GRTAGS, GSYMS, GPATH).
*/
if (mode == 1) {
/* drop table */
strbuf_clear(sql);
strbuf_puts(sql, "drop table ");
strbuf_puts(sql, dbop->tblname);
rc = sqlite3_exec(dbop->db3, strbuf_value(sql), NULL, NULL, &errmsg);
if (rc != SQLITE_OK) {
/* ignore */
}
/* create table */
strbuf_clear(sql);
strbuf_puts(sql, "create table ");
strbuf_puts(sql, dbop->tblname);
strbuf_puts(sql, " (key text, dat text, extra text");
if (!(flags & DBOP_DUP))
strbuf_puts(sql, ", primary key(key)");
strbuf_putc(sql, ')');
rc = sqlite3_exec(dbop->db3, strbuf_value(sql), NULL, NULL, &errmsg);
if (rc != SQLITE_OK)
die("create table error: %s", errmsg);
}
/*
rc = sqlite3_exec(dbop->db3, "pragma synchronous=off", NULL, NULL, &errmsg);
if (rc != SQLITE_OK)
die("pragma synchronous=off error: %s", errmsg);
*/
/*
* Decide cache size.
* See libutil/gparam.h for the details.
*/
cache_size = GTAGSCACHE;
if (getenv("GTAGSCACHE") != NULL)
cache_size = atoi(getenv("GTAGSCACHE"));
if (cache_size < GTAGSMINCACHE)
cache_size = GTAGSMINCACHE;
cache_size = (cache_size + DBOP_PAGESIZE - 1) / DBOP_PAGESIZE;
snprintf(buf, sizeof(buf), "pragma cache_size=%d", cache_size);
rc = sqlite3_exec(dbop->db3, buf, NULL, NULL, &errmsg);
if (rc != SQLITE_OK)
die("pragma cache_size error: %s", errmsg);
sqlite3_exec(dbop->db3, "pragma journal_mode=memory", NULL, NULL, &errmsg);
if (rc != SQLITE_OK)
die("pragma journal_mode=memory error: %s", errmsg);
sqlite3_exec(dbop->db3, "pragma synchronous=off", NULL, NULL, &errmsg);
if (rc != SQLITE_OK)
die("pragma synchronous=off error: %s", errmsg);
rc = sqlite3_exec(dbop->db3, "begin transaction", NULL, NULL, &errmsg);
if (rc != SQLITE_OK)
die("begin transaction error: %s", errmsg);
strbuf_release_tempbuf(sql);
return dbop;
}
static int
single_select_callback(void *v, int argc, char **argv, char **colname) {
STATIC_STRBUF(sb);
DBOP *dbop = (DBOP *)v;
if (argc > 0) {
strbuf_clear(sb);
strbuf_puts(sb, argv[0]);
dbop->lastsize = strbuf_getlen(sb);
if (argv[1]) {
strbuf_putc(sb, '\0');
strbuf_puts(sb, argv[1]);
}
dbop->lastdat = strbuf_value(sb);
dbop->lastflag = argv[1] ? dbop->lastdat + dbop->lastsize + 1 : NULL;
} else {
dbop->lastdat = NULL;
dbop->lastflag = NULL;
dbop->lastsize = 0;
}
return SQLITE_OK;
}
const char *
dbop3_get(DBOP *dbop, const char *name) {
int rc;
char *errmsg = 0;
STRBUF *sql = strbuf_open_tempbuf();
strbuf_sprintf(sql, "select dat, extra from %s where key = '%s' limit 1",
dbop->tblname, name);
dbop->lastdat = NULL;
dbop->lastsize = 0;
dbop->lastflag = NULL;
rc = sqlite3_exec(dbop->db3, strbuf_value(sql), single_select_callback, dbop, &errmsg);
if (rc != SQLITE_OK) {
sqlite3_close(dbop->db3);
die("dbop3_get failed: %s", errmsg);
}
strbuf_release_tempbuf(sql);
return dbop->lastdat;
}
const char *
dbop3_getflag(DBOP *dbop)
{
return dbop->lastflag ? dbop->lastflag : "";
}
char *
dbop3_quote(char *string) {
STATIC_STRBUF(sb);
char *p;
strbuf_clear(sb);
for (p = string; *p; p++) {
if (*p == '\'')
strbuf_putc(sb, '\'');
strbuf_putc(sb, *p);
}
return strbuf_value(sb);
}
void
dbop3_put(DBOP *dbop, const char *p1, const char *p2, const char *p3) {
int rc, len;
char *errmsg = 0;
STRBUF *sql = strbuf_open_tempbuf();
if (!(len = strlen(p1)))
die("primary key size == 0.");
if (len > MAXKEYLEN)
die("primary key too long.");
if (dbop->stmt_put3 == NULL) {
strbuf_sprintf(sql, "insert into %s values (?, ?, ?)", dbop->tblname);
rc = sqlite3_prepare_v2(dbop->db3, strbuf_value(sql), -1, &dbop->stmt_put3, NULL);
if (rc != SQLITE_OK) {
die("dbop3_put prepare failed. (rc = %d, sql = %s)", rc, strbuf_value(sql));
}
}
rc = sqlite3_bind_text(dbop->stmt_put3, 1, p1, -1, SQLITE_STATIC);
if (rc != SQLITE_OK) {
die("dbop3_put 1 failed. (rc = %d)", rc);
}
rc = sqlite3_bind_text(dbop->stmt_put3, 2, p2, -1, SQLITE_STATIC);
if (rc != SQLITE_OK) {
die("dbop3_put 2 failed. (rc = %d)", rc);
}
rc = sqlite3_bind_text(dbop->stmt_put3, 3, p3, -1, SQLITE_STATIC);
if (rc != SQLITE_OK) {
die("dbop3_put 3 failed. (rc = %d)", rc);
}
rc = sqlite3_step(dbop->stmt_put3);
if (rc != SQLITE_DONE) {
die("dbop3_put failed. (rc = %d)", rc);
}
rc = sqlite3_reset(dbop->stmt_put3);
if (rc != SQLITE_OK) {
die("dbop3_put reset failed. (rc = %d)", rc);
}
if (dbop->writecount++ > DBOP_COMMIT_THRESHOLD) {
dbop->writecount = 0;
rc = sqlite3_exec(dbop->db3, "end transaction", NULL, NULL, &errmsg);
if (rc != SQLITE_OK)
die("end transaction error: %s", errmsg);
rc = sqlite3_exec(dbop->db3, "begin transaction", NULL, NULL, &errmsg);
if (rc != SQLITE_OK)
die("begin transaction error: %s", errmsg);
}
strbuf_release_tempbuf(sql);
}
void
dbop3_delete(DBOP *dbop, const char *path) {
int rc;
char *errmsg = 0;
STRBUF *sql = strbuf_open_tempbuf();
strbuf_puts(sql, "delete from ");
strbuf_puts(sql, dbop->tblname);
strbuf_puts(sql, " where");
if (path) {
if (*path == '(') {
strbuf_puts(sql, " extra in ");
strbuf_puts(sql, path);
} else {
strbuf_puts(sql, " key = '");
strbuf_puts(sql, path);
strbuf_puts(sql, "'");
}
} else {
strbuf_puts(sql, " rowid = ");
strbuf_putn64(sql, dbop->lastrowid);
}
rc = sqlite3_exec(dbop->db3, strbuf_value(sql), NULL, NULL, &errmsg);
if (rc != SQLITE_OK) {
sqlite3_close(dbop->db3);
die("dbop3_delete failed: %s", errmsg);
}
strbuf_release_tempbuf(sql);
}
void
dbop3_update(DBOP *dbop, const char *key, const char *dat) {
int rc;
char *errmsg = 0;
STRBUF *sql = strbuf_open_tempbuf();
strbuf_sprintf(sql, "update %s set dat = '%s' where key = '%s'",
dbop->tblname, dbop3_quote((char *)dat), key);
rc = sqlite3_exec(dbop->db3, strbuf_value(sql), NULL, NULL, &errmsg);
if (rc != SQLITE_OK) {
sqlite3_close(dbop->db3);
die("dbop3_update failed: %s", errmsg);
}
if (sqlite3_changes(dbop->db3) == 0) {
strbuf_clear(sql);
strbuf_sprintf(sql, "insert into %s values ('%s', '%s', NULL)",
dbop->tblname, key, dbop3_quote((char *)dat));
rc = sqlite3_exec(dbop->db3, strbuf_value(sql), NULL, NULL, &errmsg);
if (rc != SQLITE_OK) {
sqlite3_close(dbop->db3);
die("dbop3_updated failed: %s", errmsg);
}
}
strbuf_release_tempbuf(sql);
}
const char *
dbop3_first(DBOP *dbop, const char *name, regex_t *preg, int flags) {
int rc;
char *key;
STRBUF *sql = strbuf_open_tempbuf();
dbop->done = 0; /* This is turned on when it receives SQLITE_DONE. */
strbuf_puts(sql, "select rowid, * from ");
strbuf_puts(sql, dbop->tblname);
if (name) {
strbuf_puts(sql, " where key ");
if (dbop->ioflags & DBOP_PREFIX) {
/*
* In sqlite3, 'like' ignores case. 'glob' does not ignore case.
*/
strbuf_puts(sql, "glob '");
strbuf_puts(sql, name);
strbuf_puts(sql, "*'");
} else {
strbuf_puts(sql, "= '");
strbuf_puts(sql, name);
strbuf_puts(sql, "'");
}
strlimcpy(dbop->key, name, sizeof(dbop->key));
dbop->keylen = strlen(name);
}
strbuf_puts(sql, " order by key");
if (dbop->stmt) {
rc = sqlite3_finalize(dbop->stmt);
if (rc != SQLITE_OK)
die("dbop3_finalize failed. (rc = %d)", rc);
dbop->stmt = NULL;
}
rc = sqlite3_prepare_v2(dbop->db3, strbuf_value(sql), -1, &dbop->stmt, NULL);
if (rc != SQLITE_OK)
die("dbop3_first: sqlite3_prepare_v2 failed. (rc = %d)", rc);
/*
* 0: rowid
* 1: key
* 2: dat
* 3: flags
*/
for (;;) {
/* Once it receives SQLITE_DONE, do not never return value */
if (dbop->done)
return NULL;
rc = sqlite3_step(dbop->stmt);
if (rc == SQLITE_DONE)
goto finish;
else if (rc == SQLITE_ROW) {
dbop->readcount++;
dbop->lastrowid = sqlite3_column_int64(dbop->stmt, 0);
key = (char *)sqlite3_column_text(dbop->stmt, 1);
if (name) {
if (dbop->ioflags & DBOP_PREFIX) {
if (strncmp(key, dbop->key, dbop->keylen))
goto finish;
} else {
if (strcmp(key, dbop->key))
goto finish;
}
if (dbop->preg && regexec(dbop->preg, key, 0, 0, 0) != 0)
continue;
} else {
/* skip meta records */
if (ismeta(key) && !(dbop->openflags & DBOP_RAW))
continue;
if (dbop->preg && regexec(dbop->preg, key, 0, 0, 0) != 0)
continue;
}
break;
} else {
die("dbop3_first: something is wrong (rc = %d).", rc);
}
}
strbuf_clear(dbop->sb);
strbuf_puts0(dbop->sb, (char *)sqlite3_column_text(dbop->stmt, 2));
dbop->lastsize = strbuf_getlen(dbop->sb) - 1;
dbop->lastflag = (char *)sqlite3_column_text(dbop->stmt, 3);
if (dbop->lastflag)
strbuf_puts(dbop->sb, dbop->lastflag);
dbop->lastdat = strbuf_value(dbop->sb);
if (dbop->lastflag)
dbop->lastflag = dbop->lastdat + dbop->lastsize + 1;
dbop->lastkey = key;
dbop->lastkeysize = strlen(dbop->lastkey);
strbuf_release_tempbuf(sql);
if (flags & DBOP_KEY) {
strlimcpy(dbop->prev, key, sizeof(dbop->prev));
return key;
}
return dbop->lastdat;
finish:
strbuf_release_tempbuf(sql);
dbop->done = 1;
dbop->lastdat = NULL;
dbop->lastsize = 0;
dbop->lastflag = NULL;
return dbop->lastdat;
}
const char *
dbop3_next(DBOP *dbop) {
int rc;
char *key, *dat;
/*
* 0: rowid
* 1: key
* 2: dat
* 3: flags
*/
for (;;) {
/* Once it receives SQLITE_DONE, do not never return value */
if (dbop->done)
return NULL;
rc = sqlite3_step(dbop->stmt);
if (rc == SQLITE_DONE)
goto finish;
else if (rc == SQLITE_ROW) {
dbop->readcount++;
dbop->lastrowid = sqlite3_column_int64(dbop->stmt, 0);
key = (char *)sqlite3_column_text(dbop->stmt, 1);
dat = (char *)sqlite3_column_text(dbop->stmt, 2);
/* skip meta records */
if (!(dbop->openflags & DBOP_RAW)) {
if (dbop->ioflags & DBOP_KEY && ismeta(key))
continue;
else if (ismeta(dat))
continue;
}
if (dbop->ioflags & DBOP_KEY) {
if (!strcmp(dbop->prev, key))
continue;
if (strlen(key) > MAXKEYLEN)
die("primary key too long.");
strlimcpy(dbop->prev, key, sizeof(dbop->prev));
}
if (dbop->ioflags & DBOP_PREFIX) {
if (strncmp(key, dbop->key, dbop->keylen))
goto finish;
} else if (dbop->keylen) {
if (strcmp(key, dbop->key))
goto finish;
}
if (dbop->preg && regexec(dbop->preg, key, 0, 0, 0) != 0)
continue;
break;
} else {
die("dbop3_next: something is wrong (rc = %d).", rc);
}
}
strbuf_clear(dbop->sb);
strbuf_puts0(dbop->sb, (char *)sqlite3_column_text(dbop->stmt, 2));
dbop->lastsize = strbuf_getlen(dbop->sb) - 1;
dbop->lastflag = (char *)sqlite3_column_text(dbop->stmt, 3);
if (dbop->lastflag)
strbuf_puts(dbop->sb, dbop->lastflag);
dbop->lastdat = strbuf_value(dbop->sb);
if (dbop->lastflag)
dbop->lastflag = dbop->lastdat + dbop->lastsize + 1;
dbop->lastkey = key;
dbop->lastkeysize = strlen(dbop->lastkey);
if (dbop->ioflags & DBOP_KEY) {
strlimcpy(dbop->prev, key, sizeof(dbop->prev));
return key;
}
return dbop->lastdat;
finish:
dbop->done = 1;
dbop->lastdat = NULL;
dbop->lastsize = 0;
return dbop->lastdat;
}
void
dbop3_close(DBOP *dbop) {
int rc;
char *errmsg = 0;
rc = sqlite3_exec(dbop->db3, "end transaction", NULL, NULL, &errmsg);
if (rc != SQLITE_OK)
die("end transaction error: %s", errmsg);
/*
* create index
*/
if (dbop->mode == 1 && dbop->openflags & DBOP_DUP) {
STATIC_STRBUF(sql);
strbuf_clear(sql);
strbuf_puts(sql, "create index key_i on ");
strbuf_puts(sql, dbop->tblname);
strbuf_puts(sql, "(key)");
rc = sqlite3_exec(dbop->db3, strbuf_value(sql), NULL, NULL, &errmsg);
if (rc != SQLITE_OK)
die("create index error: %s", errmsg);
strbuf_clear(sql);
strbuf_puts(sql, "create index fid_i on ");
strbuf_puts(sql, dbop->tblname);
strbuf_puts(sql, "(extra)");
rc = sqlite3_exec(dbop->db3, strbuf_value(sql), NULL, NULL, &errmsg);
if (rc != SQLITE_OK)
die("create index error: %s", errmsg);
}
if (dbop->stmt) {
rc = sqlite3_finalize(dbop->stmt);
if (rc != SQLITE_OK)
die("sqlite3_finalize failed. (rc = %d)", rc);
dbop->stmt = NULL;
}
if (dbop->stmt_put3) {
rc = sqlite3_finalize(dbop->stmt_put3);
if (rc != SQLITE_OK)
die("dbop3_finalize failed. (rc = %d)", rc);
dbop->stmt_put3 = NULL;
}
rc = sqlite3_close(dbop->db3);
if (rc != SQLITE_OK)
die("sqlite3_close failed. (rc = %d)", rc);
dbop->db3 = NULL;
if (dbop->tblname)
free((void *)dbop->tblname);
strbuf_close(dbop->sb);
free(dbop);
}
#endif /* USE_SQLITE3 */