kandi background
Explore Kits

CBoard | service open BI reporting and BI dashboard platform | SQL Database library

 by   TuiQiao JavaScript Version: Current License: Apache-2.0

 by   TuiQiao JavaScript Version: Current License: Apache-2.0

Download this library from

kandi X-RAY | CBoard Summary

CBoard is a JavaScript library typically used in Database, SQL Database applications. CBoard has no bugs, it has no vulnerabilities, it has a Permissive License and it has medium support. You can download it from GitHub.
CBoard is not only a analysis platform that supports interactive multi-dimensional report design and data analysis for user, but also a BI product development platform for developer. Powered by Shanhai Chuguo Information and Technology Co., Ltd.
Support
Support
Quality
Quality
Security
Security
License
License
Reuse
Reuse

kandi-support Support

  • CBoard has a medium active ecosystem.
  • It has 2708 star(s) with 1120 fork(s). There are 284 watchers for this library.
  • It had no major release in the last 12 months.
  • There are 94 open issues and 500 have been closed. On average issues are closed in 29 days. There are 2 open pull requests and 0 closed requests.
  • It has a neutral sentiment in the developer community.
  • The latest version of CBoard is current.
CBoard Support
Best in #SQL Database
Average in #SQL Database
CBoard Support
Best in #SQL Database
Average in #SQL Database

quality kandi Quality

  • CBoard has 0 bugs and 0 code smells.
CBoard Quality
Best in #SQL Database
Average in #SQL Database
CBoard Quality
Best in #SQL Database
Average in #SQL Database

securitySecurity

  • CBoard has no vulnerabilities reported, and its dependent libraries have no vulnerabilities reported.
  • CBoard code analysis shows 0 unresolved vulnerabilities.
  • There are 0 security hotspots that need review.
CBoard Security
Best in #SQL Database
Average in #SQL Database
CBoard Security
Best in #SQL Database
Average in #SQL Database

license License

  • CBoard is licensed under the Apache-2.0 License. This license is Permissive.
  • Permissive licenses have the least restrictions, and you can use them in most projects.
CBoard License
Best in #SQL Database
Average in #SQL Database
CBoard License
Best in #SQL Database
Average in #SQL Database

buildReuse

  • CBoard releases are not available. You will need to build from source code and install.
  • It has 112669 lines of code, 1111 functions and 720 files.
  • It has medium code complexity. Code complexity directly impacts maintainability of the code.
CBoard Reuse
Best in #SQL Database
Average in #SQL Database
CBoard Reuse
Best in #SQL Database
Average in #SQL Database
Top functions reviewed by kandi - BETA

kandi has reviewed CBoard and discovered the below as its top functions. This is intended to give you an instant insight into CBoard implemented functionality, and help decide if they suit your requirements.

  • Plot class for plot elements
    • Creates a mask for the modal set .
      • Initialize Event Manager
        • Constructs a new calendar .
          • Creates a new Slider .
            • Creates a new range object .
              • Render the header
                • Update the mask and maskets the result set .
                  • D3 - > D3
                    • Generate an array of masks based on the input parameters .

                      Get all kandi verified functions for this library.

                      Get all kandi verified functions for this library.

                      CBoard Key Features

                      Simple and beautiful interface and layout

                      Interactive, drag-and-drop OLAP classisc report development experience

                      One dataset, multiple report widgets. Maximize reuse query result

                      Cube level data refresh / realtime chart for quick query

                      Role Based Access Control

                      More than 20 chart types and dashboard insight or email report

                      Multiple types data source connection Support JDBC data connection (Almost all kinds database that has implemented JDBC protocal) Support Native Elasticsearch connection for version 1.x, 2.x, 5.x Support Native Kylin connection for version 1.6

                      Lightweight architecture and concise source code, the entire project does not rely on any third-party multi-dimensional analysis tools, if you are struggling in Mondrain, CBoard could be a nice alternative for you.

                      Easy to implement your own DataProvider to connect any data source. Even for expensive commercial BI suite, it's not possible to connect all the NOSQL and NewSQL data source in the era of big data. Due to the schema of NOSQL are various, such as hash tables, arrays, trees, maps, etc., different people using the same NoSQL products designed Schema may vary widely. The user who most familiar with their storage schema are the user themselves. And it's easy to find a Java programmers to code a Class to connect their own data source. So we leave this part of work to the end user with an easy extended data connection framework in CBoard

                      CBoard Examples and Code Snippets

                      See all related Code Snippets

                      How do I find the RAM usage of a process using its ID?

                      copy iconCopydownload iconDownload
                          // ...
                          anon = get_mm_counter(mm, MM_ANONPAGES);
                          file = get_mm_counter(mm, MM_FILEPAGES);
                          shmem = get_mm_counter(mm, MM_SHMEMPAGES);
                          // ...
                          hiwater_rss = total_rss = anon + file + shmem;
                          // ...
                          SEQ_PUT_DEC(" kB\nVmHWM:\t", hiwater_rss);
                          SEQ_PUT_DEC(" kB\nVmRSS:\t", total_rss); // <===== here it is
                          SEQ_PUT_DEC(" kB\nRssAnon:\t", anon);
                          // ...
                      
                      // SPDX-License-Identifier: GPL-3.0
                      #include <linux/kernel.h>       // printk(), pr_*()
                      #include <linux/module.h>       // THIS_MODULE, MODULE_VERSION, ...
                      #include <linux/init.h>         // module_{init,exit}
                      #include <linux/sched/task.h>   // struct task_struct, {get,put}_task_struct()
                      #include <linux/sched/signal.h> // for_each_process()
                      #include <linux/mm.h>           // get_mm_rss()
                      
                      /* Tested on kernel 5.6, qemu-system-aarch64
                       * Usage: sudo insmod task_rss
                       *        sudo modprobe task_rss
                       */
                      
                      #ifdef pr_fmt
                      #undef pr_fmt
                      #endif
                      #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
                      
                      static int __init modinit(void)
                      {
                          struct task_struct *tsk;
                          unsigned long rss;
                      
                      #ifndef CONFIG_MMU
                          pr_err("No MMU, cannot calculate RSS.\n");
                          return -EINVAL;
                      #endif
                      
                          for_each_process(tsk) {
                              get_task_struct(tsk);
                      
                              // https://www.kernel.org/doc/Documentation/vm/active_mm.rst
                              if (tsk->mm) {
                                  rss = get_mm_rss(tsk->mm) << PAGE_SHIFT;
                                  pr_info("PID %d (\"%s\") VmRSS = %lu bytes\n", tsk->pid, tsk->comm, rss);
                              } else {
                                  pr_info("PID %d (\"%s\") is an anonymous process\n", tsk->pid, tsk->comm);
                              }
                      
                              put_task_struct(tsk);
                          }
                      
                          return 0;
                      }
                      
                      static void __exit modexit(void)
                      {
                          // This function is only needed to be able to unload the module.
                      }
                      
                      module_init(modinit);
                      module_exit(modexit);
                      MODULE_VERSION("0.1");
                      MODULE_DESCRIPTION("Silly test module to calculare task RSS of all running tasks.");
                      MODULE_AUTHOR("Marco Bonelli");
                      MODULE_LICENSE("GPL");
                      
                      / # insmod task_rss.ko
                      [    7.306284] task_rss: loading out-of-tree module taints kernel.
                      [    7.312912] task_rss: PID 1 ("init") VmRSS = 4096 bytes
                      [    7.313295] task_rss: PID 2 ("kthreadd") is an anonymous process
                      [    7.314039] task_rss: PID 3 ("rcu_gp") is an anonymous process
                      ...
                      [    7.330169] task_rss: PID 146 ("sh") VmRSS = 1363968 bytes
                      [    7.330554] task_rss: PID 147 ("insmod") VmRSS = 1339392 bytes
                      
                          // ...
                          anon = get_mm_counter(mm, MM_ANONPAGES);
                          file = get_mm_counter(mm, MM_FILEPAGES);
                          shmem = get_mm_counter(mm, MM_SHMEMPAGES);
                          // ...
                          hiwater_rss = total_rss = anon + file + shmem;
                          // ...
                          SEQ_PUT_DEC(" kB\nVmHWM:\t", hiwater_rss);
                          SEQ_PUT_DEC(" kB\nVmRSS:\t", total_rss); // <===== here it is
                          SEQ_PUT_DEC(" kB\nRssAnon:\t", anon);
                          // ...
                      
                      // SPDX-License-Identifier: GPL-3.0
                      #include <linux/kernel.h>       // printk(), pr_*()
                      #include <linux/module.h>       // THIS_MODULE, MODULE_VERSION, ...
                      #include <linux/init.h>         // module_{init,exit}
                      #include <linux/sched/task.h>   // struct task_struct, {get,put}_task_struct()
                      #include <linux/sched/signal.h> // for_each_process()
                      #include <linux/mm.h>           // get_mm_rss()
                      
                      /* Tested on kernel 5.6, qemu-system-aarch64
                       * Usage: sudo insmod task_rss
                       *        sudo modprobe task_rss
                       */
                      
                      #ifdef pr_fmt
                      #undef pr_fmt
                      #endif
                      #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
                      
                      static int __init modinit(void)
                      {
                          struct task_struct *tsk;
                          unsigned long rss;
                      
                      #ifndef CONFIG_MMU
                          pr_err("No MMU, cannot calculate RSS.\n");
                          return -EINVAL;
                      #endif
                      
                          for_each_process(tsk) {
                              get_task_struct(tsk);
                      
                              // https://www.kernel.org/doc/Documentation/vm/active_mm.rst
                              if (tsk->mm) {
                                  rss = get_mm_rss(tsk->mm) << PAGE_SHIFT;
                                  pr_info("PID %d (\"%s\") VmRSS = %lu bytes\n", tsk->pid, tsk->comm, rss);
                              } else {
                                  pr_info("PID %d (\"%s\") is an anonymous process\n", tsk->pid, tsk->comm);
                              }
                      
                              put_task_struct(tsk);
                          }
                      
                          return 0;
                      }
                      
                      static void __exit modexit(void)
                      {
                          // This function is only needed to be able to unload the module.
                      }
                      
                      module_init(modinit);
                      module_exit(modexit);
                      MODULE_VERSION("0.1");
                      MODULE_DESCRIPTION("Silly test module to calculare task RSS of all running tasks.");
                      MODULE_AUTHOR("Marco Bonelli");
                      MODULE_LICENSE("GPL");
                      
                      / # insmod task_rss.ko
                      [    7.306284] task_rss: loading out-of-tree module taints kernel.
                      [    7.312912] task_rss: PID 1 ("init") VmRSS = 4096 bytes
                      [    7.313295] task_rss: PID 2 ("kthreadd") is an anonymous process
                      [    7.314039] task_rss: PID 3 ("rcu_gp") is an anonymous process
                      ...
                      [    7.330169] task_rss: PID 146 ("sh") VmRSS = 1363968 bytes
                      [    7.330554] task_rss: PID 147 ("insmod") VmRSS = 1339392 bytes
                      
                          // ...
                          anon = get_mm_counter(mm, MM_ANONPAGES);
                          file = get_mm_counter(mm, MM_FILEPAGES);
                          shmem = get_mm_counter(mm, MM_SHMEMPAGES);
                          // ...
                          hiwater_rss = total_rss = anon + file + shmem;
                          // ...
                          SEQ_PUT_DEC(" kB\nVmHWM:\t", hiwater_rss);
                          SEQ_PUT_DEC(" kB\nVmRSS:\t", total_rss); // <===== here it is
                          SEQ_PUT_DEC(" kB\nRssAnon:\t", anon);
                          // ...
                      
                      // SPDX-License-Identifier: GPL-3.0
                      #include <linux/kernel.h>       // printk(), pr_*()
                      #include <linux/module.h>       // THIS_MODULE, MODULE_VERSION, ...
                      #include <linux/init.h>         // module_{init,exit}
                      #include <linux/sched/task.h>   // struct task_struct, {get,put}_task_struct()
                      #include <linux/sched/signal.h> // for_each_process()
                      #include <linux/mm.h>           // get_mm_rss()
                      
                      /* Tested on kernel 5.6, qemu-system-aarch64
                       * Usage: sudo insmod task_rss
                       *        sudo modprobe task_rss
                       */
                      
                      #ifdef pr_fmt
                      #undef pr_fmt
                      #endif
                      #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
                      
                      static int __init modinit(void)
                      {
                          struct task_struct *tsk;
                          unsigned long rss;
                      
                      #ifndef CONFIG_MMU
                          pr_err("No MMU, cannot calculate RSS.\n");
                          return -EINVAL;
                      #endif
                      
                          for_each_process(tsk) {
                              get_task_struct(tsk);
                      
                              // https://www.kernel.org/doc/Documentation/vm/active_mm.rst
                              if (tsk->mm) {
                                  rss = get_mm_rss(tsk->mm) << PAGE_SHIFT;
                                  pr_info("PID %d (\"%s\") VmRSS = %lu bytes\n", tsk->pid, tsk->comm, rss);
                              } else {
                                  pr_info("PID %d (\"%s\") is an anonymous process\n", tsk->pid, tsk->comm);
                              }
                      
                              put_task_struct(tsk);
                          }
                      
                          return 0;
                      }
                      
                      static void __exit modexit(void)
                      {
                          // This function is only needed to be able to unload the module.
                      }
                      
                      module_init(modinit);
                      module_exit(modexit);
                      MODULE_VERSION("0.1");
                      MODULE_DESCRIPTION("Silly test module to calculare task RSS of all running tasks.");
                      MODULE_AUTHOR("Marco Bonelli");
                      MODULE_LICENSE("GPL");
                      
                      / # insmod task_rss.ko
                      [    7.306284] task_rss: loading out-of-tree module taints kernel.
                      [    7.312912] task_rss: PID 1 ("init") VmRSS = 4096 bytes
                      [    7.313295] task_rss: PID 2 ("kthreadd") is an anonymous process
                      [    7.314039] task_rss: PID 3 ("rcu_gp") is an anonymous process
                      ...
                      [    7.330169] task_rss: PID 146 ("sh") VmRSS = 1363968 bytes
                      [    7.330554] task_rss: PID 147 ("insmod") VmRSS = 1339392 bytes
                      

                      C++ dll in subfolder

                      copy iconCopydownload iconDownload
                      #pragma comment(lib, "mainlib.lib")
                      
                      SetDllDirectory("absolute_path_to_my_DLLs_folder")
                      
                      #pragma comment(lib, "mainlib.lib")
                      
                      SetDllDirectory("absolute_path_to_my_DLLs_folder")
                      

                      See all related Code Snippets

                      Community Discussions

                      Trending Discussions on CBoard
                      • How do I find the RAM usage of a process using its ID?
                      • C++ dll in subfolder
                      Trending Discussions on CBoard

                      QUESTION

                      How do I find the RAM usage of a process using its ID?

                      Asked 2021-May-10 at 14:05

                      I am really new to this Kernel stuff. I went here and I found this code that outputs process information like its ID.

                      main.c:

                      #include <linux/kernel.h>
                      #include <linux/module.h>
                      #include <linux/init.h>
                      #include <linux/sched/signal.h>
                      #include <linux/sched.h>
                       
                       
                      struct task_struct *task;        /*    Structure defined in sched.h for tasks/processes    */
                      struct task_struct *task_child;        /*    Structure needed to iterate through task children    */
                      struct list_head *list;            /*    Structure needed to iterate through the list in each task->children struct    */
                       
                      int iterate_init(void)                    /*    Init Module    */
                      {
                          printk(KERN_INFO "%s","LOADING MODULE\n");    /*    good practice to log when loading/removing modules    */
                           
                          for_each_process( task ){            /*    for_each_process() MACRO for iterating through each task in the os located in linux\sched\signal.h    */
                              printk(KERN_INFO "\nPARENT PID: %d PROCESS: %s STATE: %ld",task->pid, task->comm, task->state);/*    log parent id/executable name/state    */
                              list_for_each(list, &task->children){                        /*    list_for_each MACRO to iterate through task->children    */
                       
                                  task_child = list_entry( list, struct task_struct, sibling );    /*    using list_entry to declare all vars in task_child struct    */
                           
                                  printk(KERN_INFO "\nCHILD OF %s[%d] PID: %d PROCESS: %s STATE: %ld",task->comm, task->pid, /*    log child of and child pid/name/state    */
                                      task_child->pid, task_child->comm, task_child->state);
                              }
                              printk("-----------------------------------------------------");    /*for aesthetics*/
                          }    
                           
                       
                          return 0;
                       
                      }                /*    End of Init Module    */
                           
                      void cleanup_exit(void)        /*    Exit Module    */
                      {
                       
                       
                          printk(KERN_INFO "%s","REMOVING MODULE\n");
                       
                      }                /*    End of Exit Module    */
                       
                      module_init(iterate_init);    /*    Load Module MACRO    */
                      module_exit(cleanup_exit);    /*    Remove Module MACRO    */
                       
                      MODULE_LICENSE("GPL");
                      MODULE_DESCRIPTION("ITERATE THROUGH ALL PROCESSES/CHILD PROCESSES IN THE OS");
                      MODULE_AUTHOR("Laerehte");
                      

                      Makefile:

                      obj-m += main.o
                       
                      all:
                          make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules
                       
                      clean:
                          make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean
                      

                      Executed with ./ins (with chmod +x)

                      Code:

                      sudo insmod main.ko
                      sudo rmmod main
                      sudo dmesg -c
                      

                      I looked up how to find how much memory a process uses, and I found this question: Memory usage of current process in C.

                      Correct me if I'm wrong here, but I'm thinking that you can read the current RAM usage of these processes by looking in /proc/[process_id]/status. I found out from another place(forgot where) that within this file, there is something called VmRSS that would hold the current RAM usage of the process.

                      You can apparently use:

                      ssize_t kernel_read(struct file *file, void *buf, size_t count, loff_t *pos);
                      

                      to read a file, but I have not been able to modify main.c with this successfully. I need to find the size of the file, but I also have not been able to use vfs_stat correctly. When I just try some constant integer, I get all 0s in the buffer anyway. I don't know how to use these functions properly. I'm trying to modify main.c so that I will see the RAM usage of these processes along with the other information. Much of the information I found was outdated. Can anyone help?

                      ANSWER

                      Answered 2021-May-10 at 14:05

                      While you can technically open and read files from kernel space, it's usually a bad idea for multiple reasons. Whatever information is provided under /proc is already available to the kernel, you just need to figure out where it is and how to obtain it, and you will be able to do everything in your module without reading any file.

                      You are interested in knowing how much RAM is a particular process using given its PID, and you are correct that this statistic is available in /proc/<PID>/status: in fact, it is labeled as "VmRSS" which means "virtual memory resident set size". If we take a look at the kernel source code, we can see exactly how that number is calculated:

                      The kernel function called when reading /proc/<PID>/status is proc_pid_status() in fs/proc/array.c, which then calls (among the other things) task_mem().

                          // ...
                          anon = get_mm_counter(mm, MM_ANONPAGES);
                          file = get_mm_counter(mm, MM_FILEPAGES);
                          shmem = get_mm_counter(mm, MM_SHMEMPAGES);
                          // ...
                          hiwater_rss = total_rss = anon + file + shmem;
                          // ...
                          SEQ_PUT_DEC(" kB\nVmHWM:\t", hiwater_rss);
                          SEQ_PUT_DEC(" kB\nVmRSS:\t", total_rss); // <===== here it is
                          SEQ_PUT_DEC(" kB\nRssAnon:\t", anon);
                          // ...
                      

                      You can therefore obtain this information in the same way. First get ahold of the task_struct of the process you want to check, then inspect the ->mm field like get_mm_counter() does, or simply using get_mm_rss() from include/linux/mm.h, which does exactly what we want.

                      Note that:

                      1. The value obtained from get_mm_counter() or get_mm_rss() is the number of pages, you will have to multiply this by the page size (simply shift left by PAGE_SHIFT).
                      2. You will only be able to do this if your kernel was compiled with MMU support (CONFIG_MMU=y), you can check this in your module code with a simple #ifdef or #ifndef.

                      Here's a working example module to do this for all processes:

                      // SPDX-License-Identifier: GPL-3.0
                      #include <linux/kernel.h>       // printk(), pr_*()
                      #include <linux/module.h>       // THIS_MODULE, MODULE_VERSION, ...
                      #include <linux/init.h>         // module_{init,exit}
                      #include <linux/sched/task.h>   // struct task_struct, {get,put}_task_struct()
                      #include <linux/sched/signal.h> // for_each_process()
                      #include <linux/mm.h>           // get_mm_rss()
                      
                      /* Tested on kernel 5.6, qemu-system-aarch64
                       * Usage: sudo insmod task_rss
                       *        sudo modprobe task_rss
                       */
                      
                      #ifdef pr_fmt
                      #undef pr_fmt
                      #endif
                      #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
                      
                      static int __init modinit(void)
                      {
                          struct task_struct *tsk;
                          unsigned long rss;
                      
                      #ifndef CONFIG_MMU
                          pr_err("No MMU, cannot calculate RSS.\n");
                          return -EINVAL;
                      #endif
                      
                          for_each_process(tsk) {
                              get_task_struct(tsk);
                      
                              // https://www.kernel.org/doc/Documentation/vm/active_mm.rst
                              if (tsk->mm) {
                                  rss = get_mm_rss(tsk->mm) << PAGE_SHIFT;
                                  pr_info("PID %d (\"%s\") VmRSS = %lu bytes\n", tsk->pid, tsk->comm, rss);
                              } else {
                                  pr_info("PID %d (\"%s\") is an anonymous process\n", tsk->pid, tsk->comm);
                              }
                      
                              put_task_struct(tsk);
                          }
                      
                          return 0;
                      }
                      
                      static void __exit modexit(void)
                      {
                          // This function is only needed to be able to unload the module.
                      }
                      
                      module_init(modinit);
                      module_exit(modexit);
                      MODULE_VERSION("0.1");
                      MODULE_DESCRIPTION("Silly test module to calculare task RSS of all running tasks.");
                      MODULE_AUTHOR("Marco Bonelli");
                      MODULE_LICENSE("GPL");
                      

                      Output on my machine (qemu-system-aarch64):

                      / # insmod task_rss.ko
                      [    7.306284] task_rss: loading out-of-tree module taints kernel.
                      [    7.312912] task_rss: PID 1 ("init") VmRSS = 4096 bytes
                      [    7.313295] task_rss: PID 2 ("kthreadd") is an anonymous process
                      [    7.314039] task_rss: PID 3 ("rcu_gp") is an anonymous process
                      ...
                      [    7.330169] task_rss: PID 146 ("sh") VmRSS = 1363968 bytes
                      [    7.330554] task_rss: PID 147 ("insmod") VmRSS = 1339392 bytes
                      

                      Source https://stackoverflow.com/questions/67224020

                      Community Discussions, Code Snippets contain sources that include Stack Exchange Network

                      Vulnerabilities

                      No vulnerabilities reported

                      Install CBoard

                      You can download it from GitHub.

                      Support

                      Multiple kinds of data source plugins. Drag-and-drop self-service multidimensional analysis. More than 20 kinds of chart type. :white_check_mark: + 明细表 + GIS中国地图. Layout by row and column, view and design are seperated. Free layout and live preview. Add date range filter, checkbox, searchable dropdown selector filter, keyword input filter. Design for developers, simple support based on raw data columns. Design for data analyst, complete chart linkage mechanism to support linkage to datasets, billboards. :x: All charts must first be saved and managed in the Widget Config design area. Support insert inline chart in dashboard. Cusomize sort dimension members. More powerful and easy to use. GIS Map chart on detail data. :star::star: Data cell level control and support role based data access control. Folder based resource managment system. :x: Only support virtual path based folder. OS likly file system solution. ACL can be managed by folder. :star::star: Supports advanced calculations such as year-on-year, aspect ratio, percentage, totals, subtotals, cell conditional styles. Iframe external system integration with parameter control. VueJS + ES6 + Webpack. :white_check_mark: Escort your production environment. :white_check_mark: + 明细表 + GIS中国地图. VueJS + ES6 + Webpack,优化首页加载速度,更适应于云端部署. More enterprise features please access our homepage: 上海楚果信息技术有限公司.

                      DOWNLOAD this Library from

                      Find, review, and download reusable Libraries, Code Snippets, Cloud APIs from
                      over 430 million Knowledge Items
                      Find more libraries
                      Reuse Solution Kits and Libraries Curated by Popular Use Cases
                      Explore Kits

                      Save this library and start creating your kit

                      Explore Related Topics

                      Share this Page

                      share link
                      Consider Popular SQL Database Libraries
                      Try Top Libraries by TuiQiao
                      • CBoardDoc

                        by TuiQiao CSS

                      Compare SQL Database Libraries with Highest Support
                      Compare SQL Database Libraries with Highest Quality
                      Compare SQL Database Libraries with Highest Security
                      Compare SQL Database Libraries with Permissive License
                      Compare SQL Database Libraries with Highest Reuse
                      Find, review, and download reusable Libraries, Code Snippets, Cloud APIs from
                      over 430 million Knowledge Items
                      Find more libraries
                      Reuse Solution Kits and Libraries Curated by Popular Use Cases
                      Explore Kits

                      Save this library and start creating your kit

                      • © 2022 Open Weaver Inc.