React-native-quick-sqlite - ⚡️ The fastest SQLite implementation for react-native.

Overview

React Native Quick SQLite

The **fastest** SQLite implementation for react-native.

Frame 2

    Copy typeORM patch-package from example dir
    npm i react-native-quick-sqlite typeorm
    npx pod-install
    Enable decorators and configure babel
  


Quick SQLite uses JSI, removes all the overhead of intercommunication between JavaScript code and C++ code, making CRUDing entities from SQLite super fast!

Big ❤️ to react-native-sqlite-storage and react-native-sqlite2, this library also provides a WebSQL interface.

If you are using quick-sqlite in your app, please get in touch or open a PR with a modified README (with your company/product logo, would love to showcase you!

GOTCHAS

  • It's not possible to use the browser debugger with JSI, use Flipper, on android Flipper also has an integrated database explorer you can use to debug your sqlite database, you will have to configure your database path though. 130516553-15c18d0f-65ad-44cf-8235-a4d6f41859e2
  • Your app will now include C++, you will need to install the NDK on your machine for android. (unless you know how to generate an AAR, feel free to open a PR)
  • If you want to run the example project on android, you will have to change the paths on the android/CMakeLists.txt file, they are already there, just uncomment them.
  • This library supports SQLite BLOBs which are mapped to JS ArrayBuffers, check out the sample project on how to use it
  • Starting with version 2.0.0 the library no longer throws errors when an invalid statement is passed, but rather returns an object with a status enum property, where 0 signals a succesful execution and 1 an incorrect execution (this is to keep typeorm from exploding when an incorrect query is executed)

Use TypeORM

The recommended way to use this package is to use TypeORM with patch-package. TypeORM already has a sqlite-storage driver. In the example project on the patch folder you can a find a patch for TypeORM, it basically just replaces all the react-native-sqlite-storage strings in TypeORM with react-native-quick-sqlite.

Follow the instructions to make TypeORM work with rn (enable decorators, configure babel, etc), then apply the patch via patch-package and you should be good to go.

Low level API

It is also possible to directly execute SQL against the db:

interface ISQLite {
  open: (dbName: string, location?: string) => any;
  close: (dbName: string, location?: string) => any;
  executeSql: (
    dbName: string,
    query: string,
    params: any[] | undefined
  ) => {
    status: 0 | 1; // 0 for correct execution
    message: string; // if status === 1, here you will find error description
    rows: any[];
    insertId?: number;
  };
}

In your code

// If you want to register the (globalThis) types for the low level API do an empty import
import 'react-native-quick-sqlite';

// `sqlite` is a globally registered object, so you can directly call it from anywhere in your javascript
// The methods `throw` when an execution error happens, so try/catch them
try {
  sqlite.open('myDatabase', 'databases');
} catch (e) {
  console.log(e); // [react-native-quick-sqlite]: Could not open database file: ERR XXX
}

JSI Cheatsheet

If you want to learn how to make your own JSI module and also get a reference guide for all things C++/JSI you can buy my JSI/C++ Cheatsheet

License

react-native-quick-sqlite is licensed under MIT.

Issues
  • Issues with reading JSON strings in SQLite rows

    Issues with reading JSON strings in SQLite rows

    Hi,

    I was using expo-sqlite package with TypeORM package in my React Native app, and I decided to change the adapter to this package.

    Everything mostly works, however some of my content are stored using simple-json data type in TypeORM, which uses JSON.stringify to store JSON data in SQLite. When reading this data from SQLite using this package, some of the content are terminated unexpectedly. Not everything. But some of them for example are missing the final } in the string...

    Do you have any ideas where this issue may be coming from? Thanks!

    opened by sallar 26
  • Enable JSON1 on Android

    Enable JSON1 on Android

    Hi, Is there a way to enable JSON1 module for Android in order to use json_extract in SQL queries ?

    This also can be a good point about the cross-platform compatibility since iOS manage it already. Thanks for help.

    opened by LaGregance 15
  • Support for SQLite Compile-Time Options?

    Support for SQLite Compile-Time Options?

    Looking at this library as a replacement for react-native-sqlite-storage in a project I'm working on and first impressions are great.

    I've got requirements for enabling FTS5 and Geopoly extensions. This seems possible with this library as opposed to RNSS since the SQLite source is compiled from /cpp for both iOS and Android, instead of using the phone's SQLite. Is there any method of setting compile-time options for enabling specific extensions (e.g. SQLITE_ENABLE_GEOPOLY) ?

    The closest I have reached is presuming that you can set options somewhere in 'CMakeLists.txt' for Android and the podspec for iOS, but I've not been having any luck.

    Thanks.

    opened by HaydenPWoods 12
  • Add async exec call

    Add async exec call

    Managed to implement spawning a C++ thread and returning the result of the SQL execution

    @EduFrazao would you mind giving it a test? Try to run your queries with the asyncExecuteSql method

    TODOS:

    • [x] Clean up example project
    • [x] Test on android
    • [ ] Check that the types are working correctly on a new project
    • [ ] Add an exception for eslint (currently throws no-undef for the global sqlite object)
    enhancement help wanted 
    opened by ospfranco 10
  • Exceptions cause app to crash on Android

    Exceptions cause app to crash on Android

    When exceptions happen on Android, the entire app crashes with an error like this in logcat. react-native-sqlite-storage and expo-sqlite show the error in the app instead. An example of a query that crashes the app is upsert operations.

    11-16 19:19:10.116 19657 19817 F libc    : Fatal signal 6 (SIGABRT), code -1 (SI_QUEUE) in tid 19817 (mqt_js), pid 19657 (smtg.clinic.dev)
    11-16 19:19:10.862 19878 19878 F DEBUG   : *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
    11-16 19:19:10.863 19878 19878 F DEBUG   : Build fingerprint: 'OnePlus/OnePlus6/OnePlus6:10/QKQ1.190716.003/2103022249:user/release-keys'
    11-16 19:19:10.863 19878 19878 F DEBUG   : Revision: '0'
    11-16 19:19:10.863 19878 19878 F DEBUG   : ABI: 'arm64'
    11-16 19:19:10.864 19878 19878 F DEBUG   : Timestamp: 2021-11-16 19:19:10+0200
    11-16 19:19:10.864 19878 19878 F DEBUG   : pid: 19657, tid: 19817, name: mqt_js  >>> com.example <<<
    11-16 19:19:10.864 19878 19878 F DEBUG   : uid: 10363
    11-16 19:19:10.864 19878 19878 F DEBUG   : signal 6 (SIGABRT), code -1 (SI_QUEUE), fault addr --------
    11-16 19:19:10.864 19878 19878 F DEBUG   :     x0  0000000000000000  x1  0000000000004d69  x2  0000000000000006  x3  0000006e72b843d0
    11-16 19:19:10.864 19878 19878 F DEBUG   :     x4  fefeff00c29c9b0a  x5  fefeff00c29c9b0a  x6  fefeff00c29c9b0a  x7  7f7f7f7fffffff7f
    11-16 19:19:10.864 19878 19878 F DEBUG   :     x8  00000000000000f0  x9  2fc256f094da4f67  x10 0000000000000001  x11 0000000000000000
    11-16 19:19:10.864 19878 19878 F DEBUG   :     x12 fffffff0fffffbdf  x13 0000000000000000  x14 ffffffffffffffff  x15 f4946f4010e7c894
    11-16 19:19:10.864 19878 19878 F DEBUG   :     x16 00000078bd8208c0  x17 00000078bd7fc900  x18 0000000000000000  x19 0000000000004cc9
    11-16 19:19:10.864 19878 19878 F DEBUG   :     x20 0000000000004d69  x21 00000000ffffffff  x22 00000077bf5c36b0  x23 0000006e72b88020
    11-16 19:19:10.864 19878 19878 F DEBUG   :     x24 0000000000000000  x25 00000077a79c9460  x26 0000006e72b857a0  x27 0000000000000000
    11-16 19:19:10.864 19878 19878 F DEBUG   :     x28 0000006e72b88020  x29 0000006e72b84470
    11-16 19:19:10.864 19878 19878 F DEBUG   :     sp  0000006e72b843b0  lr  00000078bd7ae0c4  pc  00000078bd7ae0f0
    11-16 19:19:10.953 19878 19878 F DEBUG   : 
    11-16 19:19:10.953 19878 19878 F DEBUG   : backtrace:
    11-16 19:19:10.953 19878 19878 F DEBUG   :       #00 pc 00000000000830f0  /apex/com.android.runtime/lib64/bionic/libc.so (abort+160) (BuildId: a6a4a6a4e20240bbe3173fe560b161af)
    11-16 19:19:10.953 19878 19878 F DEBUG   :       #01 pc 000000000003b93c  /data/app/com.example-UW0sbJT3_R9Rd3Gd9LEiaw==/lib/arm64/libjscexecutor.so (_Unwind_SetGR+16) (BuildId: b78e918ab4c52dbf31404f74fe20101bc5214e4d)
    11-16 19:19:10.953 19878 19878 F DEBUG   :       #02 pc 00000000000b85c8  /data/app/com.example-UW0sbJT3_R9Rd3Gd9LEiaw==/lib/arm64/libfbjni.so (__gxx_personality_v0+364) (BuildId: 8edc347b17ae03442aeaf32376fe2c404c260276)
    11-16 19:19:10.953 19878 19878 F DEBUG   :       #03 pc 00000000001c95dc  /data/app/com.example-UW0sbJT3_R9Rd3Gd9LEiaw==/lib/arm64/libsequel.so (BuildId: a6c676a5cd19d086c0ed16d384d30ebb689d8330)
    11-16 19:19:10.954 19878 19878 F DEBUG   :       #04 pc 00000000001c9ae4  /data/app/com.example-UW0sbJT3_R9Rd3Gd9LEiaw==/lib/arm64/libsequel.so (BuildId: a6c676a5cd19d086c0ed16d384d30ebb689d8330)
    11-16 19:19:10.954 19878 19878 F DEBUG   :       #05 pc 0000000000087434  /data/app/com.example-UW0sbJT3_R9Rd3Gd9LEiaw==/lib/arm64/libsequel.so (BuildId: a6c676a5cd19d086c0ed16d384d30ebb689d8330)
    11-16 19:19:10.954 19878 19878 F DEBUG   :       #06 pc 0000000000087188  /data/app/com.example-UW0sbJT3_R9Rd3Gd9LEiaw==/lib/arm64/libsequel.so (BuildId: a6c676a5cd19d086c0ed16d384d30ebb689d8330)
    11-16 19:19:10.954 19878 19878 F DEBUG   :       #07 pc 000000000008706c  /data/app/com.example-UW0sbJT3_R9Rd3Gd9LEiaw==/lib/arm64/libsequel.so (BuildId: a6c676a5cd19d086c0ed16d384d30ebb689d8330)
    11-16 19:19:10.954 19878 19878 F DEBUG   :       #08 pc 0000000000086fa0  /data/app/com.example-UW0sbJT3_R9Rd3Gd9LEiaw==/lib/arm64/libsequel.so (BuildId: a6c676a5cd19d086c0ed16d384d30ebb689d8330)
    11-16 19:19:10.954 19878 19878 F DEBUG   :       #09 pc 000000000008504c  /data/app/com.example-UW0sbJT3_R9Rd3Gd9LEiaw==/lib/arm64/libsequel.so (BuildId: a6c676a5cd19d086c0ed16d384d30ebb689d8330)
    11-16 19:19:10.954 19878 19878 F DEBUG   :       #10 pc 000000000002d5b4  /data/app/com.example-UW0sbJT3_R9Rd3Gd9LEiaw==/lib/arm64/libjscexecutor.so (BuildId: b78e918ab4c52dbf31404f74fe20101bc5214e4d)
    11-16 19:19:10.954 19878 19878 F DEBUG   :       #11 pc 00000000000b9bd0  /data/app/com.example-UW0sbJT3_R9Rd3Gd9LEiaw==/lib/arm64/libjsc.so
    11-16 19:19:10.954 19878 19878 F DEBUG   :       #12 pc 000000000026fef4  /data/app/com.example-UW0sbJT3_R9Rd3Gd9LEiaw==/lib/arm64/libjsc.so
    11-16 19:19:10.954 19878 19878 F DEBUG   :       #13 pc 000000000026f814  /data/app/com.example-UW0sbJT3_R9Rd3Gd9LEiaw==/lib/arm64/libjsc.so
    11-16 19:19:10.954 19878 19878 F DEBUG   :       #14 pc 000000000018d4c0  <anonymous:779b6ff000>
    
    opened by sallar 9
  • Resultset metadata

    Resultset metadata

    • Feature to return resultset metadata on the low level API to help dynamic applications to analise column declared data types that can be "different" from storage datatypes, like datetime or booleans
    opened by EduFrazao 8
  • Sync transaction implementation

    Sync transaction implementation

    I created the dumbest and simplest lock since the base operations are sync, this is very easy. If an async version will come, then it won't be so easy.

    Closes #13

    enhancement 
    opened by ospfranco 6
  • Concurrent use with react-native-sqlite-storage?

    Concurrent use with react-native-sqlite-storage?

    Hi. Thank you very mutch this nice project! Today my project is dependent of react-native-sqlite-storage, and use some features like sqlBatch and transactions. Its fine for the majority of the workload, but I have some specific scenarios where I need to bulk insert many rows (sometimes more than 500k) and even using transactions or batch inserts, this takes a long time, sometimes more than a minute. Its mutch more that the classic Cordova SQLite Plugin takes with the same datasource (We have two versions of the same application. The cordova one will be replaced by the react-native version).

    I'm wondering if its possible to use this plugin to do such heavy operations, and continue to use react-native-sqlite-storage to continue use transactions, etc. Or its not recommend/possible to open the same database at the same time with two engines.

    opened by EduFrazao 6
  • Large operations are causing UI Freeze

    Large operations are causing UI Freeze

    Hi! I'm using quick sqlite version 2.0.1, and sometimes when I need to persist some large datasets here, my UI completely freezes. Using perf monitor, I can see that UI FPS keeps 60FPS, but JS shows "-2.1".

    I ran this commands inside a BEGIN TRANSATION and COMMIT statements, and some transactions inserts 100k records. This lib is so fast, that this rows takes only 8 seconds to be persisted.

    As far as I know, React Native keep a separate thread for JavaScript execution right? Do you have any tips in how to keep this heavy work running concurrently, without having so mutch impact on the UI thread? Do you think that this can be related to JSI behavior?

    opened by EduFrazao 5
  • Integer Overflow During Type Conversions

    Integer Overflow During Type Conversions

    I encountered an integer overflow for INTEGER(8) (8-byte ints) during type conversions. Here's a code sample showing the error:

    async function reproError() {
      try {
        const connection = await openDb('reproBug.sqlite', './');
        if (!connection) {
          throw new Error('Cannot get a connection to reproBug.sqlite');
        }
    
        const createSql = `CREATE TABLE IF NOT EXISTS "foo" (
          "created" integer(8) NOT NULL DEFAULT(1)
        );`;
        let res = await executeSql(connection, createSql, []);
        console.log(`createTable result: ${JSON.stringify(res, null, 2)}`);
    
        const insertSql = 'INSERT INTO foo (created) VALUES (1588399753901)';
        await executeSql(connection, insertSql, []);
    
        res = await executeSql(connection, 'SELECT * FROM foo', []);
        console.log(`Number of rows: ${res.rows.length}`);
        let item = res.rows.item(0);
    
        // Verify the value for created seems to have underflowed
        console.log(`Found item: ${JSON.stringify(item, null, 2)}`);
    
        res = await executeSql(
          connection,
          'SELECT *, CAST(created as TEXT) AS createdStr FROM foo ',
          [],
        );
        console.log(`Number of rows: ${res.rows.length}`);
        item = res.rows.item(0);
    
        // Verify the value is properly stored in sqlite by converting the value to a string and sending it over
        console.log(`Found item: ${JSON.stringify(item, null, 2)}`);
      } catch (error) {
        console.error(
          'Encountered an error when trying to repro the error. Details:',
          error,
        );
      }
    }
    

    For the functions executeSql and openDb: they are promise versions of the functions that exist in react-native-quick-sqlite:

    async function openDb(name: string, location: string) {
      return new Promise<DBConnection>((resolve, reject) => {
        openDatabase(
          {
            name,
            location,
          },
          resolve,
          reject,
        );
      });
    }
    
    async function executeSql(
      connection: DBConnection,
      sql: string,
      args: any[],
    ): Promise<OkResponse> {
      return new Promise((resolve, reject) => {
        connection.executeSql(sql, args, resolve, reject);
      });
    }
    

    The output of reproError is:

     LOG  createTable result: {
      "rows": {
        "status": 0,
        "length": 0,
        "_array": []
      },
      "rowsAffected": 0
    }
     LOG  Number of rows: 9
     LOG  Found item: {
      "created": -738145619
    }
     LOG  Number of rows: 9
     LOG  Found item: {
      "created": -738145619,
      "createdStr": "1588399753901"
    }
    

    So the value 1588399753901 can be inserted properly in sqlite in INTEGER(8) form, but when retrieving, there is integer overflow. Converting it to TEXT in sqlite before retrieval gets the proper value, but it would be nice to not have to have additional string conversions, just to re-parse as numbers on the JS side...

    Any ideas on how to fix this?

    opened by vinnybad 5
  • Doubt: Close connections on Destroy

    Doubt: Close connections on Destroy

    Hi. I have a doubt: QuickSQLite should automatically close opened connections when the application gets detroyed? As far as I know its not possible to react to this events from ReactNative JavaScript side, and its recommend to keep SQLite databases opened for the entire lifecicle of the application. In this case, should this library hook native application destroy events to close this connections?

    opened by EduFrazao 4
  • TypeORM swallows up errors

    TypeORM swallows up errors

    Behavior: Using react-native-quick-sqlite as the driver for TypeORM swallows up errors and return an empty array instead

    Expectation: TypeORM should throw. Like it does with the default react-native-sqlite-storage implementation

    Here's a quick repo that setups up the behavior https://github.com/amhed/quick_typeorm_bug/blob/master/App.tsx

    opened by amhed 1
  • Avoid global scope

    Avoid global scope

    The term sqlite is sufficiently common as to be inconvenient (for me) to be taken globally. It would be nice if I could import {sqlite as myOtherSqlite} from 'react-native-quick-sqlite';.

    Potentially register global object (that is what you need for JSI, yes?) as rnQuickSqlite, which no one else is likely to use, and export const sqlite = rnQuickSqlite; for named imports from this lib.

    opened by alpha0010 11
  • JS async transactions

    JS async transactions

    Transactions are now supported in the sync version, an async version still needs to be done. I'm guessing it will need to be promise-based, which doesn't quite fit with our callback async calls.

    Option a: dump the responsibility of promisifying the responsibilities to the user, and just rollback the transaction on reject. Option b: migrate or create yet another version of the async callbacks to return promises.

    enhancement 
    opened by ospfranco 0
Releases(3.1.0)
  • 3.1.0(May 3, 2022)

    Transactions were internally supported via batchExecuteSql method, but now there is a new transaction method. It's more idiomatic and useful if you need to check intermediate results. It's only meant for sync callbacks, an async version will be implemented next.

    Source code(tar.gz)
    Source code(zip)
  • 3.0.4(Apr 15, 2022)

    Column metadata is now returned when performing select queries. Should help when the data has been coerced to basic types but the SQL field is different.

    Source code(tar.gz)
    Source code(zip)
  • 3.0.2(Mar 17, 2022)

    After a lot of work, we have finally managed to add async callbacks to the library! 🎉

    Thanks a lot to @EduFrazao whose help has been vital to getting this working! Also, to @sergeymild, who's repo showed us how to do async callbacks with the JSI.

    Changes

    • Methods now have async equivalents, if you don't want to block your UI while SQLite processes your data
    • SQLite has been bumped to version 3.38.1

    Please open an issue if you are facing any sort of bug, this was a major refactoring of the library.

    Source code(tar.gz)
    Source code(zip)
  • 3.0.0(Mar 5, 2022)

    Added a couple of new methods:

    • batch execute SQL
    • load and execute a SQL file

    Also a big refactoring was done, the methods no longer throw errors at all, everything returns a response object with a status field

    Source code(tar.gz)
    Source code(zip)
  • 2.0.2(Feb 24, 2022)

  • 1.0.5(Oct 15, 2021)

  • 1.0.0(Aug 4, 2021)

Owner
Oscar Franco
Full-Stack Freelance Dev
Oscar Franco
The fastest database-library on Android OS.

Android SQLite3 NDK 封装 Demo下载 (操作:按钮新增 按钮查询 点按编辑 长按删除) 写在前面 sqlite3 开源、集成简单(现在的版本只有2个文件 sqlite3.h sqlite3.c) 这个库抽离自 Telegram 的开源代码、作者:DrKLO 我个人感觉 Tele

水银灯、 2 Dec 27, 2021
A lightweight header-only C++11 library for quick and easy SQL querying with QtSql classes.

EasyQtSql EasyQtSql is a lightweight header-only C++11 library for quick and easy SQL querying with QtSql classes. Features: Header only C++11 library

null 44 Jun 28, 2022
❤️ SQLite ORM light header only library for modern C++

SQLite ORM SQLite ORM light header only library for modern C++ Status Branch Travis Appveyor master dev Advantages No raw string queries Intuitive syn

Yevgeniy Zakharov 1.6k Jun 27, 2022
SQLean: all the missing SQLite functions

SQLite has very few functions compared to other DBMS. SQLite authors see this as a feature rather than a bug, because SQLite has extension mechanism in place.

Anton Zhiyanov 1.3k Jun 25, 2022
An SQLite binding for node.js with built-in encryption, focused on simplicity and (async) performance

Description An SQLite (more accurately SQLite3MultipleCiphers) binding for node.js focused on simplicity and (async) performance. When dealing with en

mscdex 14 May 15, 2022
Yet another SQLite wrapper for Nim

Yet another SQLite wrapper for Nim Features: Design for ARC/ORC, you don’t need to close the connection manually Use importdb macro to create helper f

Code Hz 7 May 10, 2022
A friendly and lightweight C++ database library for MySQL, PostgreSQL, SQLite and ODBC.

QTL QTL is a C ++ library for accessing SQL databases and currently supports MySQL, SQLite, PostgreSQL and ODBC. QTL is a lightweight library that con

null 155 Jun 26, 2022
Fork of sqlite4java with updated SQLite and very basic compiler hardening enabled.

Download latest version: sqlite4java-392 with SQLite 3.8.7, Windows/Linux/Mac OS X/Android binaries OSGi bundle 1.0.392 with sqlite4java-392 Files for

GrapheneOS 5 Jun 8, 2022
An updated fork of sqlite_protobuf, a SQLite extension for extracting values from serialized Protobuf messages.

This fork of sqlite_protobuf fixes some issues (e.g., #15) and removes the test suite that we do not use. It also comes with proto_table, a C library

Backtrace Labs 17 Jun 27, 2022
Serverless SQLite database read from and write to Object Storage Service, run on FaaS platform.

serverless-sqlite Serverless SQLite database read from and write to Object Storage Service, run on FaaS platform. NOTES: This repository is still in t

老雷 7 May 12, 2022
Verneuil is a VFS extension for SQLite that asynchronously replicates databases to S3-compatible blob stores.

Verneuil: streaming replication for sqlite Verneuil1 [vɛʁnœj] is a VFS (OS abstraction layer) for sqlite that accesses local database files like the d

Backtrace Labs 264 Jun 24, 2022
C++ ORM for SQLite

Hiberlite ORM C++ object-relational mapping with API inspired by the awesome Boost.Serialization - that means almost no API to learn. Usage Just compi

Paul Korzhyk 625 Jun 24, 2022
The C++14 wrapper around sqlite library

sqlite modern cpp wrapper This library is a lightweight modern wrapper around sqlite C api . #include<iostream> #include <sqlite_modern_cpp.h> using n

null 683 Jun 17, 2022
Unofficial git mirror of SQLite sources (see link for build instructions)

SQLite Source Repository This repository contains the complete source code for the SQLite database engine. Some test scripts are also included. Howeve

null 2k Jul 3, 2022
A hook for Project Zomboid that intercepts files access for savegames and puts them in an SQLite DB instead.

ZomboidDB This project consists of a library and patcher that results in file calls for your savegame(s) being transparently intercepted and redirecte

Oliver 6 May 6, 2022
Lightweight C++ wrapper for SQLite

NLDatabase Lightweight C++ wrapper for SQLite. Requirements C++11 compiler SQLite 3 Usage Let's open a database file and read some rows: #include "NLD

Raven 0 Sep 20, 2019
Writing a sqlite clone from scratch in C++

如何用C++实现一个简易数据库 基于cstack/db_tutorial C语言版本 KCNyu 2022/2/2 作为笔者写的第一个系列型教程,还是选择基于前人的教程经验以及添加一些自己个人的探索。也许有很多纰漏之处,希望大家指正。 1. 数据库是什么? 数据库是“按照数据结构来组织、存储和管理数

shengyu.li 31 Jun 24, 2022
YugabyteDB is a high-performance, cloud-native distributed SQL database that aims to support all PostgreSQL features

YugabyteDB is a high-performance, cloud-native distributed SQL database that aims to support all PostgreSQL features. It is best to fit for cloud-native OLTP (i.e. real-time, business-critical) applications that need absolute data correctness and require at least one of the following: scalability, high tolerance to failures, or globally-distributed deployments.

yugabyte 6.6k Jul 1, 2022
pgagroal is a high-performance protocol-native connection pool for PostgreSQL.

pgagroal is a high-performance protocol-native connection pool for PostgreSQL.

Agroal 524 Jun 15, 2022