XTDBError
XTDBInitHandle(const char* dbName,const char* dir,XTDBHandle** out) {
XTDBError rv;
XTDBHandle* h = malloc(sizeof(XTDBHandle));
int rc;
//InitQueryModule();
if (!h) {
return XTDB_NO_MEM;
}
memset(h,0,sizeof(*h));
StrInit(&h->dbName);
if (StrAppend(&h->dbName,dbName)) {
rv = XTDB_NO_MEM;
goto error;
}
StrInit(&h->dataDir);
if (StrAppend(&h->dataDir,dir)) {
rv = XTDB_NO_MEM;
goto error;
}
StrInit(&h->descName);
if (StrAppendFmt(&h->descName,"%s/%s.desc",dir,dbName)) {
rv = XTDB_NO_MEM;
goto error;
}
StrInit(&h->mainDbFileName);
if (StrAppendFmt(&h->mainDbFileName,"%s/%s.main.data",dir,dbName)) {
rv = XTDB_NO_MEM;
goto error;
}
h->indexes = tcmapnew2(23);
if (!h->indexes) {
rv = XTDB_NO_MEM;
goto error;
}
//h->indexes = hash_table_new(stringhash,string_equal);
//hash_table_register_free_functions(h->indexes,free,NULL);
if (!(h->mainDB = DBInit(h->mainDbFileName.ptr,BDBOCREAT|BDBOWRITER))) {
rv = XTDB_NO_MEM;
goto error;
}
if (!(rc=DBOpen(h->mainDB,BDBOCREAT|BDBOWRITER))) {
rv = DBGetLastError(h->mainDB);
goto error;
}
if (!XTDBLoadIndexes(h)) {
rv = h->error;
goto error;
}
*out = h;
return XTDB_OK;
error:
XTDBFreeHandle(h);
*out = NULL;
return rv;
}
int myfunc(jual_xapi *JXAPI)
{
void *L = JXAPI->LS;
// Map functions as required
defGetNumber *GetNumber = (defGetNumber *)JXAPI->fnGetNumber;
defGetString *GetString = (defGetString *)JXAPI->fnGetString;
defGetObject *GetObject = (defGetObject *)JXAPI->fnGetObject;
defNumberPush *NumberPush = (defNumberPush *)JXAPI->fnNumberPush;
defStrInit *StrInit = (defStrInit *)JXAPI->fnStrInit;
defStrAppend *StrAppend = (defStrAppend *)JXAPI->fnStrAppend;
defStrPush *StrPush = (defStrPush *)JXAPI->fnStrPush;
int iNum = GetNumber(L, 1);
size_t tSize;
const char *szParm2 = GetString(L, 2, &tSize);
printf("you entered %d %s %d\n", iNum, szParm2, tSize);
char strBuffer[JXAPI->STRBUFFER_SIZE];
char *cResult = StrInit(L, strBuffer, 16);
const char text[]="Hello from the C language";
StrAppend(strBuffer, text, sizeof(text)-1);
const char text2[]="More greeting from the C language";
StrAppend(strBuffer, text2, sizeof(text2)-1);
StrPush(strBuffer);
return 1;
}
int StrAssign(HString *hstr, const char *str)
{
int slen = strlen(str);
StrInit(hstr, slen);
memcpy(hstr->ch, str, slen);
return 1;
}
int StrCopy(HString *dst, HString *src)
{
if(StrEmpty(src)){
ClearString(dst);
return 1;
}
StrInit(dst, src->len);
memcpy(dst->ch, src->ch, src->len);
return 1;
}
int SubString(HString *sub, HString *src, int pos, int len)
{
if(pos>=src->len || pos+len>src->len) return 0;
StrInit(sub, len);
int i = 0, j = 0;
for(i=pos,j=0; j<len; i++,j++){
*(sub->ch+j) = *(src->ch+i);
}
return 1;
}
//添加字符串到尾部
int StrAppend(HString *hs, const char *_str) {
int _len = strlen(_str);
if(StrEmpty(hs)){
StrInit(hs, _len);
}
int _s_len = StrLength(hs);
hs->ch = (char *)realloc(hs->ch, _s_len + _len);
strncpy(hs->ch+_s_len, _str, _len);
hs->len += _len ;
return 1;
}
int Concat(HString *dst,HString *hstr1,HString *hstr2){
int _len = hstr1->len + hstr2->len;
StrInit(dst, _len);
int i=0;
if(!StrEmpty(hstr1)){
for(i=0; i<hstr1->len; i++){
*( dst->ch + i ) = *( hstr1->ch + i ) ;
}
}
if(!StrEmpty(hstr2)){
for(i=0; i<hstr2->len; i++){
*( dst->ch + hstr1->len + i ) = *( hstr2->ch + i ) ;
}
}
return 1;
}
function friendlyCall(num,str){return ffi_call(ffi_func1,num,str)};\n\
";
// **
// init function name must always be in the format of <module name>_init
// the init function must always return 0
// **
int modsample_init(jual_xapi *JXAPI) {
void *L = JXAPI->LS;
defStrInit *StrInit = (defStrInit *)JXAPI->fnStrInit;
defStrAppend *StrAppend = (defStrAppend *)JXAPI->fnStrAppend;
defStrPush *StrPush = (defStrPush *)JXAPI->fnStrPush;
char strBuffer[JXAPI->STRBUFFER_SIZE];
char *cResult = StrInit(L, strBuffer, 32);
StrAppend(strBuffer, initString, sizeof(initString)-1);
StrPush(strBuffer);
return 0;
}
uint8_t
XTDBDropIndex(XTDBHandle* handle,char* fieldName) {
//void * iter = DBIter(handle->descDB);
uint8_t deleted=False;
String descKey,idxDBName;
BinaryStr key,value;
DataBaseBE* idxDB;
idxDB = XTDBGetIndex(handle,fieldName);
if (!idxDB) {
handle->error = XTDB_NO_ENTRY;
return False;
}
StrInit(&descKey);
if (StrAppendFmt(&descKey,"index.value.%s",fieldName)) {
handle->error = XTDB_NO_MEM;
return False;
}
StrToBStr(IDXFIELDNAME,&key);
StrToBStr(fieldName,&value);
DBDeleteKeyVal(handle->descDB,&key,&value);
DBClose(idxDB);
if (!XTDBRemoveIndex(handle,fieldName)) {
return False;
}
DBFree(idxDB);
StrToBStr(descKey.ptr,&key);
DBDelete(handle->descDB,&key);
if (GetIndexDBName(handle,fieldName,&idxDBName)) {
handle->error = XTDB_NO_MEM;
return False;
}
unlink(STR(&idxDBName));
StrFree(&descKey);
StrFree(&idxDBName);
return True;
}
// XXX revisit after DB eror
uint8_t
XTDBCreateIndex(XTDBHandle* handle,char* fieldName) {
String idxDBName;
String descKey;
bson idxDesc;
BinaryStr key,value,data;
DataBaseBE* db;
int rc;
StrInit(&descKey);
if(StrAppendFmt(&descKey,"index.value.%s",fieldName)) {
handle->error = XTDB_NO_MEM;
return False;
}
StrToBStr(descKey.ptr,&key);
if (DBGet(handle->descDB,&key,&value)) {
// Index already exists
printf("Index already exists.\n");
StrFree(&descKey);
BinaryStrFree(&value);
handle->error= XTDB_INDEX_EXISTS;
return False;
}
bson_init(&idxDesc);
if (bson_append_string(&idxDesc,"name",fieldName)) {
handle->error = XTDB_NO_MEM;
bson_destroy(&idxDesc);
StrFree(&descKey);
return False;
}
if (bson_finish(&idxDesc)) {
handle->error = XTDB_NO_MEM;
bson_destroy(&idxDesc);
StrFree(&descKey);
return False;
}
BsonToBStr(&idxDesc,&value);
if (!DBSet(handle->descDB,&key,&value,False)) {
printf("Error Adding to index names list\n");
handle->error = DBGetLastError(handle->descDB);
bson_destroy(&idxDesc);
StrFree(&descKey);
return False;
}
StrFree(&descKey);
StrToBStr(IDXFIELDNAME,&key);
StrToBStr(fieldName,&value);
if (!DBSet(handle->descDB,&key,&value,True)) {
//printf("Error Adding to index names list\n");
handle->error = DBGetLastError(handle->descDB);
//handle->error = XTDB_IO_ERR;
bson_destroy(&idxDesc);
return False;
}
bson_destroy(&idxDesc);
if (GetIndexDBName(handle,fieldName,&idxDBName)) {
handle->error = XTDB_NO_MEM;
return False;
}
db = DBInit(STR(&idxDBName),BDBOWRITER | BDBOCREAT);
StrFree(&idxDBName);
if (!db) {
handle->error = XTDB_NO_MEM;
return False;
}
rc = DBOpen(db,BDBOCREAT|BDBOWRITER);
if (!rc) {
handle->error = DBGetLastError(db);
DBFree(db);
return False;
}
DBClose(db);
DBFree(db);
if (!XTDBAddIndex(handle,fieldName)) {
// AddIndex failed return
printf("Error Adding to index names list\n");
return False;
}
assert(XTDBGetIndex(handle,fieldName));
void* iter = DBIter(handle->mainDB);
while (DBIterCur(handle->mainDB,iter,&key,&data)) {
//printf("Adding value to index\n");
bson obj;
BStrToBson(&data,&obj);
if (!XTDBInsertToIndex(handle,&key,&data)) {
return False;
}
BinaryStrFree(&key);
BinaryStrFree(&data);
DBIterNext(handle->mainDB,iter);
}
DBIterFree(handle->mainDB,iter);
return True;
}
int
GetIndexDBName(XTDBHandle* h,
const char* field,String* out) {
StrInit(out);
return StrAppendFmt(out,"%s/%s.%s.idx",h->dataDir.ptr,h->dbName.ptr,field);
}
Str* ParseLex(char* s,Err* err,int* i){
int len=0;
static char op='\0';
Str* S=NULL;
S=StrInit();
int noStep=0;
char c;
ParseLexStates prevstate,state=BLANK;
if (s!=NULL) len=strlen(s); else return NULL;
while ((*i)<len && s[*i]==' ') (*i)++;
for (;(state!=ERROR && (*i)<=len);){
c=s[*i];
prevstate=state;
switch (state){
case BLANK:
if (c=='"') state=QUOTE;
else if (CharOp(c)) {
if (S->len==0 && CharDoubleOp(c)){
if ((*i)<len-1 && s[(*i)+1]==c){
StrPutChar(S,c); StrPutChar(S,c);
StrPutChar(S,'\0');
(*i)+=2;
state=END;
} else {
StrPutChar(S,c); StrPutChar(S,'\0');
(*i)++;
state=END;
}
}
if (S->len==0 && CharSimpleOp(c)){
StrPutChar(S,c); StrPutChar(S,'\0');
state=END;
(*i)++;
}
} else if (c==' ' || c=='\0') state=BLANK;
else {
StrPutChar(S,c);
state=WORD;
}
break;
case QUOTE:
if (c!='"') StrPutChar(S,c);
if (c=='"') {
StrPutChar(S,'\0');
state=END;
(*i)++;
} else if ((*i)==len-1) state=ERROR;
break;
case OPERATOR:
if (c==op && CharDoubleOp(c)){
StrPutChar(S,c);StrPutChar(S,c); StrPutChar(S,'\0');
state=END;
(*i)++;
} else {
StrPutChar(S,c);
StrPutChar(S,'\0');
state=END;
}
break;
case WORD:
if (c=='"') state=WORD;
else if (c==' '){
/*StrPutChar(S,' ');*/
state=END;
} else if (CharOp(c)) {
state=END;
op=c;
}
else {
StrPutChar(S,c);
}
break;
default:
break;
}
if (state==END ) {
if (StrLast(S)!='\0') StrPutChar(S,'\0');
/*printf("%d\n",*i);*/
return S;
}
if (!noStep) (*i)++;
if (state==ERROR){
if (prevstate==QUOTE) {
err->pres=1;
(err->err)=myrealloc(err->err,50);
strcpy(err->err,"Unfinished Quote\0");
}
i=NULL;
return NULL;
}
if ((*i)>=len){
if (state==BLANK) return NULL;
if (state!=BLANK) {
if (StrLast(S)!='\0') StrPutChar(S,'\0');
return S;
}
}
}
i=NULL;
return S;
}
