C语言【微项目17】—DustBase微尘数据库[自制键值对数据库][超轻量]【2022-03-23】
【TDTX】
【C99】
【编译与运行环境】64位Windows操作系统，TDM-gcc 4.9.2 64bit（-std=c99）编译。
【项目Gitee仓库】DustBase，同时将V1.0版本也放在C语言-微项目。
【介绍】微尘数据库，一个十分简单轻量的非关系型——键值对数据库，纯C语言实现。
【使用方式】
- 由DustBaseShell.exe命令行交互式使用。由“.”前缀调用命令、由“$”前缀调用函数。（已实现）
- 嵌入式使用。将DustBaseCore.c通过#include "DustBaseCore.c"的方式直接将数据库编译到用户程序中去。（已实现）
- 连接式用法。(待定)
【功能】
1.支持的函数
| 函数 | 作用 |
|---|---|
| createDataBase | 创建数据库 |
| usingDataBase | 指定要使用的数据库 |
| clearUsingDataBase | 清除使用中的数据库 |
| deleteDataBase | 删除某个未使用中的数据库 |
| putString | 存入键值对 |
| deleteString | 删除键值对 |
| getString | 获取键的值 |
| setKeyValue | 更改键的值 |
| getKeyList | 获取键名的列表 |
2.使用方法
- 在DustBaseShell.exe命令行交互式环境中，使用’.'开头可以使用Shell里面的命令。
- 在DustBaseShell.exe命令行交互式环境中，使用’$'开头可以使用上述支持的函数里面的命令。
- 设置好环境变量后，DustBaseShell.exe支持带参启动！
- 在嵌入式使用方法中，直接调用上述支持的函数即可。
【版本】version 1.0
1. DustBaseShell.c
#include <stdio.h>
#include <stdlib.h>
#include <io.h>
#include <dirent.h>
#include "DustBaseCore.c"
char c;
int count = 0;
int isLegalparameter(char c)
{
//判断参数是不是合法参数字符
if(c >= '0' && c <= '9')
{
return 1;
}
if((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))
{
return 1;
}
return 0;
}
int checkParameter(char* command,int parastart,char** para)
{
//command是用户输入的字符串
//parastart是可能的函数参数起始位置
//para将会指向合法的参数起始位置
//检查单参数函数
int flag = 0;
for(int i = parastart;i < strlen(command);i++)
{
if(flag == 0 && command[i] != ' ' && isLegalparameter(command[i]))
{
//过滤参数字符串的非法前缀
parastart = i;
flag = 1;
continue;
}
if(flag == 1 && !isLegalparameter(command[i]))
{
//找到非空参数起始位置后，检查字符合法性
*para = NULL;
return 0;
}
}
//printf("start = %d\n",parastart);
*para = &command[parastart];
return 1;
}
int checkTwoParameter(char* command,int parastart,char** ppkey,char** ppvalue)
{
int secondparastart = -1;
int flag = 0;
for(int i = parastart;i < strlen(command);i++)
{
//判断该参数字符串有没有空格，即是否可能输入了两个参数，而非一个
if(flag == 0 && command[i] != ' ')
{
flag = 1;
}
if(flag == 1 && command[i] == ' ' && i + 1 < strlen(command))
{
command[i] = '\0';
secondparastart = i+1;
}
}
if(secondparastart == -1)
{
return 0;
}
//puts(&command[parastart]);
//puts(&command[secondparastart]);
int result = 0;
result = checkParameter(command,parastart,ppkey);
*ppvalue = &command[secondparastart];
for(int i = 0;i < strlen(*ppvalue);i++)
{
if((*ppvalue)[i] == '$')
{
return 0;
}
}
return result;
}
void printHello()
{
puts("Welcome to DustBase v1.0.0.");
puts("This is a very very lite datastore!");
puts("Two type '.' and '$',$ use to function.");
puts("Say \".help\" for more information.");
}
void printHelp()
{
puts(".help Print this help message");
puts(".databases List names and files of attached databases");
puts(".function List supported features");
puts(".this Introduce the DustBase");
puts(".cls Clear screen");
puts(".restart Restart DustBaseShell");
puts(".quit Quit the DustBaseShell");
puts("$function parameter For example:$createDataBase helloworld");
}
void printFunction()
{
puts("----------------------+---------------------------------------");
puts("|createDataBase |-创建数据库 |");
puts("----------------------+---------------------------------------");
puts("|usingDataBase |-指定要使用的数据库 |");
puts("----------------------+---------------------------------------");
puts("|clearUsingDataBase |-清除使用中的数据库 |");
puts("----------------------+---------------------------------------");
puts("|deleteDataBase |-删除某个未使用中的数据库 |");
puts("----------------------+---------------------------------------");
puts("|putString |-存入键值对 |");
puts("----------------------+---------------------------------------");
puts("|deleteString |-删除键值对 |");
puts("----------------------+---------------------------------------");
puts("|getString |-获取键的值 |");
puts("----------------------+---------------------------------------");
puts("|setKeyValue |-更改键的值 |");
puts("----------------------+---------------------------------------");
puts("|getKeyList |-获取键名的列表 |");
puts("----------------------+---------------------------------------");
puts("|getKeySeekIndex |-获取[键的索引位置及键名组合]的列表 |");
puts("----------------------+---------------------------------------");
}
void printIntroduce()
{
puts("- DustBase,微尘数据库!");
puts("- 一个十分简单轻量的非关系型——键值对数据库，纯C语言实现!");
puts("- 作者：CSDN/Gitee:TDTX/TDTXYZHH");
}
int main(int argc,char*argv[])
{
printHello();
if(argc >= 2)
{
if(argv[1] != NULL && !strcmp(".help",argv[1]))
{
printf("DB> %s\n",argv[1]);
printHelp();
}
if(argv[1] != NULL && !strcmp(".function",argv[1]))
{
printf("DB> %s\n",argv[1]);
printFunction();
}
if(argv[1] != NULL && !strcmp(".this",argv[1]))
{
printf("DB> %s\n",argv[1]);
printIntroduce();
}
if(argv[1] != NULL && !strcmp(".quit",argv[1]))
{
printf("DB> %s\n",argv[1]);
return 0;
}
}
//puts("");
while(1)
{
printf("DB> ");
while(1)
{
c = fgetc(stdin);
if(c == '\n')
{
break;
}
if(c == '.' && ftell(stdin) == 1)
{
int commandsize = 0;
char* command = (char*)malloc(0);
while(1)
{
c = fgetc(stdin);
command = (char*)realloc(command,sizeof(char)*(commandsize + 1));
commandsize++;
if(c == '\n')
{
command[commandsize - 1] = '\0';
break;
}
command[commandsize - 1] = c;
}
if(!strcmp("help",command))
{
printHelp();
free(command);
break;
}
else if(!strcmp("databases",command))
{
//puts("teset=====");
DIR* dir = NULL;
struct dirent* dt;
int i = 0;
dir = opendir("./");
int flag = 0;
puts("=====[In this folder]=====");
while(dt = readdir(dir))
{
//print("hello");
//printf("i = %d\n",i);
char* filename = &(dt->d_name)[strlen(dt->d_name) - 4];
if(!strcmp(filename,".tdb"))
{
i++;
printf("->%2d:%s\n",i,dt->d_name);
flag = 1;
}
}
if(flag == 0)
{
puts("Info:NO DATABASE[.tdb]");
}
puts("=====[In this folder]=====");
closedir(dir);
free(command);
break;
}
else if(!strcmp("function",command))
{
printFunction();
free(command);
break;
}
else if(!strcmp("this",command))
{
printIntroduce();
free(command);
break;
}
else if(!strcmp("cls",command))
{
system("cls");
free(command);
break;
}
else if(!strcmp("restart",command))
{
char* t[] = {"DustBase",NULL};
main(0,t);
free(command);
exit(0);
break;
}
else if(!strcmp("quit",command))
{
free(command);
return 0;
}
free(command);
break;
}
else if(c == '$' && ftell(stdin) == 1)
{
int commandsize = 0;
char* command = (char*)malloc(0);
while(1)
{
c = fgetc(stdin);
command = (char*)realloc(command,sizeof(char)*(commandsize + 1));
commandsize++;
if(c == '\n')
{
command[commandsize - 1] = '\0';
break;
}
command[commandsize - 1] = c;
}
if(strstr(command,"createDataBase") != NULL)
{
puts("create");
if(strlen(command) > 15)
{
if(command[14] != ' ')
{
puts("Function:createDataBase input error,need space between function and parameter!");
}
else
{
char* parameter = &command[15];
int i = checkParameter(command,15,¶meter);
if(i == 0)
{
puts("Function:createDataBase input error,parameters have illegal parameter!");
}
else
{
puts(parameter);
createDataBase(parameter);
}
}
}
else
{
puts("Function:createDataBase input error,need parameter!");
}
free(command);
break;
}
else if(strstr(command,"usingDataBase") != NULL)
{
puts("use");
if(strlen(command) > 14)
{
if(command[13] != ' ')
{
puts("Function:createDataBase input error,need space between function and parameter!");
}
else
{
char* parameter = &command[14];
int i = checkParameter(command,14,¶meter);
if(i == 0)
{
puts("Function:createDataBase input error,parameters have illegal parameter!");
}
else
{
puts(parameter);
usingDataBase(parameter);
}
}
}
else
{
puts("Function:createDataBase input error,need parameter!");
}
free(command);
break;
}
else if(strstr(command,"clearUsingDataBase") != NULL)
{
puts("clearusing");
if(strlen(command) == 18)
{
clearUsingDataBase();
}
else
{
puts("Function:createDataBase input error,don't need parameter!");
}
free(command);
break;
}
else if(strstr(command,"deleteDataBase") != NULL)
{
puts("deleteDataBase");
if(strlen(command) > 15)
{
if(command[14] != ' ')
{
puts("Function:deleteDataBase input error,need space between function and parameter!");
}
else
{
char* parameter = &command[15];
int i = checkParameter(command,15,¶meter);
if(i == 0)
{
puts("Function:deleteDataBase input error,parameters have illegal parameter!");
}
else
{
puts(parameter);
deleteDataBase(parameter);
}
}
}
else
{
puts("Function:deleteDataBase input error,need parameter!");
}
free(command);
break;
}
else if(strstr(command,"putString") != NULL)
{
puts("putString");
if(strlen(command) > 10)
{
if(command[9] != ' ')
{
puts("Function:putString input error,need space between function and parameter!");
}
else
{
char* pkey = &command[10];
char* pvalue = NULL;
int result = checkTwoParameter(command,10,&pkey,&pvalue);
if(result == 0)
{
puts("Function:putString input error,parameters have illegal parameter!");
}
else
{
//puts(pkey);
//puts(pvalue);
putString(pkey,pvalue);
}
}
}
else
{
puts("Function:putString input error,need parameter!");
}
free(command);
break;
}
else if(strstr(command,"deleteString") != NULL)
{
puts("deleteString");
if(strlen(command) > 13)
{
if(command[12] != ' ')
{
puts("Function:deleteString input error,need space between function and parameter!");
}
else
{
char* parameter = &command[13];
int i = checkParameter(command,13,¶meter);
if(i == 0)
{
puts("Function:deleteString input error,parameters have illegal parameter!");
}
else
{
puts(parameter);
deleteString(parameter);
}
}
}
else
{
puts("Function:deleteString input error,need parameter!");
}
free(command);
break;
}
else if(strstr(command,"getString") != NULL)
{
puts("getString");
if(strlen(command) > 10)
{
if(command[9] != ' ')
{
puts("Function:getString input error,need space between function and parameter!");
}
else
{
char* pkey = &command[10];
char* pvalue = NULL;
int result = checkTwoParameter(command,10,&pkey,&pvalue);
if(result == 0)
{
puts("Function:getString input error,parameters have illegal parameter!");
}
else
{
//puts(pkey);
//puts(pvalue);
//char* svalue = getString(pkey,pvalue);
//puts(svalue);
getString(pkey,pvalue);
}
}
}
else
{
puts("Function:getString input error,need parameter!");
}
free(command);
break;
}
else if(strstr(command,"setKeyValue") != NULL)
{
puts("setKeyValue");
if(strlen(command) > 12)
{
if(command[11] != ' ')
{
puts("Function:setKeyValue input error,need space between function and parameter!");
}
else
{
char* pkey = &command[12];
char* pvalue = NULL;
int result = checkTwoParameter(command,12,&pkey,&pvalue);
if(result == 0)
{
puts("Function:setKeyValue input error,parameters have illegal parameter!");
}
else
{
//puts(pkey);
//puts(pvalue);
setKeyValue(pkey,pvalue);
}
}
}
else
{
puts("Function:setKeyValue input error,need parameter!");
}
free(command);
break;
}
else if(strstr(command,"getKeyList") != NULL)
{
puts("getKeyList");
if(strlen(command) == 10)
{
struct keylistinfo* keys = getKeyList();
if(keys != NULL)
{
for(int i = 0;i < keys->n;i++)
{
if(i == 0)
{
printf("[\"%s\"",(keys->keylist)[i]);
}
else
{
printf(",\"%s\"",(keys->keylist)[i]);
}
if(i == keys->n - 1)
{
printf("]\n");
}
}
}
}
else
{
puts("Function:createDataBase input error,don't need parameter!");
}
free(command);
break;
}
free(command);
break;
}
}
}
system("pause");
return 0;
}
2. DustBaseCore.c
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
struct keylistinfo
{
char** keylist;
int n;
};
char rundatabasename[37] = {'\0'};//数据库名最多32字符
char* value = NULL;
struct keylistinfo* keys = NULL;
int connecDataBase();//待定
int disconnectDataBase();//待定
int createDataBase(char* databasename);
int usingDataBase(char* databasename);
int clearUsingDataBase();
int deleteDataBase(char* databasename);
int putString(char* key,char* value);
int deleteString(char* key);
char* getString(char* key,char* error);
int setKeyValue(char* key,char* newvalue);
struct keylistinfo* getKeyList();
int getKeySeekIndex();//暂不实现
int connecDataBase()
{
//待定
}
int disconnectDataBase()
{
//待定
}
int createDataBase(char* databasename)
{
int len = strlen(databasename);
if(len > 32)
{
puts("Warning:the length of database name exceeds the limit(32)");
return 0;
}
char name[len+5];
strcpy(name,databasename);
name[len] = '.';
name[len+1] = 't';
name[len+1+1] = 'd';
name[len+1+1+1] = 'b';
name[len+1+1+1+1] = '\0';
//puts(name);
if(!access(name,F_OK))
{
puts("Error:the newdatabase exist!");
return -1;
}
FILE* database = fopen(name,"a");
if(database == NULL)
{
puts("Error:create database fail!");
return -1;
}
fflush(database);
fclose(database);
puts("Info:create database success!");
return 1;
}
int usingDataBase(char* databasename)
{
int len = strlen(databasename);
if(len > 32)
{
puts("Warning:the length of database name exceeds the limit(32)");
return 0;
}
char name[len+5];
strcpy(name,databasename);
name[len] = '.';
name[len+1] = 't';
name[len+1+1] = 'd';
name[len+1+1+1] = 'b';
name[len+1+1+1+1] = '\0';
//puts(name);
if(access(name,F_OK))
{
puts("Error:the database doesn't exist!");
return -1;
}
strcpy(rundatabasename,name);
puts("Info:using database success!");
char* value = (char*)malloc(0);
keys = (struct keylistinfo*)malloc(sizeof(struct keylistinfo));
keys->n = 0;
keys->keylist = (char**)malloc(0);
return 1;
}
int clearUsingDataBase()
{
if(strlen(rundatabasename) == 0)
{
puts("Error:clear using databse fail,no database is using!");
return 0;
}
rundatabasename[0] = '\0';
free(value);
value = NULL;
for(int i = 0;i < keys->n;i++)
{
free((keys->keylist)[i]);
}
free(keys->keylist);
free(keys);
keys = NULL;
puts("Info:clear using databse success!");
return 1;
}
int deleteDataBase(char* databasename)
{
int len = strlen(databasename);
if(len > 32)
{
puts("Warning:the length of database name exceeds the limit(32)");
return 0;
}
char name[len+5];
strcpy(name,databasename);
name[len] = '.';
name[len+1] = 't';
name[len+1+1] = 'd';
name[len+1+1+1] = 'b';
name[len+1+1+1+1] = '\0';
//puts(name);
if(access(name,F_OK))
{
puts("Error:the newdatabase doesn't exist!");
return -1;
}
if(!strcmp(rundatabasename,name))
{
puts("Warning:the database is using,can not delete!");
return 0;
}
if(remove(name) != 0)
{
puts("Error:delete databse fail!");
return -1;
}
puts("Info:delete databse success!");
return 1;
}
int putString(char* key,char* value)
{
if(rundatabasename[0] == '\0')
{
puts("Error:no database is using!");
return -1;
}
if(strlen(key) > 32)
{
puts("Warning:the length of key exceeds the limit(32)");
return 0;
}
//puts(rundatabasename);
for(int i = 0; i < strlen(value);i++)
{
if(value[i] == '$')
{
puts("Warning:the value can not contain '$'!");
return 0;
}
}
FILE* database = fopen(rundatabasename,"a+");
if(database == NULL)
{
puts("Error:the database doesn't exist!");
return -1;
}
char tkey[33];
int cancopy = 0;
int k = 0;
char tc;
while(1)
{
//这里用来判断里面有没有该key，如果存在则不存入，没有则存入
tc = fgetc(database);
if(tc == EOF)
{
break;
}
if(tc == '$')
{
cancopy = 1;
continue;
}
if(cancopy == 1)
{
if(tc == ':')
{
tkey[k] = '\0';
k = 0;
cancopy = 0;
//puts(tkey);
if(!strcmp(key,tkey))
{
fclose(database);
puts("Error:the key exists!");
return -1;
}
tkey[0] = '\0';
}
else
{
tkey[k++] = tc;
continue;
}
}
}
fprintf(database,"$%s:%s\n",key,value);
fflush(database);
fclose(database);
puts("Info:putString success!");
return 1;
}
int deleteString(char* key)
{
if(rundatabasename[0] == '\0')
{
puts("Error:no database is using!");
return -1;
}
if(strlen(key) > 32)
{
puts("Warning:the length of key exceeds the limit(32)");
return 0;
}
//puts(rundatabasename);
FILE* database = fopen(rundatabasename,"a+");
if(database == NULL)
{
puts("Error:the database doesn't exist!");
return -1;
}
char tkey[33];
int cancopy = 0;
int k = 0;
char tc;
int havekey = 0;
int location = 0;
while(1)
{
//这里用来判断里面有没有该key，如果存在则执行删除，不存在则返回-1
tc = fgetc(database);
if(tc == EOF)
{
break;
}
if(tc == '$')
{
location = ftell(database);
cancopy = 1;
continue;
}
if(cancopy == 1)
{
if(tc == ':')
{
tkey[k] = '\0';
k = 0;
cancopy = 0;
//puts(tkey);
if(!strcmp(key,tkey))
{
havekey = 1;
//puts("Error:the key exists!");
break;
}
tkey[0] = '\0';
}
else
{
tkey[k++] = tc;
continue;
}
}
}
if(havekey == 1)
{
int flag = 0;
fseek(database,0,SEEK_SET);//将文件指针定位到起始位置
FILE* temp = fopen("temp.tdb","w");
if(temp == NULL)
{
puts("Error:new temp-database fail!");
fclose(database);
return -1;
}
while(1)
{
tc = fgetc(database);
if(tc == EOF)
{
break;
}
if(ftell(database) == location)
{
flag = 1;
}
if(flag == 1)
{
if((tc == '$' || tc == EOF) && ftell(database) > location)
{
flag = 0;
fputc(tc,temp);
}
}
else
{
fputc(tc,temp);
}
}
fclose(database);
fclose(temp);
remove(rundatabasename);
rename("temp.tdb",rundatabasename);
puts("Info:delete key-value success!");
return 1;
}
else
{
fclose(database);
puts("Error:the key doesn't exists,cannot delete key-vlaue!");
return 0;
}
}
char* getString(char* key,char* error)
{
if(rundatabasename[0] == '\0')
{
puts("Error:no database is using!");
return error;
}
if(strlen(key) > 32)
{
puts("Warning:the length of key exceeds the limit(32)");
return error;
}
//puts(rundatabasename);
FILE* database = fopen(rundatabasename,"a+");
if(database == NULL)
{
puts("Error:the database doesn't exist!");
return error;
}
char tkey[33];
int cancopy = 0;
int k = 0;
char tc;
int havekey = 0;
int location = 0;
while(1)
{
//这里用来判断里面有没有该key，如果存在则执行获取值，不存在则返回error所指字符串
tc = fgetc(database);
if(tc == EOF)
{
break;
}
if(tc == '$')
{
cancopy = 1;
continue;
}
if(cancopy == 1)
{
if(tc == ':')
{
location = ftell(database);
tkey[k] = '\0';
k = 0;
cancopy = 0;
//puts(tkey);
if(!strcmp(key,tkey))
{
havekey = 1;
//puts("Error:the key exists!");
break;
}
tkey[0] = '\0';
}
else
{
tkey[k++] = tc;
continue;
}
}
}
k = 0;
if(havekey == 1)
{
fseek(database,location,SEEK_SET);
while(1)
{
tc = fgetc(database);
if(tc == '$' || tc == EOF)
{
break;
}
value = (char*)realloc(value,++k);
value[k - 1] = tc;
}
value[k] = '\0';
puts("value is:");
puts(value);
fclose(database);
return value;
}
else
{
fclose(database);
puts("Error:the key doesn't exists,cannot get vlaue!");
return 0;
}
}
int setKeyValue(char* key,char* newvalue)
{
if(rundatabasename[0] == '\0')
{
puts("Error:no database is using!");
return -1;
}
if(strlen(key) > 32)
{
puts("Warning:the length of key exceeds the limit(32)");
return 0;
}
//puts(rundatabasename);
for(int i = 0; i < strlen(value);i++)
{
if(value[i] == '$')
{
puts("Warning:the value can not contain '$'!");
return 0;
}
}
FILE* database = fopen(rundatabasename,"a+");
if(database == NULL)
{
puts("Error:the database doesn't exist!");
return -1;
}
char tkey[33];
int cancopy = 0;
int k = 0;
char tc;
int havekey = 0;
int location = 0;
while(1)
{
//这里用来判断里面有没有该key，如果存在则执行设置该key的value，不存在则返回0
tc = fgetc(database);
if(tc == EOF)
{
break;
}
if(tc == '$')
{
cancopy = 1;
continue;
}
if(cancopy == 1)
{
if(tc == ':')
{
location = ftell(database);
tkey[k] = '\0';
k = 0;
cancopy = 0;
//puts(tkey);
if(!strcmp(key,tkey))
{
havekey = 1;
//puts("Error:the key exists!");
break;
}
tkey[0] = '\0';
}
else
{
tkey[k++] = tc;
continue;
}
}
}
if(havekey == 1)
{
int flag = 0;
fseek(database,0,SEEK_SET);//将文件指针定位到起始位置
FILE* temp = fopen("settemp.tdb","w");
if(temp == NULL)
{
puts("Error:new settemp-database fail!");
fclose(database);
return -1;
}
while(1)
{
tc = fgetc(database);
if(tc == EOF)
{
break;
}
if(ftell(database) == location)
{
fputc(tc,temp);
flag = 1;
int len = strlen(newvalue);
for(int i = 0;i < len;i++)
{
fputc(newvalue[i],temp);
}
fputc('\n',temp);
}
if(flag == 1)
{
if((tc == '$' || tc == EOF) && ftell(database) > location)
{
flag = 0;
fputc(tc,temp);
}
}
else
{
fputc(tc,temp);
}
}
fclose(database);
fclose(temp);
remove(rundatabasename);
rename("settemp.tdb",rundatabasename);
puts("Info:set the key's new value success!");
return 1;
}
else
{
fclose(database);
puts("Error:the key doesn't exists,cannot set set the key's new value!");
return 0;
}
}
struct keylistinfo* getKeyList()
{
if(rundatabasename[0] == '\0')
{
puts("Error:no database is using!");
return NULL;
}
//puts(rundatabasename);
FILE* database = fopen(rundatabasename,"a+");
if(database == NULL)
{
puts("Error:the database doesn't exist!");
return NULL;
}
if(keys->n != 0)
{
for(int i = 0;i < keys->n;i++)
{
free((keys->keylist)[i]);
}
keys->keylist = (char**)realloc(keys->keylist,0);
keys->n = 0;
}
char tkey[33];
int cancopy = 0;
int k = 0;
char tc;
int location = 0;
while(1)
{
tc = fgetc(database);
if(tc == EOF)
{
break;
}
if(tc == '$')
{
location = ftell(database);
cancopy = 1;
continue;
}
if(cancopy == 1)
{
if(tc == ':')
{
tkey[k] = '\0';
k = 0;
cancopy = 0;
//puts(tkey);
keys->keylist = (char**)realloc(keys->keylist,sizeof(char*)*(keys->n + 1));
(keys->n)++;
char* thiskey = (char*)malloc(strlen(tkey)*sizeof(char));
strcpy(thiskey,tkey);
//printf("检查thiskey:%s\n",thiskey);
(keys->keylist)[keys->n - 1] = thiskey;
tkey[0] = '\0';
}
else
{
tkey[k++] = tc;
continue;
}
}
}
fclose(database);
return keys;
}
int getKeySeekIndex()
{
//暂不实现
}
3. DustBaseShell模式使用截图
4. DustBase典型使用流程
-
int createDataBase(char* databasename);//创建数据库
-
int usingDataBase(char* databasename);//使用数据库
-
使用下列数据库操作函数：
int putString(char* key,char* value);
int deleteString(char* key);
char* getString(char* key,char* error);
int setKeyValue(char* key,char* newvalue);
struct keylistinfo* getKeyList(); -
int clearUsingDataBase();//清除使用的数据库
-
int deleteDataBase(char* databasename);//删除未使用中的数据库
5. DustBaseCore嵌入式使用
测试文件：importtest.c
#include <stdlib.h>
#include "DustBaseCore.c"
int main()
{
createDataBase("useimport999");
usingDataBase("useimport999");
putString("godd1","dadasdhjuhfas\ndadasd\tdada8977465=");
putString("peoo","dersaasdasdewqdad");
putString("qdwqd","cfasdsadad");
getString("godd1","error");
struct keylistinfo* keys = getKeyList();
if(keys != NULL)
{
for(int i = 0;i < keys->n;i++)
{
if(i == 0)
{
printf("[\"%s\"",(keys->keylist)[i]);
}
else
{
printf(",\"%s\"",(keys->keylist)[i]);
}
if(i == keys->n - 1)
{
printf("]\n");
}
}
}
setKeyValue("godd1","this is new value!!!!");
keys = getKeyList();
if(keys != NULL)
{
for(int i = 0;i < keys->n;i++)
{
printf("%s:%s",(keys->keylist)[i],getString((keys->keylist)[i],"error"));
}
}
clearUsingDataBase();
system("pause");
return 0;
}
运行截图：
6. DustBaseShell模式运行视频
DustBase--微尘数据库，一个十分简单轻量的非关系型——键值对数据库，纯C语言实现！
179
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
