UnQLite入门

川长思鸟来 2024-05-24 01:41 83阅读 0赞

本文介绍UnQLite的基本使用，包括增删改查，事务ACID

文章目录

  • UnQLite介绍
  • UnQLite常用接口
    • 函数
    • 返回码
  • Demo
    • Key/Value存储
    • 数据库游标

UnQLite介绍

  • UnQLite简介

在这里插入图片描述

UnQLite是，由 Symisc Systems公司出品的一个嵌入式C语言软件库，它实现了一个自包含、无服务器、零配置、事务化的NoSQL数据库引擎。UnQLite是一个文档存储数据库，类似于MongoDB、Redis、CouchDB等。同时，也是一个标准的Key/Value存储，与BerkeleyDB和LevelDB等类似。

UnQLite是一个嵌入式NoSQL（键/值存储和文档存储）数据库引擎。不同于其他绝大多数NoSQL数据库，UnQLite没有一个独立的服务器进程。UnQLite直接读/写普通的磁盘文件。包含多个数据集的一个完整的数据库，存储在单一的磁盘文件中。数据库文件格式是跨平台的，可以在32位和64位系统或大端和小端架构之间，自由拷贝一个数据库。UnQLite的主要特点，如下：

  1. `无服务器`数据库引擎。
  2. `事务化` (ACID) 数据库。
  3. `零配置`。
  4. `单一数据库文件`，不使用临时文件。
  5. `跨平台`的`文件格式`。
  6. UnQLite是一个自包含的C语言程序库，`无任何外部依赖`。
  7. 标准的`Key/Value`存储。
  8. 基于`Jx9`的`文档存储`(JSON)数据库。
  9. 支持`游标`，满足线性记录遍历。
  10. `插件式`运行时可交换存储引擎。
  11. 支持`磁盘持久化`和`内存模式`的数据库。
  12. 内建强大的磁盘存储引擎，支持`O(1)`查询。
  13. `线程安全`，完全可重入。
  14. 简单、清晰，很容易使用的`API`。
  15. 支持`TB（Terabyte）尺寸`的数据库。
  16. 采用`BSD开源许可协议`。
  17. 合并：UnQLite和Jx9相关所有C源代码文件，都合并到`单一的文件中`。
  18. 很好的`在线支持`。

UnQLite常用接口

函数

  1. /* Database Engine Handle */
  2. UNQLITE_APIEXPORT int unqlite_open(unqlite **ppDB,const char *zFilename,unsigned int iMode);
  3. UNQLITE_APIEXPORT int unqlite_config(unqlite *pDb,int nOp,...);
  4. UNQLITE_APIEXPORT int unqlite_close(unqlite *pDb);
  7. /* Key/Value (KV) Store Interfaces */
  8. UNQLITE_APIEXPORT int unqlite_kv_store(unqlite *pDb,const void *pKey,int nKeyLen,const void *pData,unqlite_int64 nDataLen);
  9. UNQLITE_APIEXPORT int unqlite_kv_append(unqlite *pDb,const void *pKey,int nKeyLen,const void *pData,unqlite_int64 nDataLen);
  10. UNQLITE_APIEXPORT int unqlite_kv_store_fmt(unqlite *pDb,const void *pKey,int nKeyLen,const char *zFormat,...);
  11. UNQLITE_APIEXPORT int unqlite_kv_append_fmt(unqlite *pDb,const void *pKey,int nKeyLen,const char *zFormat,...);
  12. UNQLITE_APIEXPORT int unqlite_kv_fetch(unqlite *pDb,const void *pKey,int nKeyLen,void *pBuf,unqlite_int64 /* in|out */*pBufLen);
  13. UNQLITE_APIEXPORT int unqlite_kv_fetch_callback(unqlite *pDb,const void *pKey,
  14.                         int nKeyLen,int (*xConsumer)(const void *,unsigned int,void *),void *pUserData);
  15. UNQLITE_APIEXPORT int unqlite_kv_delete(unqlite *pDb,const void *pKey,int nKeyLen);
  16. UNQLITE_APIEXPORT int unqlite_kv_config(unqlite *pDb,int iOp,...);
  18. /* Document (JSON) Store Interfaces powered by the Jx9 Scripting Language */
  19. UNQLITE_APIEXPORT int unqlite_compile(unqlite *pDb,const char *zJx9,int nByte,unqlite_vm **ppOut);
  20. UNQLITE_APIEXPORT int unqlite_compile_file(unqlite *pDb,const char *zPath,unqlite_vm **ppOut);
  21. UNQLITE_APIEXPORT int unqlite_vm_config(unqlite_vm *pVm,int iOp,...);
  22. UNQLITE_APIEXPORT int unqlite_vm_exec(unqlite_vm *pVm);
  23. UNQLITE_APIEXPORT int unqlite_vm_reset(unqlite_vm *pVm);
  24. UNQLITE_APIEXPORT int unqlite_vm_release(unqlite_vm *pVm);
  25. UNQLITE_APIEXPORT int unqlite_vm_dump(unqlite_vm *pVm, int (*xConsumer)(const void *, unsigned int, void *), void *pUserData);
  26. UNQLITE_APIEXPORT unqlite_value * unqlite_vm_extract_variable(unqlite_vm *pVm,const char *zVarname);
  28. /*  Cursor Iterator Interfaces */
  29.  UNQLITE_APIEXPORT int unqlite_kv_cursor_release(unqlite *pDb,unqlite_kv_cursor *pCur);
  30. UNQLITE_APIEXPORT int unqlite_kv_cursor_seek(unqlite_kv_cursor *pCursor,const void *pKey,int nKeyLen,int iPos);
  31. UNQLITE_APIEXPORT int unqlite_kv_cursor_first_entry(unqlite_kv_cursor *pCursor);
  32. UNQLITE_APIEXPORT int unqlite_kv_cursor_last_entry(unqlite_kv_cursor *pCursor);
  33. UNQLITE_APIEXPORT int unqlite_kv_cursor_valid_entry(unqlite_kv_cursor *pCursor);
  34. UNQLITE_APIEXPORT int unqlite_kv_cursor_next_entry(unqlite_kv_cursor *pCursor);
  35. UNQLITE_APIEXPORT int unqlite_kv_cursor_prev_entry(unqlite_kv_cursor *pCursor);
  36. UNQLITE_APIEXPORT int unqlite_kv_cursor_key(unqlite_kv_cursor *pCursor,void *pBuf,int *pnByte);
  37. UNQLITE_APIEXPORT int unqlite_kv_cursor_key_callback(unqlite_kv_cursor *pCursor,int (*xConsumer)(const void *,unsigned int,void *),void *pUserData);
  38. UNQLITE_APIEXPORT int unqlite_kv_cursor_data(unqlite_kv_cursor *pCursor,void *pBuf,unqlite_int64 *pnData);
  39. UNQLITE_APIEXPORT int unqlite_kv_cursor_data_callback(unqlite_kv_cursor *pCursor,int (*xConsumer)(const void *,unsigned int,void *),void *pUserData);
  40. UNQLITE_APIEXPORT int unqlite_kv_cursor_delete_entry(unqlite_kv_cursor *pCursor);
  41. UNQLITE_APIEXPORT int unqlite_kv_cursor_reset(unqlite_kv_cursor *pCursor);
  43. /* Manual Transaction Manager */
  44. UNQLITE_APIEXPORT int unqlite_begin(unqlite *pDb);
  45. UNQLITE_APIEXPORT int unqlite_commit(unqlite *pDb);
  46. UNQLITE_APIEXPORT int unqlite_rollback(unqlite *pDb);
  48. /* Utility interfaces */
  49. UNQLITE_APIEXPORT int unqlite_util_load_mmaped_file(const char *zFile,void **ppMap,unqlite_int64 *pFileSize);
  50. UNQLITE_APIEXPORT int unqlite_util_release_mmaped_file(void *pMap,unqlite_int64 iFileSize);
  51. UNQLITE_APIEXPORT int unqlite_util_random_string(unqlite *pDb,char *zBuf,unsigned int buf_size);
  52. UNQLITE_APIEXPORT unsigned int unqlite_util_random_num(unqlite *pDb);
  54. /* In-process extending interfaces */
  55. UNQLITE_APIEXPORT int unqlite_create_function(unqlite_vm *pVm,const char *zName,int (*xFunc)(unqlite_context *,int,unqlite_value **),void *pUserData);
  56. UNQLITE_APIEXPORT int unqlite_delete_function(unqlite_vm *pVm, const char *zName);
  57. UNQLITE_APIEXPORT int unqlite_create_constant(unqlite_vm *pVm,const char *zName,void (*xExpand)(unqlite_value *, void *),void *pUserData);
  58. UNQLITE_APIEXPORT int unqlite_delete_constant(unqlite_vm *pVm, const char *zName);
  60. /* On Demand Object allocation interfaces */
  61. UNQLITE_APIEXPORT unqlite_value * unqlite_vm_new_scalar(unqlite_vm *pVm);
  62. UNQLITE_APIEXPORT unqlite_value * unqlite_vm_new_array(unqlite_vm *pVm);
  63. UNQLITE_APIEXPORT int unqlite_vm_release_value(unqlite_vm *pVm,unqlite_value *pValue);
  64. UNQLITE_APIEXPORT unqlite_value * unqlite_context_new_scalar(unqlite_context *pCtx);
  65. UNQLITE_APIEXPORT unqlite_value * unqlite_context_new_array(unqlite_context *pCtx);
  66. UNQLITE_APIEXPORT void unqlite_context_release_value(unqlite_context *pCtx,unqlite_value *pValue);
  68. /* Dynamically Typed Value Object Management Interfaces */
  69. UNQLITE_APIEXPORT int unqlite_value_int(unqlite_value *pVal, int iValue);
  70. UNQLITE_APIEXPORT int unqlite_value_int64(unqlite_value *pVal, unqlite_int64 iValue);
  71. UNQLITE_APIEXPORT int unqlite_value_bool(unqlite_value *pVal, int iBool);
  72. UNQLITE_APIEXPORT int unqlite_value_null(unqlite_value *pVal);
  73. UNQLITE_APIEXPORT int unqlite_value_double(unqlite_value *pVal, double Value);
  74. UNQLITE_APIEXPORT int unqlite_value_string(unqlite_value *pVal, const char *zString, int nLen);
  75. UNQLITE_APIEXPORT int unqlite_value_string_format(unqlite_value *pVal, const char *zFormat,...);
  76. UNQLITE_APIEXPORT int unqlite_value_reset_string_cursor(unqlite_value *pVal);
  77. UNQLITE_APIEXPORT int unqlite_value_resource(unqlite_value *pVal, void *pUserData);
  78. UNQLITE_APIEXPORT int unqlite_value_release(unqlite_value *pVal);
  80. /* Foreign Function Parameter Values */
  81. UNQLITE_APIEXPORT int unqlite_value_to_int(unqlite_value *pValue);
  82. UNQLITE_APIEXPORT int unqlite_value_to_bool(unqlite_value *pValue);
  83. UNQLITE_APIEXPORT unqlite_int64 unqlite_value_to_int64(unqlite_value *pValue);
  84. UNQLITE_APIEXPORT double unqlite_value_to_double(unqlite_value *pValue);
  85. UNQLITE_APIEXPORT const char * unqlite_value_to_string(unqlite_value *pValue, int *pLen);
  86. UNQLITE_APIEXPORT void * unqlite_value_to_resource(unqlite_value *pValue);
  87. UNQLITE_APIEXPORT int unqlite_value_compare(unqlite_value *pLeft, unqlite_value *pRight, int bStrict);
  89. /* Setting The Result Of A Foreign Function */
  90. UNQLITE_APIEXPORT int unqlite_result_int(unqlite_context *pCtx, int iValue);
  91. UNQLITE_APIEXPORT int unqlite_result_int64(unqlite_context *pCtx, unqlite_int64 iValue);
  92. UNQLITE_APIEXPORT int unqlite_result_bool(unqlite_context *pCtx, int iBool);
  93. UNQLITE_APIEXPORT int unqlite_result_double(unqlite_context *pCtx, double Value);
  94. UNQLITE_APIEXPORT int unqlite_result_null(unqlite_context *pCtx);
  95. UNQLITE_APIEXPORT int unqlite_result_string(unqlite_context *pCtx, const char *zString, int nLen);
  96. UNQLITE_APIEXPORT int unqlite_result_string_format(unqlite_context *pCtx, const char *zFormat, ...);
  97. UNQLITE_APIEXPORT int unqlite_result_value(unqlite_context *pCtx, unqlite_value *pValue);
  98. UNQLITE_APIEXPORT int unqlite_result_resource(unqlite_context *pCtx, void *pUserData);
  100. /* Dynamically Typed Value Object Query Interfaces */
  101. UNQLITE_APIEXPORT int unqlite_value_is_int(unqlite_value *pVal);
  102. UNQLITE_APIEXPORT int unqlite_value_is_float(unqlite_value *pVal);
  103. UNQLITE_APIEXPORT int unqlite_value_is_bool(unqlite_value *pVal);
  104. UNQLITE_APIEXPORT int unqlite_value_is_string(unqlite_value *pVal);
  105. UNQLITE_APIEXPORT int unqlite_value_is_null(unqlite_value *pVal);
  106. UNQLITE_APIEXPORT int unqlite_value_is_numeric(unqlite_value *pVal);
  107. UNQLITE_APIEXPORT int unqlite_value_is_callable(unqlite_value *pVal);
  108. UNQLITE_APIEXPORT int unqlite_value_is_scalar(unqlite_value *pVal);
  109. UNQLITE_APIEXPORT int unqlite_value_is_json_array(unqlite_value *pVal);
  110. UNQLITE_APIEXPORT int unqlite_value_is_json_object(unqlite_value *pVal);
  111. UNQLITE_APIEXPORT int unqlite_value_is_resource(unqlite_value *pVal);
  112. UNQLITE_APIEXPORT int unqlite_value_is_empty(unqlite_value *pVal);
  114. /* JSON Array/Object Management Interfaces */
  115. UNQLITE_APIEXPORT unqlite_value * unqlite_array_fetch(unqlite_value *pArray, const char *zKey, int nByte);
  116. UNQLITE_APIEXPORT int unqlite_array_walk(unqlite_value *pArray, int (*xWalk)(unqlite_value *, unqlite_value *, void *), void *pUserData);
  117. UNQLITE_APIEXPORT int unqlite_array_add_elem(unqlite_value *pArray, unqlite_value *pKey, unqlite_value *pValue);
  118. UNQLITE_APIEXPORT int unqlite_array_add_strkey_elem(unqlite_value *pArray, const char *zKey, unqlite_value *pValue);
  119. UNQLITE_APIEXPORT int unqlite_array_count(unqlite_value *pArray);
  121. /* Call Context Handling Interfaces */
  122. UNQLITE_APIEXPORT int unqlite_context_output(unqlite_context *pCtx, const char *zString, int nLen);
  123. UNQLITE_APIEXPORT int unqlite_context_output_format(unqlite_context *pCtx,const char *zFormat, ...);
  124. UNQLITE_APIEXPORT int unqlite_context_throw_error(unqlite_context *pCtx, int iErr, const char *zErr);
  125. UNQLITE_APIEXPORT int unqlite_context_throw_error_format(unqlite_context *pCtx, int iErr, const char *zFormat, ...);
  126. UNQLITE_APIEXPORT unsigned int unqlite_context_random_num(unqlite_context *pCtx);
  127. UNQLITE_APIEXPORT int unqlite_context_random_string(unqlite_context *pCtx, char *zBuf, int nBuflen);
  128. UNQLITE_APIEXPORT void * unqlite_context_user_data(unqlite_context *pCtx);
  129. UNQLITE_APIEXPORT int unqlite_context_push_aux_data(unqlite_context *pCtx, void *pUserData);
  130. UNQLITE_APIEXPORT void * unqlite_context_peek_aux_data(unqlite_context *pCtx);
  131. UNQLITE_APIEXPORT unsigned int unqlite_context_result_buf_length(unqlite_context *pCtx);
  132. UNQLITE_APIEXPORT const char * unqlite_function_name(unqlite_context *pCtx);
  134. /* Call Context Memory Management Interfaces */
  135. UNQLITE_APIEXPORT void * unqlite_context_alloc_chunk(unqlite_context *pCtx,unsigned int nByte,int ZeroChunk,int AutoRelease);
  136. UNQLITE_APIEXPORT void * unqlite_context_realloc_chunk(unqlite_context *pCtx,void *pChunk,unsigned int nByte);
  137. UNQLITE_APIEXPORT void unqlite_context_free_chunk(unqlite_context *pCtx,void *pChunk);
  139. /* Global Library Management Interfaces */
  140. UNQLITE_APIEXPORT int unqlite_lib_config(int nConfigOp,...);
  141. UNQLITE_APIEXPORT int unqlite_lib_init(void);
  142. UNQLITE_APIEXPORT int unqlite_lib_shutdown(void);
  143. UNQLITE_APIEXPORT int unqlite_lib_is_threadsafe(void);
  144. UNQLITE_APIEXPORT const char * unqlite_lib_version(void);
  145. UNQLITE_APIEXPORT const char * unqlite_lib_signature(void);
  146. UNQLITE_APIEXPORT const char * unqlite_lib_ident(void);
  147. UNQLITE_APIEXPORT const char * unqlite_lib_copyright(void);

返回码

  1. /* 标准UnQLite返回值 */
  2. #define UNQLITE_OK               /* Successful result */
  3. /* 以下的都是错误码 */
  4. #define UNQLITE_NOMEM            /* Out of memory */
  5. #define UNQLITE_ABORT            /* Another thread have released this instance */
  6. #define UNQLITE_IOERR            /* IO error */
  7. #define UNQLITE_CORRUPT          /* Corrupt pointer */
  8. #define UNQLITE_LOCKED           /* Forbidden Operation */
  9. #define UNQLITE_BUSY                 /* The database file is locked */
  10. #define UNQLITE_DONE                 /* Operation done */
  11. #define UNQLITE_PERM             /* Permission error */
  12. #define UNQLITE_NOTIMPLEMENTED   /* Method not implemented by the underlying Key/Value storage engine */
  13. #define UNQLITE_NOTFOUND         /* No such record */
  14. #define UNQLITE_NOOP             /* No such method */
  15. #define UNQLITE_INVALID          /* Invalid parameter */
  16. #define UNQLITE_EOF              /* End Of Input */
  17. #define UNQLITE_UNKNOWN          /* Unknown configuration option */
  18. #define UNQLITE_LIMIT            /* Database limit reached */
  19. #define UNQLITE_EXISTS           /* Records exists */
  20. #define UNQLITE_EMPTY            /* Empty record */
  21. #define UNQLITE_COMPILE_ERR      /* Compilation error */
  22. #define UNQLITE_VM_ERR           /* Virtual machine error */
  23. #define UNQLITE_FULL             /* Full database (unlikely) */
  24. #define UNQLITE_CANTOPEN         /* Unable to open the database file */
  25. #define UNQLITE_READ_ONLY        /* Read only Key/Value storage engine */
  26. #define UNQLITE_LOCKERR          /* Locking protocol error */

Demo

参考文档：

  • https://unqlite.github.io/2013/05/26/intro/，五分钟玩转UnQLite
  • https://unqlite.github.io/archive/，存档
  • https://unqlite.org/c\_api\_func.html，该目录查看**每个接口函数的具体使用**

Key/Value存储

涉及到事务ACID的操作，得用一个pDb handler，然后事务回滚。
对于KV操作，可以结合cJSON库，将需要存储的表记录（struct结构体定义的表结构）转换为json串，作为value。

  1. #include <unqlite.h>
  2.   int i,rc;
  3.   unqlite *pDb;
  5.   // Open our database;
  6.   rc = unqlite_open(&pDb,"test.db",UNQLITE_OPEN_CREATE);
  7.   if( rc != UNQLITE_OK ){
  8.      return; }
  10.   // Store some records
  11.   rc = unqlite_kv_store(pDb,"test",-1,"Hello World",11); //test => 'Hello World'
  12.   if( rc != UNQLITE_OK ){
  14.    //Insertion fail, Hande error (See below)
  15.     return;
  16.   }
  17.   // A small formatted string
  18.   rc = unqlite_kv_store_fmt(pDb,"date",-1,"Current date: %d:%d:%d",2013,06,07);
  19.   if( rc != UNQLITE_OK ){
  21.     //Insertion fail, Hande error (See below)
  22.     return;
  23.   }
  25.   //Switch to the append interface
  26.   rc = unqlite_kv_append(pDb,"msg",-1,"Hello, ",7); //msg => 'Hello, '
  27.   if( rc == UNQLITE_OK ){
  29.     //The second chunk
  30.     rc = unqlite_kv_append(pDb,"msg",-1,"Current time is: ",17); //msg => 'Hello, Current time is: '
  31.     if( rc == UNQLITE_OK ){
  33.       //The last formatted chunk
  34.       rc = unqlite_kv_append_fmt(pDb,"msg",-1,"%d:%d:%d",10,16,53); //msg => 'Hello, Current time is: 10:16:53'
  35.     }
  36.   }
  38.   //Delete a record
  39.   unqlite_kv_delete(pDb,"test",-1);
  41.   //Store 20 random records.
  42.   for(i = 0 ; i < 20 ; ++i ){
  44.     char zKey[12]; //Random generated key
  45.     char zData[34]; //Dummy data
  47.     // generate the random key
  48.     unqlite_util_random_string(pDb,zKey,sizeof(zKey));
  50.     // Perform the insertion
  51.     rc = unqlite_kv_store(pDb,zKey,sizeof(zKey),zData,sizeof(zData));
  52.     if( rc != UNQLITE_OK ){
  54.       break;
  55.      }
  56.   }
  58.   if( rc != UNQLITE_OK ){
  60.     //Insertion fail, Handle error
  61.     const char *zBuf;
  62.     int iLen;
  63.     /* Something goes wrong, extract the database error log */
  64.     unqlite_config(pDb,UNQLITE_CONFIG_ERR_LOG,&zBuf,&iLen);
  65.     if( iLen > 0 ){
  67.       puts(zBuf);
  68.      }
  69.     if( rc != UNQLITE_BUSY && rc != UNQLITE_NOTIMPLEMENTED ){
  71.       /* Rollback */
  72.       unqlite_rollback(pDb);
  73.      }
  74.   }
  76.   //Auto-commit the transaction and close our handle.
  77.   unqlite_close(pDb);

数据库游标

游标提供了一种机制，通过它，你可以遍历整个数据库的记录。使用游标，你可以定位，提取，移动和删除数据库记录。

  1. #include <unqlite.h>
  3.   int rc;
  4.   unqlite *pDb;
  5.   unqlite_kv_cursor *pCursor;
  6.   unqlite_int64 iData;
  8.   // Open our database;
  9.   rc = unqlite_open(&pDb,"test.db",UNQLITE_OPEN_CREATE);
  10.   if( rc != UNQLITE_OK ){
  11.      return; }
  13.   //Store some records unqlite_kv_store(), unqlite_kv_append()...
  15.   /* Allocate a new cursor instance */
  16.   rc = unqlite_kv_cursor_init(pDb,&pCursor);
  17.   if( rc != UNQLITE_OK ){
  18.      return; }
  20.   /* Point to the last record */
  21.   rc = unqlite_kv_cursor_last_entry(pCursor);
  22.   if( rc != UNQLITE_OK ){
  23.      return; }
  25.   /* Iterate over the records */
  26.   while( unqlite_kv_cursor_valid_entry(pCursor) ){
  28.     /* Consume the key */
  29.     printf("\nKey ==>\n\t");
  30.     unqlite_kv_cursor_key_callback(pCursor,DataConsumerCallback,0);
  32.     /* Extract data length */
  33.     unqlite_kv_cursor_data(pCursor,NULL,&iData);
  34.     printf("\nData length ==> %lld\n\t",iData);
  36.     /* Consume the data */
  37.     unqlite_kv_cursor_data_callback(pCursor,DataConsumerCallback,0);
  39.     /* Point to the previous record */
  40.      unqlite_kv_cursor_prev_entry(pCursor);
  41.   }
  43.   /* Finally, Release our cursor */
  44.   unqlite_kv_cursor_release(pDb,pCursor);
  46.   //Auto-commit the transaction and close our handle
  47.   unqlite_close(pDb);

发表评论

表情：
评论列表 （有 0 条评论，83人围观）

还没有评论，来说两句吧...

相关阅读

    相关 UnQLite入门

    UnQLite简介UnQLite是，由 Symisc Systems公司出品的一个嵌入式C语言软件库，它实现了一个自包含、无服务器、零配置、事务化的NoSQL数据库引擎。...

    川长思鸟来川长思鸟来/ 0 赞/ 84 阅读

    相关 Arduino入门,Arduino入门

    Arduino入门： 于2012年2月1日在搜索颜色识别传感器时，了解到了arduino，仔细查阅了一下资料发现了新大陆，这个东西很有意思入门也不难。而且加上现在的移动互联，

    短命女短命女/ 0 赞/ 528 阅读

    相关 【MongoDb入门】基础入门

     关于mongodb的好处，优点之类的这里就不说了，唯一要讲的一点就是mongodb中有三元素：数据库，集合，文档，其中“集合” 就是对应关系数据库中的“表”，“文档”对应“

    港控/mmm°港控/mmm°/ 0 赞/ 449 阅读

    相关 Vuex从入门到入门

    Vuex 是什么？ 官方是这么说的：Vuex 是一个专为 Vue.js 应用程序开发的状态管理模式。它采用集中式存储管理应用的所有组件的状态，并以相应的规则保证状态以一种

    一时失言乱红尘一时失言乱红尘/ 0 赞/ 557 阅读