fix merge

Author: siscia

Dockerfile

@@ -2,7 +2,7 @@ FROM redis:latest
 
 # RUN apk update; apk add libgcc_s.so.1
 
-COPY /target/release/libredis_sql.so /usr/local/lib
+COPY releases/0.9.1/redisql_v0.9.1_x86_64.so /usr/local/lib
 
 EXPOSE 6379
 

README.md

@@ -4,7 +4,7 @@ RediSQL is the Fast, in-memory, SQL engine with batteries included.
 
 It provides several benefits for your application.
 
-1. Fast, it can top up to 130k inserts per *seconds*.
+1. Fast, it can top up to 130k inserts per *second*.
 2. Familiar, it works with standard SQL, no weird dialect or syntax to learn.
 3. Easy to Operate, it is based on Redis, just start the standard Redis binary and and pass the RediSQL binary.
 4. Easy to Use, being based on Redis there are already bindings for any language.
@@ -16,55 +16,55 @@ There are several use cases for RediSQL.
 ### RediSQL to store Transient Data
 
 RediSQL is wonderful for transient data.
-With supports for lightweights DBs you can just store all the data that are important now, and trash them all together as soon as they are not necessary anymore.
+With supports for lightweights DBs, you can just store all the data that are important now, and trash them all together as soon as they are not necessary anymore.
 
 ### RediSQL as main database
 
-The product is stable, it does not loose data and you can store the data into regular files to gain in persistency.
-Moreover RediSQL support all the persistency features of Redis, hence RDB and AOF are both fully supported.
+The product is stable, it does not lose data.
+Moreover RediSQL supports all the persistency features of Redis, hence RDB and AOF are both fully supported.
 
 ## Much more to explore...
 
-There are a lot of features in RediSQL that is worth to explore more, here a short excerpt of those features.
+There are a lot of features in RediSQL that are worth exploring more. Here are short explanations of those features.
 
 #### Lightweight DBs
 
-RediSQL provides you with lightweight in memory databases.
-It could completely shift your architecture, indeed you could thing to create a new isolated database each day, or for every tenant of your application or even for each of your users.
+RediSQL provides you with lightweight in-memory databases.
+It could completely shift your architecture. For example, you could create a new isolated database each day, one for each application tenant, or even one per user.
 
 #### On disk storage
 
-While RediSQL focus on in-memory database, it can also store data in a regular file. Of course this makes operations slower, but it allow to reach a level of persistency and safeness of data on pair with regular databases as Postgres or MySQL.
+While RediSQL focuses on in-memory database, it can also store data in a regular file. Of course this makes operations slower, but it allows RediSQL to reach a level of data persistency on par with incumbent databases such as Postgres or MySQL.
 
 #### Copy of DBs
 
-With the concept of lightweight databases it become necessary to have a way to duplicate your database. 
+With the concept of lightweight databases, it becomes necessary to have a way to duplicate your database. 
 Indeed it is possible to copy a database into another one. 
-This allow several interesting patterns. 
-For example you could copy an in-memory database into a file-backed database and then ship the file for storage or other analysis. 
+This allows several interesting patterns. 
+For example, you could copy an in-memory database into a file-backed database and then ship the file for storage or other analysis. 
 Another pattern would be to copy a heavy read database into another for load balancing reasons.
 Moreover you may use the copy function to keep a "base-database" to grow when new data comes in.
 
 #### Directly expose the DB to users
 
-With the ability to create several lightweight databases and the capability to copy those database, you could directly expose directly the databases to the final users instead of exposing a set of API that you would need to maintain.
+With the ability to create several lightweight databases, and the capability to copy those database, you could directly expose the databases to the end users instead of exposing an API that you would need to maintain.
 Just load all the data that the user may need into a RediSQL database, document the tables that are available, and give access to it to the users. 
 They will write their own API without waiting on you.
 
 #### Stream and cache query results
 
-RediSQL allow to store the results of queries into a Redis Stream.
-This allow different clients to consume part of the result, or to delay the consuption of a result. 
-Moreover it allow to cache the result of expensive queries into Redis Streams and consume them over and over again.
+RediSQL can also store results of queries into a Redis Streams.
+This allows different clients to consume part of the result, or to delay the consuption of a result. 
+Moreover, it allows caching the result of expensive queries as Redis Streams to consume them over and over again.
 
 #### Complete JSON support
 
-JSON is the de-facto standard to share data between application, indeed RediSQL exploit the JSON1 module of SQLite to bring you the capability to easy and quickly manage JSON data inside SQL statements and tables.
-In RediSQL you are able to manipulate JSON in all the possible way.
+JSON is the de-facto standard for sharing data between applications. RediSQL exploits the JSON1 module of SQLite to bring that capability to easy and quickly manage JSON data inside SQL statements and tables.
+In RediSQL you are able to manipulate JSON in every standard way.
 
 #### Full text search support
 
-RediSQL fully supports also the FTS{3,4,5} engine in SQLite giving you a full text engine at your fingertip.
+RediSQL fully supports also the FTS{3,4,5} engine from SQLite, giving you a full text engine at your fingertip.
 You will be able to manage and search for data.
 
 ## Getting started
@@ -101,9 +101,9 @@ This will start a RediSQL instance and allow you to work directly with RediSQL.
 
 We create a few tutorial to guide you on using RediSQL with Node.js, Go(lang) and Python:
 
-- [Using RediSQL with Python](http://redbeardlab.tech/rediSQL/blog/python/using-redisql-with-python/)
-- [Using RediSQL with Golang](http://redbeardlab.tech/rediSQL/blog/golang/using-redisql-with-golang/)
-- [Using RediSQL with Node.js](http://redbeardlab.tech/rediSQL/blog/node/using-redisql-with-node/)
+- [Using RediSQL with Python](http://redisql.redbeardlab.com/rediSQL/blog/python/using-redisql-with-python/)
+- [Using RediSQL with Golang](http://redisql.redbeardlab.com/rediSQL/blog/golang/using-redisql-with-golang/)
+- [Using RediSQL with Node.js](http://redisql.redbeardlab.com/rediSQL/blog/node/using-redisql-with-node/)
 
 Please open an issue and request a tutorial for any other language you are intereted in.
 
@@ -170,5 +170,5 @@ This software is licensed under the AGPL-v3, it is possible to purchase more per
 <RediSQL, SQL steroids for Redis.>
 Copyright (C) 2019  Simone Mosciatti
 
-[api]: http://redbeardlab.tech/rediSQL/references/
+[api]: http://redisql.redbeardlab.com/rediSQL/references/
 [redis-download]: https://redis.io/download

redisql_lib/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "redisql_lib"
-version = "0.5.0"
+version = "0.5.1"
 authors = ["Simone Mosciatti <[email protected]>"]
 
 [build-dependencies]

redisql_lib/src/redis.rs

@@ -245,6 +245,12 @@ pub struct Loop {
     redis_context: ProtectedRedisContext,
 }
 
+impl Drop for Loop {
+    fn drop(&mut self) {
+        debug!("### Dropping Loop ###")
+    }
+}
+
 unsafe impl Send for Loop {}
 
 pub trait LoopData {
@@ -498,7 +504,6 @@ pub enum Command {
         client: BlockedClient,
     },
     MakeCopy {
-        source: DBKey,
         destination: DBKey,
         client: BlockedClient,
     },
@@ -560,26 +565,26 @@ pub fn do_query(
 
 /// implements the copy of the source database into the destination one
 /// it also leak the two DBKeys
-pub fn do_copy(
-    source: DBKey,
-    destination: DBKey,
+pub fn do_copy<L: LoopData>(
+    source_db: &Arc<Mutex<sql::RawConnection>>,
+    destination_loopdata: &L,
 ) -> Result<QueryResult, err::RediSQLError> {
-    let source_connection = source.loop_data.get_db();
-    let destination_connection = destination.loop_data.get_db();
+    debug!("DoCopy | Start");
 
     let backup_result = {
-        let source_db = source_connection.lock().unwrap();
-        let destination_db = destination_connection.lock().unwrap();
+        let destination_db = destination_loopdata.get_db();
+        let destination_db = destination_db.lock().unwrap();
+        let source_db = source_db.lock().unwrap();
         match make_backup(&source_db, &destination_db) {
             Err(e) => Err(RediSQLError::from(e)),
             Ok(_) => Ok(QueryResult::OK {}),
         }
     };
 
-    restore_previous_statements(&destination.loop_data);
-
-    std::mem::forget(source);
-    std::mem::forget(destination);
+    if backup_result.is_ok() {
+        restore_previous_statements(destination_loopdata);
+    }
+    debug!("DoCopy | End");
 
     backup_result
 }
@@ -973,20 +978,37 @@ pub fn listen_and_execute<'a, L: 'a + LoopData>(
                 );
             }
             Ok(Command::MakeCopy {
-                source,
                 destination,
                 client,
             }) => {
-                // The DBKeys MUST be leaked, they are leaked by do_copy
-                let result = do_copy(source, destination);
-                return_value(&client, result);
+                loopdata.with_contex_set(
+                    Context::thread_safe(&client),
+                    |_| {
+                        debug!("MakeCopy | Doing do_copy");
+                        let destination_loopdata =
+                            &destination.loop_data;
+                        let result = do_copy(
+                            &loopdata.get_db(),
+                            destination_loopdata,
+                        );
+                        match result {
+                            Ok(_) => STATISTICS.copy_ok(),
+                            Err(_) => STATISTICS.copy_err(),
+                        };
+                        return_value(&client, result);
+                    },
+                );
+                std::mem::forget(destination);
             }
             Ok(Command::Stop) => {
                 debug!("Stop, exiting from work loop");
                 return;
             }
             Err(RecvError) => {
-                debug!("RecvError, exiting from work loop");
+                debug!(
+                    "RecvError {}, exiting from work loop",
+                    RecvError
+                );
                 return;
             }
         }

src/commands.rs

@@ -894,81 +894,88 @@ pub extern "C" fn MakeCopy(
     STATISTICS.copy();
     let (context, argvector) = r::create_argument(ctx, argv, argc);
 
-    if argvector.len() != 3 {
-        let error = CString::new(
-            "Wrong number of arguments, it accepts exactly 3",
-        )
-        .unwrap();
-        STATISTICS.copy_err();
-        return unsafe {
-            r::rm::ffi::RedisModule_ReplyWithError.unwrap()(
-                context.as_ptr(),
-                error.as_ptr(),
-            )
-        };
-    }
-
-    let source_db =
-        get_dbkey_from_name(context.as_ptr(), argvector[1]);
-    if source_db.is_err() {
-        let error =
-            CString::new("Error in opening the SOURCE database")
-                .unwrap();
-        STATISTICS.copy_err();
-        return unsafe {
-            r::rm::ffi::RedisModule_ReplyWithError.unwrap()(
-                context.as_ptr(),
-                error.as_ptr(),
-            )
-        };
-    }
-    let source_db = source_db.unwrap();
+    match argvector.len() {
+        3 => with_ch_and_loopdata(
+            context.as_ptr(),
+            argvector[1],
+            |ch_loopdata| match ch_loopdata {
+                Err(key_type) => {
+                    STATISTICS.copy_err();
 
-    let dest_db = get_dbkey_from_name(context.as_ptr(), argvector[2]);
-    if dest_db.is_err() {
-        let error =
+                    reply_with_error_from_key_type(
+                        context.as_ptr(),
+                        key_type,
+                    )
+                }
+                Ok((ch, _loopdata)) => {
+                    let dest_db = get_dbkey_from_name(
+                        context.as_ptr(),
+                        argvector[2],
+                    );
+                    if dest_db.is_err() {
+                        let error =
             CString::new("Error in opening the DESTINATION database")
                 .unwrap();
-        STATISTICS.copy_err();
-        return unsafe {
-            r::rm::ffi::RedisModule_ReplyWithError.unwrap()(
-                context.as_ptr(),
-                error.as_ptr(),
-            )
-        };
-    }
-    let dest_db = dest_db.unwrap();
-
-    let blocked_client = r::rm::BlockedClient {
-        client: unsafe {
-            r::rm::ffi::RedisModule_BlockClient.unwrap()(
-                context.as_ptr(),
-                Some(reply_create_statement),
-                Some(timeout),
-                Some(free_privdata),
-                10000,
-            )
-        },
-    };
+                        STATISTICS.copy_err();
+                        return unsafe {
+                            r::rm::ffi::RedisModule_ReplyWithError
+                                .unwrap()(
+                                context.as_ptr(),
+                                error.as_ptr(),
+                            )
+                        };
+                    }
+                    let dest_db = dest_db.unwrap();
 
-    let ch = &source_db.tx.clone();
+                    let blocked_client = r::rm::BlockedClient {
+                        client: unsafe {
+                            r::rm::ffi::RedisModule_BlockClient
+                                .unwrap()(
+                                context.as_ptr(),
+                                Some(reply_create_statement),
+                                Some(timeout),
+                                Some(free_privdata),
+                                10000,
+                            )
+                        },
+                    };
 
-    let cmd = r::Command::MakeCopy {
-        source: source_db,
-        destination: dest_db,
-        client: blocked_client,
-    };
+                    let cmd = r::Command::MakeCopy {
+                        destination: dest_db,
+                        client: blocked_client,
+                    };
 
-    debug!("MakeCopy | End");
-    match ch.send(cmd) {
-        Ok(()) => {
-            debug!("MakeCopy | Successfully send command");
-            unsafe {
-                Replicate(&context, "REDISQL.COPY.NOW", argv, argc);
-            }
-            r::rm::ffi::REDISMODULE_OK
+                    match ch.send(cmd) {
+                        Ok(()) => {
+                            debug!("MakeCopy | Successfully send command");
+                            unsafe {
+                                Replicate(
+                                    &context,
+                                    "REDISQL.COPY.NOW",
+                                    argv,
+                                    argc,
+                                );
+                            }
+                            r::rm::ffi::REDISMODULE_OK
+                        }
+                        Err(_) => r::rm::ffi::REDISMODULE_OK,
+                    }
+                }
+            },
+        ),
+        _ => {
+            let error = CString::new(
+                "Wrong number of arguments, it accepts exactly 3",
+            )
+            .unwrap();
+            STATISTICS.copy_err();
+            return unsafe {
+                r::rm::ffi::RedisModule_ReplyWithError.unwrap()(
+                    context.as_ptr(),
+                    error.as_ptr(),
+                )
+            };
         }
-        Err(_) => r::rm::ffi::REDISMODULE_OK,
     }
 }