Skip to content
This repository was archived by the owner on Jul 11, 2021. It is now read-only.

Commit 10a3389

Browse files
author
Simone Mosciatti
committed
fix format, rustfmt changed
1 parent 3cb4fd3 commit 10a3389

12 files changed

Lines changed: 917 additions & 379 deletions

File tree

‎Cargo.lock‎

Lines changed: 10 additions & 0 deletions
Some generated files are not rendered by default. Learn more about customizing how changed files appear on GitHub.

‎Cargo.toml‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -13,9 +13,9 @@ uuid = { version = "0.4", features = ["v4"] }
1313
log = {version = "0.3.8", features = ["release_max_level_warn"]}
1414
env_logger = "0.4.3"
1515
redisql_lib = {path = "./redisql_lib"}
16-
# engine_pro = {path = "./engine_pro", optional = true}
16+
engine_pro = {path = "./engine_pro", optional = true}
1717

1818
[features]
1919
default = []
20-
# pro = ["engine_pro"]
20+
pro = ["engine_pro"]
2121
# trial = ["engine_pro/trial"]

‎redisql_lib/build.rs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -50,8 +50,8 @@ fn main() {
5050
}
5151
}
5252

53-
// let engine_pro = "-DENGINE_PRO=1";
54-
let engine_pro = "-DENGINE_PRO=0";
53+
let engine_pro = "-DENGINE_PRO=1";
54+
//let engine_pro = "-DENGINE_PRO=0";
5555

5656
let bindings = bindgen::Builder::default()
5757
.parse_callbacks(Box::new(SqliteTypeChooser))

‎redisql_lib/src/community_statement.rs‎

Lines changed: 110 additions & 39 deletions
Original file line numberDiff line numberDiff line change
@@ -28,11 +28,12 @@ unsafe impl Send for MultiStatement {}
2828
impl<'a> fmt::Display for MultiStatement {
2929
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3030
let mut buffer = String::new();
31-
buffer = self.stmts.iter().fold(buffer, |mut buffer, stmt| {
32-
buffer.push_str(&stmt.to_string());
33-
buffer.push_str("\n");
34-
buffer
35-
});
31+
buffer =
32+
self.stmts.iter().fold(buffer, |mut buffer, stmt| {
33+
buffer.push_str(&stmt.to_string());
34+
buffer.push_str("\n");
35+
buffer
36+
});
3637
write!(f, "{}", buffer)
3738
}
3839
}
@@ -74,17 +75,25 @@ pub fn generate_statements(
7475
let arc_db = db.clone();
7576
let conn = arc_db.lock().unwrap();
7677
loop {
77-
let mut stmt: *mut ffi::sqlite3_stmt = unsafe { mem::uninitialized() };
78+
let mut stmt: *mut ffi::sqlite3_stmt =
79+
unsafe { mem::uninitialized() };
7880

7981
let r = unsafe {
80-
ffi::sqlite3_prepare_v2(conn.get_db(), next_query, -1, &mut stmt, &mut next_query)
82+
ffi::sqlite3_prepare_v2(
83+
conn.get_db(),
84+
next_query,
85+
-1,
86+
&mut stmt,
87+
&mut next_query,
88+
)
8189
};
8290
match r {
8391
ffi::SQLITE_OK => {
8492
let stmt = Statement { stmt };
8593
stmts.push(stmt);
8694
if unsafe { *next_query } == 0 {
87-
let (num_parameters, parameters) = count_parameters(&stmts)?;
95+
let (num_parameters, parameters) =
96+
count_parameters(&stmts)?;
8897
return Ok(MultiStatement {
8998
stmts,
9099
db,
@@ -99,15 +108,21 @@ pub fn generate_statements(
99108
}
100109

101110
impl Statement {
102-
fn execute(&self, db: &RawConnection) -> Result<Cursor, SQLite3Error> {
111+
fn execute(
112+
&self,
113+
db: &RawConnection,
114+
) -> Result<Cursor, SQLite3Error> {
103115
match unsafe { ffi::sqlite3_step(self.stmt) } {
104116
ffi::SQLITE_OK => Ok(Cursor::OKCursor {}),
105117
ffi::SQLITE_DONE => {
106-
let modified_rows = unsafe { ffi::sqlite3_changes(db.get_db()) };
118+
let modified_rows =
119+
unsafe { ffi::sqlite3_changes(db.get_db()) };
107120
Ok(Cursor::DONECursor { modified_rows })
108121
}
109122
ffi::SQLITE_ROW => {
110-
let num_columns = unsafe { ffi::sqlite3_column_count(self.stmt) } as i32;
123+
let num_columns = unsafe {
124+
ffi::sqlite3_column_count(self.stmt)
125+
} as i32;
111126
Ok(Cursor::RowsCursor {
112127
stmt: self,
113128
num_columns,
@@ -130,10 +145,14 @@ impl<'a> StatementTrait<'a> for Statement {
130145
Err(self.get_last_error())
131146
}
132147

133-
fn new(conn: Arc<Mutex<RawConnection>>, query: &str) -> Result<Statement, SQLite3Error> {
148+
fn new(
149+
conn: Arc<Mutex<RawConnection>>,
150+
query: &str,
151+
) -> Result<Statement, SQLite3Error> {
134152
let raw_query = CString::new(query).unwrap();
135153

136-
let mut stmt: *mut ffi::sqlite3_stmt = unsafe { mem::uninitialized() };
154+
let mut stmt: *mut ffi::sqlite3_stmt =
155+
unsafe { mem::uninitialized() };
137156

138157
let conn = conn.lock().unwrap();
139158
let r = unsafe {
@@ -158,7 +177,10 @@ impl<'a> StatementTrait<'a> for Statement {
158177
}
159178
}
160179

161-
fn bind_texts(&self, values: &[&str]) -> Result<SQLiteOK, SQLite3Error> {
180+
fn bind_texts(
181+
&self,
182+
values: &[&str],
183+
) -> Result<SQLiteOK, SQLite3Error> {
162184
let mut index = 0;
163185
values
164186
.iter()
@@ -169,7 +191,11 @@ impl<'a> StatementTrait<'a> for Statement {
169191
.collect()
170192
}
171193

172-
fn bind_index(&self, index: i32, value: &str) -> Result<SQLiteOK, SQLite3Error> {
194+
fn bind_index(
195+
&self,
196+
index: i32,
197+
value: &str,
198+
) -> Result<SQLiteOK, SQLite3Error> {
173199
#[allow(non_snake_case)]
174200
fn SQLITE_TRANSIENT() -> ffi::sqlite3_destructor_type {
175201
Some(unsafe { mem::transmute(-1isize) })
@@ -206,16 +232,24 @@ impl<'a> StatementTrait<'a> for MultiStatement {
206232
let db = self.db.clone();
207233
let conn = db.lock().unwrap();
208234
debug!("Execute | Acquired db lock");
209-
let rows_modified_before_executing = unsafe { ffi::sqlite3_total_changes(conn.get_db()) };
235+
let rows_modified_before_executing =
236+
unsafe { ffi::sqlite3_total_changes(conn.get_db()) };
210237
debug!("Execute | Read row modified before");
211-
match self.stmts.iter().map(|stmt| stmt.execute(&conn)).collect() {
238+
match self
239+
.stmts
240+
.iter()
241+
.map(|stmt| stmt.execute(&conn))
242+
.collect()
243+
{
212244
Err(e) => Err(e),
213245
Ok(mut v) => {
214246
debug!("Execute=> Executed trains of statements");
215-
let rows_modified_after_executing =
216-
unsafe { ffi::sqlite3_total_changes(conn.get_db()) };
247+
let rows_modified_after_executing = unsafe {
248+
ffi::sqlite3_total_changes(conn.get_db())
249+
};
217250
let total_modified_rows =
218-
rows_modified_after_executing - rows_modified_before_executing;
251+
rows_modified_after_executing
252+
- rows_modified_before_executing;
219253
match v {
220254
Cursor::DONECursor {
221255
ref mut modified_rows,
@@ -236,13 +270,20 @@ impl<'a> StatementTrait<'a> for MultiStatement {
236270
}
237271
}
238272
}
239-
fn bind_index(&self, index: i32, value: &str) -> Result<SQLiteOK, SQLite3Error> {
273+
fn bind_index(
274+
&self,
275+
index: i32,
276+
value: &str,
277+
) -> Result<SQLiteOK, SQLite3Error> {
240278
for stmt in &self.stmts {
241279
stmt.bind_index(index, value)?;
242280
}
243281
Ok(SQLiteOK::OK)
244282
}
245-
fn bind_texts(&self, values: &[&str]) -> Result<SQLiteOK, SQLite3Error> {
283+
fn bind_texts(
284+
&self,
285+
values: &[&str],
286+
) -> Result<SQLiteOK, SQLite3Error> {
246287
if values.len() != self.number_parameters as usize {
247288
return Err(SQLite3Error {
248289
code: 2021,
@@ -266,7 +307,10 @@ impl<'a> StatementTrait<'a> for MultiStatement {
266307
}
267308
Ok(SQLiteOK::OK)
268309
}
269-
fn new(conn: Arc<Mutex<RawConnection>>, query: &str) -> Result<MultiStatement, SQLite3Error> {
310+
fn new(
311+
conn: Arc<Mutex<RawConnection>>,
312+
query: &str,
313+
) -> Result<MultiStatement, SQLite3Error> {
270314
generate_statements(conn, query)
271315
}
272316
fn get_raw_stmt(&self) -> *mut ffi::sqlite3_stmt {
@@ -284,7 +328,9 @@ impl<'a> StatementTrait<'a> for MultiStatement {
284328
}
285329
}
286330

287-
fn count_parameters(statements: &[Statement]) -> Result<(i32, Vec<Vec<Parameters>>), SQLite3Error> {
331+
fn count_parameters(
332+
statements: &[Statement],
333+
) -> Result<(i32, Vec<Vec<Parameters>>), SQLite3Error> {
288334
let error_wrong_paramenter = SQLite3Error {
289335
code: 1021,
290336
error_message: String::from(
@@ -305,15 +351,21 @@ fn count_parameters(statements: &[Statement]) -> Result<(i32, Vec<Vec<Parameters
305351
let mut discriminant: Vec<_> = parameters
306352
.clone()
307353
.iter()
308-
.flat_map(|params| params.iter().map(|p| mem::discriminant(p)))
354+
.flat_map(|params| {
355+
params.iter().map(|p| mem::discriminant(p))
356+
})
309357
.collect();
310358
discriminant.dedup();
311359
if discriminant.len() > 1 {
312360
return Err(error_wrong_paramenter);
313361
}
314362
match discriminant.first() {
315363
None => return Ok((0, vec![])),
316-
Some(d) if *d == mem::discriminant(&Parameters::Anonymous) => {
364+
Some(d)
365+
if *d == mem::discriminant(
366+
&Parameters::Anonymous,
367+
) =>
368+
{
317369
return Err(error_wrong_paramenter);
318370
}
319371
Some(_) => {}
@@ -335,18 +387,30 @@ fn count_parameters(statements: &[Statement]) -> Result<(i32, Vec<Vec<Parameters
335387
}
336388
}
337389
}
338-
fn get_parameter_name(stmt: &Statement, index: i32) -> Result<Option<Parameters>, SQLite3Error> {
339-
let parameter_name_ptr = unsafe { ffi::sqlite3_bind_parameter_name(stmt.stmt, index) };
340-
let index_parameter =
341-
unsafe { ffi::sqlite3_bind_parameter_index(stmt.stmt, parameter_name_ptr) };
390+
fn get_parameter_name(
391+
stmt: &Statement,
392+
index: i32,
393+
) -> Result<Option<Parameters>, SQLite3Error> {
394+
let parameter_name_ptr =
395+
unsafe { ffi::sqlite3_bind_parameter_name(stmt.stmt, index) };
396+
let index_parameter = unsafe {
397+
ffi::sqlite3_bind_parameter_index(
398+
stmt.stmt,
399+
parameter_name_ptr,
400+
)
401+
};
342402
match index_parameter {
343403
0 => Ok(None),
344404
n => Ok(Some(Parameters::Named { index: n })),
345405
}
346406
}
347407

348-
fn get_parameters(stmt: &Statement) -> Result<Vec<Parameters>, SQLite3Error> {
349-
let total_paramenters = unsafe { ffi::sqlite3_bind_parameter_count(stmt.stmt) } as usize;
408+
fn get_parameters(
409+
stmt: &Statement,
410+
) -> Result<Vec<Parameters>, SQLite3Error> {
411+
let total_paramenters = unsafe {
412+
ffi::sqlite3_bind_parameter_count(stmt.stmt)
413+
} as usize;
350414
if total_paramenters == 0 {
351415
return Ok(vec![]);
352416
}
@@ -369,7 +433,8 @@ mod test {
369433

370434
#[test]
371435
fn test_multiple_statements() {
372-
let db = sql::open_connection(String::from(":memory:")).unwrap();
436+
let db =
437+
sql::open_connection(String::from(":memory:")).unwrap();
373438
let statements = String::from("BEGIN; SELECT 'a'; COMMIT;");
374439
let stmts = generate_statements(&db, statements).unwrap();
375440
assert!(stmts.stmts.len() == 3);
@@ -383,14 +448,17 @@ mod test {
383448

384449
#[test]
385450
fn count_inside_nested_vector() {
386-
let nested_vector = vec![vec![1, 2, 3], vec![4, 5, 6, 6], vec![1, 1, 0]];
387-
let ten: i32 = nested_vector.iter().map(|v| v.len() as i32).sum();
451+
let nested_vector =
452+
vec![vec![1, 2, 3], vec![4, 5, 6, 6], vec![1, 1, 0]];
453+
let ten: i32 =
454+
nested_vector.iter().map(|v| v.len() as i32).sum();
388455
assert!(ten == 10);
389456
}
390457

391458
#[test]
392459
fn test_parameters_standard() {
393-
let db = sql::open_connection(String::from(":memory:")).unwrap();
460+
let db =
461+
sql::open_connection(String::from(":memory:")).unwrap();
394462
let stmts = String::from(
395463
"BEGIN; SELECT CASE WHEN ?1 > ?2 \
396464
THEN ?3 END;",
@@ -401,7 +469,8 @@ mod test {
401469

402470
#[test]
403471
fn test_gap_parameters() {
404-
let db = sql::open_connection(String::from(":memory:")).unwrap();
472+
let db =
473+
sql::open_connection(String::from(":memory:")).unwrap();
405474
let stmts = String::from(
406475
"SELECT CASE WHEN ?1 > ?3 \
407476
THEN ?10 END;",
@@ -413,7 +482,8 @@ mod test {
413482

414483
#[test]
415484
fn test_gap_but_valid() {
416-
let db = sql::open_connection(String::from(":memory:")).unwrap();
485+
let db =
486+
sql::open_connection(String::from(":memory:")).unwrap();
417487
let stmts = String::from(
418488
"BEGIN; \
419489
SELECT CASE WHEN ?1 > ?2 THEN ?3 END; \
@@ -426,7 +496,8 @@ mod test {
426496

427497
#[test]
428498
fn test_nameless_parameters_do_not_count() {
429-
let db = sql::open_connection(String::from(":memory:")).unwrap();
499+
let db =
500+
sql::open_connection(String::from(":memory:")).unwrap();
430501
let stmts = String::from(
431502
"BEGIN; \
432503
SELECT CASE WHEN ? > ? THEN ? END; \

0 commit comments

Comments
 (0)