- 
-
@@ -41,30 +40,22 @@ FnckSQL individual developers independently implemented LSM KV-based SQL DBMS ou
Welcome to our WebSite, Power By FnckSQL: **http://www.kipdata.site/**
### Quick Started
-Tips: Install rust toolchain first.
+Tips: Install rust toolchain and llvm first.
Clone the repository
``` shell
git clone https://github.com/KipData/FnckSQL.git
```
-
-then use `psql` to enter sql
-
+
Using FnckSQL in code
```rust
let fnck_sql = DataBaseBuilder::path("./data")
- .build()
- .await?;
-let tuples = fnck_sql.run("select * from t1").await?;
+ .build()?;
+let tuples = fnck_sql.run("select * from t1")?;
```
Storage Support:
-- KipDB
+- RocksDB
-### Docker
-#### Pull Image
-```shell
-docker pull kould23333/fncksql:latest
-```
#### Build From Source
~~~shell
git clone https://github.com/KipData/FnckSQL.git
@@ -72,21 +63,6 @@ cd FnckSQL
docker build -t kould23333/fncksql:latest .
~~~
-#### Run
-We installed the `psql` tool in the image for easy debug.
-
-You can use `psql -h 127.0.0.1 -p 5432` to do this.
-
-~~~shell
-docker run -d \
---name=fncksql \
--p 5432:5432 \
---restart=always \
--v fncksql-data:/fnck_sql/fncksql_data \
--v /etc/localtime:/etc/localtime:ro \
-kould23333/fncksql:latest
-~~~
-
### Features
- ORM Mapping: `features = ["marcos"]`
```rust
@@ -123,15 +99,13 @@ function!(TestFunction::test(LogicalType::Integer, LogicalType::Integer) -> Logi
let fnck_sql = DataBaseBuilder::path("./data")
.register_function(TestFunction::new())
- .build()
- .await?;
+ .build()?;
```
- Optimizer
- RBO
- CBO based on RBO(Physical Selection)
- Execute
- Volcano
- - Codegen on LuaJIT: `features = ["codegen_execute"]`
- MVCC Transaction
- Optimistic
- Field options
diff --git a/examples/hello_world.rs b/examples/hello_world.rs
index 15cf1018..ea72f426 100644
--- a/examples/hello_world.rs
+++ b/examples/hello_world.rs
@@ -28,17 +28,12 @@ implement_from_tuple!(
);
#[cfg(feature = "marcos")]
-#[tokio::main]
-async fn main() -> Result<(), DatabaseError> {
- let database = DataBaseBuilder::path("./hello_world").build().await?;
+fn main() -> Result<(), DatabaseError> {
+ let database = DataBaseBuilder::path("./hello_world").build()?;
- let _ = database
- .run("create table if not exists my_struct (c1 int primary key, c2 int)")
- .await?;
- let _ = database
- .run("insert into my_struct values(0, 0), (1, 1)")
- .await?;
- let (schema, tuples) = database.run("select * from my_struct").await?;
+ let _ = database.run("create table if not exists my_struct (c1 int primary key, c2 int)")?;
+ let _ = database.run("insert into my_struct values(0, 0), (1, 1)")?;
+ let (schema, tuples) = database.run("select * from my_struct")?;
let tuples = tuples
.into_iter()
.map(|tuple| MyStruct::from((&schema, tuple)))
@@ -46,7 +41,7 @@ async fn main() -> Result<(), DatabaseError> {
println!("{:#?}", tuples);
- let _ = database.run("drop table my_struct").await?;
+ let _ = database.run("drop table my_struct")?;
Ok(())
}
diff --git a/examples/transaction.rs b/examples/transaction.rs
index d1cf38ea..97d6df4a 100644
--- a/examples/transaction.rs
+++ b/examples/transaction.rs
@@ -1,23 +1,20 @@
use fnck_sql::db::DataBaseBuilder;
use fnck_sql::errors::DatabaseError;
-#[tokio::main]
-async fn main() -> Result<(), DatabaseError> {
- let database = DataBaseBuilder::path("./transaction").build().await?;
- let mut tx_1 = database.new_transaction().await?;
+fn main() -> Result<(), DatabaseError> {
+ let database = DataBaseBuilder::path("./transaction").build()?;
+ let mut tx_1 = database.new_transaction()?;
- let _ = tx_1
- .run("create table if not exists t1 (c1 int primary key, c2 int)")
- .await?;
- let _ = tx_1.run("insert into t1 values(0, 0), (1, 1)").await?;
+ let _ = tx_1.run("create table if not exists t1 (c1 int primary key, c2 int)")?;
+ let _ = tx_1.run("insert into t1 values(0, 0), (1, 1)")?;
- assert!(database.run("select * from t1").await.is_err());
+ assert!(database.run("select * from t1").is_err());
- tx_1.commit().await?;
+ tx_1.commit()?;
- assert!(database.run("select * from t1").await.is_ok());
+ assert!(database.run("select * from t1").is_ok());
- let _ = database.run("drop table t1").await?;
+ let _ = database.run("drop table t1")?;
Ok(())
}
diff --git a/src/bin/server.rs b/src/bin/server.rs
deleted file mode 100644
index 1e23dc89..00000000
--- a/src/bin/server.rs
+++ /dev/null
@@ -1,331 +0,0 @@
-use async_trait::async_trait;
-use clap::Parser;
-use fnck_sql::db::{DBTransaction, DataBaseBuilder, Database};
-use fnck_sql::errors::DatabaseError;
-use fnck_sql::storage::kipdb::KipStorage;
-use fnck_sql::types::tuple::{Schema, Tuple};
-use fnck_sql::types::LogicalType;
-use futures::stream;
-use log::{error, info, LevelFilter};
-use pgwire::api::auth::noop::NoopStartupHandler;
-use pgwire::api::auth::StartupHandler;
-use pgwire::api::query::{
- ExtendedQueryHandler, PlaceholderExtendedQueryHandler, SimpleQueryHandler,
-};
-use pgwire::api::results::{DataRowEncoder, FieldFormat, FieldInfo, QueryResponse, Response, Tag};
-use pgwire::api::MakeHandler;
-use pgwire::api::{ClientInfo, StatelessMakeHandler, Type};
-use pgwire::error::{ErrorInfo, PgWireError, PgWireResult};
-use pgwire::tokio::process_socket;
-use std::fmt::Debug;
-use std::io;
-use std::path::PathBuf;
-use std::sync::Arc;
-use tokio::net::TcpListener;
-use tokio::sync::Mutex;
-
-pub(crate) const BANNER: &str = "
-███████╗███╗ ██╗ ██████╗██╗ ██╗ ███████╗ ██████╗ ██╗
-██╔════╝████╗ ██║██╔════╝██║ ██╔╝ ██╔════╝██╔═══██╗██║
-█████╗ ██╔██╗ ██║██║ █████╔╝ ███████╗██║ ██║██║
-██╔══╝ ██║╚██╗██║██║ ██╔═██╗ ╚════██║██║▄▄ ██║██║
-██║ ██║ ╚████║╚██████╗██║ ██╗ ███████║╚██████╔╝███████╗
-╚═╝ ╚═╝ ╚═══╝ ╚═════╝╚═╝ ╚═╝ ╚══════╝ ╚══▀▀═╝ ╚══════╝
-
-";
-
-pub const BLOOM: &str = "
- _ ._ _ , _ ._
- (_ ' ( ` )_ .__)
- ( ( ( ) `) ) _)
-- --=(;;(----(-----)-----);;)==-- -
- (__ (_ (_ . _) _) ,__)
- `~~`\\ ' . /`~~`
- ; ;
- / \\
-_____________/_ __ \\_____________
-";
-
-#[derive(Parser, Debug)]
-#[command(author, version, about, long_about = None)]
-struct Args {
- #[clap(long, default_value = "127.0.0.1")]
- ip: String,
- #[clap(long, default_value = "5432")]
- port: u16,
- #[clap(long, default_value = "./fncksql_data")]
- path: String,
-}
-
-pub struct FnckSQLBackend {
- inner: Arc,
- placeholder: Arc
{
/// Run SQL queries.
- pub async fn run {
}
let stmt = &stmts[0];
let _guard = if matches!(command_type(stmt)?, CommandType::DDL) {
- MetaDataLock::Write(self.mdl.write_arc().await)
+ MetaDataLock::Write(self.mdl.write_arc())
} else {
- MetaDataLock::Read(self.mdl.read_arc().await)
+ MetaDataLock::Read(self.mdl.read_arc())
};
- let transaction = self.storage.transaction().await?;
+ let transaction = self.storage.transaction()?;
let plan = Self::build_plan(stmt, &transaction, &self.functions)?;
- Self::run_volcano(transaction, plan).await
+ Self::run_volcano(transaction, plan)
}
- pub(crate) async fn run_volcano(
- mut transaction: ::TransactionType,
+ pub(crate) fn run_volcano(
+ mut transaction: ::TransactionType<'_>,
mut plan: LogicalPlan,
) -> Result<(SchemaRef, Vec {
pub(crate) fn build_plan(
stmt: &Statement,
- transaction: &::TransactionType,
+ transaction: &::TransactionType<'_>,
functions: &Functions,
) -> Result {
}
}
-pub struct DBTransaction {
- pub async fn run {
let mut plan = Database::::build_plan(stmt, &self.inner, &self.functions)?;
let schema = plan.output_schema().clone();
- let mut stream = build_write(plan, &mut self.inner);
+ let executor = build_write(plan, &mut self.inner);
- Ok((schema, try_collect(&mut stream).await?))
+ Ok((schema, try_collect(executor)?))
}
- pub async fn commit(self) -> Result<(), DatabaseError> {
- self.inner.commit().await?;
+ pub fn commit(self) -> Result<(), DatabaseError> {
+ self.inner.commit()?;
Ok(())
}
@@ -276,7 +268,7 @@ mod test {
use std::sync::Arc;
use tempfile::TempDir;
- async fn build_table(mut transaction: impl Transaction) -> Result<(), DatabaseError> {
+ fn build_table(mut transaction: impl Transaction) -> Result<(), DatabaseError> {
let columns = vec![
ColumnCatalog::new(
"c1".to_string(),
@@ -290,19 +282,19 @@ mod test {
),
];
let _ = transaction.create_table(Arc::new("t1".to_string()), columns, false)?;
- transaction.commit().await?;
+ transaction.commit()?;
Ok(())
}
- #[tokio::test]
- async fn test_run_sql() -> Result<(), DatabaseError> {
+ #[test]
+ fn test_run_sql() -> Result<(), DatabaseError> {
let temp_dir = TempDir::new().expect("unable to create temporary working directory");
- let database = DataBaseBuilder::path(temp_dir.path()).build().await?;
- let transaction = database.storage.transaction().await?;
- build_table(transaction).await?;
+ let database = DataBaseBuilder::path(temp_dir.path()).build()?;
+ let transaction = database.storage.transaction()?;
+ build_table(transaction)?;
- let batch = database.run("select * from t1").await?;
+ let batch = database.run("select * from t1")?;
println!("{:#?}", batch);
Ok(())
@@ -316,45 +308,40 @@ mod test {
Ok(plus_unary_evaluator.unary_eval(&value))
}));
- #[tokio::test]
- async fn test_udf() -> Result<(), DatabaseError> {
+ #[test]
+ fn test_udf() -> Result<(), DatabaseError> {
let temp_dir = TempDir::new().expect("unable to create temporary working directory");
let fnck_sql = DataBaseBuilder::path(temp_dir.path())
.register_function(TestFunction::new())
- .build()
- .await?;
+ .build()?;
let _ = fnck_sql
- .run("CREATE TABLE test (id int primary key, c1 int, c2 int default test(1, 2));")
- .await?;
+ .run("CREATE TABLE test (id int primary key, c1 int, c2 int default test(1, 2));")?;
let _ = fnck_sql
- .run("INSERT INTO test VALUES (1, 2, 2), (0, 1, 1), (2, 1, 1), (3, 3, default);")
- .await?;
- let (schema, tuples) = fnck_sql.run("select test(c1, 1), c2 from test").await?;
+ .run("INSERT INTO test VALUES (1, 2, 2), (0, 1, 1), (2, 1, 1), (3, 3, default);")?;
+ let (schema, tuples) = fnck_sql.run("select test(c1, 1), c2 from test")?;
println!("{}", create_table(&schema, &tuples));
Ok(())
}
- #[tokio::test]
- async fn test_transaction_sql() -> Result<(), DatabaseError> {
+ #[test]
+ fn test_transaction_sql() -> Result<(), DatabaseError> {
let temp_dir = TempDir::new().expect("unable to create temporary working directory");
- let fnck_sql = DataBaseBuilder::path(temp_dir.path()).build().await?;
+ let fnck_sql = DataBaseBuilder::path(temp_dir.path()).build()?;
- let _ = fnck_sql
- .run("create table t1 (a int primary key, b int)")
- .await?;
+ let _ = fnck_sql.run("create table t1 (a int primary key, b int)")?;
- let mut tx_1 = fnck_sql.new_transaction().await?;
- let mut tx_2 = fnck_sql.new_transaction().await?;
+ let mut tx_1 = fnck_sql.new_transaction()?;
+ let mut tx_2 = fnck_sql.new_transaction()?;
- let _ = tx_1.run("insert into t1 values(0, 0)").await?;
- let _ = tx_1.run("insert into t1 values(1, 1)").await?;
+ let _ = tx_1.run("insert into t1 values(0, 0)")?;
+ let _ = tx_1.run("insert into t1 values(1, 1)")?;
- let _ = tx_2.run("insert into t1 values(0, 0)").await?;
- let _ = tx_2.run("insert into t1 values(3, 3)").await?;
+ let _ = tx_2.run("insert into t1 values(0, 0)")?;
+ let _ = tx_2.run("insert into t1 values(3, 3)")?;
- let (_, tuples_1) = tx_1.run("select * from t1").await?;
- let (_, tuples_2) = tx_2.run("select * from t1").await?;
+ let (_, tuples_1) = tx_1.run("select * from t1")?;
+ let (_, tuples_2) = tx_2.run("select * from t1")?;
assert_eq!(tuples_1.len(), 2);
assert_eq!(tuples_2.len(), 2);
@@ -389,12 +376,12 @@ mod test {
]
);
- tx_1.commit().await?;
+ tx_1.commit()?;
- assert!(tx_2.commit().await.is_err());
+ assert!(tx_2.commit().is_err());
- let mut tx_3 = fnck_sql.new_transaction().await?;
- let res = tx_3.run("create table t2 (a int primary key, b int)").await;
+ let mut tx_3 = fnck_sql.new_transaction()?;
+ let res = tx_3.run("create table t2 (a int primary key, b int)");
assert!(res.is_err());
Ok(())
diff --git a/src/errors.rs b/src/errors.rs
index 79acfcb0..b09346a4 100644
--- a/src/errors.rs
+++ b/src/errors.rs
@@ -1,7 +1,6 @@
use crate::expression::{BinaryOperator, UnaryOperator};
use crate::types::LogicalType;
use chrono::ParseError;
-use kip_db::KernelError;
use sqlparser::parser::ParserError;
use std::num::{ParseFloatError, ParseIntError, TryFromIntError};
use std::str::ParseBoolError;
@@ -17,6 +16,8 @@ pub enum DatabaseError {
#[from]
Box