noth/surrealpatch
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Change data returned by the INFO statement ()

Browse source 
Co-authored-by: Marta <marta@Salvadors-Laptop.local>
This commit is contained in:
Marta Sanchez 2023-05-31 14:35:29 +02:00 committed by GitHub
parent a9bf907432
commit 496d16242f
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
6 changed files with 168 additions and 168 deletions

32
lib/src/sql/statements/info.rs
View file

@ -50,7 +50,7 @@ impl InfoStatement {
for v in run.all_ns().await?.iter() {
tmp.insert(v.name.to_string(), v.to_string().into());
}
res.insert("ns".to_owned(), tmp.into());
res.insert("namespaces".to_owned(), tmp.into());
// Ok all good
Value::from(res).ok()
}
@ -70,19 +70,19 @@ impl InfoStatement {
for v in run.all_db(opt.ns()).await?.iter() {
tmp.insert(v.name.to_string(), v.to_string().into());
}
res.insert("db".to_owned(), tmp.into());
res.insert("databases".to_owned(), tmp.into());
// Process the logins
let mut tmp = Object::default();
for v in run.all_nl(opt.ns()).await?.iter() {
tmp.insert(v.name.to_string(), v.to_string().into());
}
res.insert("nl".to_owned(), tmp.into());
res.insert("logins".to_owned(), tmp.into());
// Process the tokens
let mut tmp = Object::default();
for v in run.all_nt(opt.ns()).await?.iter() {
tmp.insert(v.name.to_string(), v.to_string().into());
}
res.insert("nt".to_owned(), tmp.into());
res.insert("tokens".to_owned(), tmp.into());
// Ok all good
Value::from(res).ok()
}
@ -102,43 +102,43 @@ impl InfoStatement {
for v in run.all_dl(opt.ns(), opt.db()).await?.iter() {
tmp.insert(v.name.to_string(), v.to_string().into());
}
res.insert("dl".to_owned(), tmp.into());
res.insert("logins".to_owned(), tmp.into());
// Process the tokens
let mut tmp = Object::default();
for v in run.all_dt(opt.ns(), opt.db()).await?.iter() {
tmp.insert(v.name.to_string(), v.to_string().into());
}
res.insert("dt".to_owned(), tmp.into());
res.insert("tokens".to_owned(), tmp.into());
// Process the functions
let mut tmp = Object::default();
for v in run.all_fc(opt.ns(), opt.db()).await?.iter() {
tmp.insert(v.name.to_string(), v.to_string().into());
}
res.insert("fc".to_owned(), tmp.into());
res.insert("functions".to_owned(), tmp.into());
// Process the params
let mut tmp = Object::default();
for v in run.all_pa(opt.ns(), opt.db()).await?.iter() {
tmp.insert(v.name.to_string(), v.to_string().into());
}
res.insert("pa".to_owned(), tmp.into());
res.insert("params".to_owned(), tmp.into());
// Process the scopes
let mut tmp = Object::default();
for v in run.all_sc(opt.ns(), opt.db()).await?.iter() {
tmp.insert(v.name.to_string(), v.to_string().into());
}
res.insert("sc".to_owned(), tmp.into());
res.insert("scopes".to_owned(), tmp.into());
// Process the tables
let mut tmp = Object::default();
for v in run.all_tb(opt.ns(), opt.db()).await?.iter() {
tmp.insert(v.name.to_string(), v.to_string().into());
}
res.insert("tb".to_owned(), tmp.into());
res.insert("tables".to_owned(), tmp.into());
// Process the analyzers
let mut tmp = Object::default();
for v in run.all_az(opt.ns(), opt.db()).await?.iter() {
tmp.insert(v.name.to_string(), v.to_string().into());
}
res.insert("az".to_owned(), tmp.into());
res.insert("analyzers".to_owned(), tmp.into());
// Ok all good
Value::from(res).ok()
}
@ -158,7 +158,7 @@ impl InfoStatement {
for v in run.all_st(opt.ns(), opt.db(), sc).await?.iter() {
tmp.insert(v.name.to_string(), v.to_string().into());
}
res.insert("st".to_owned(), tmp.into());
res.insert("tokens".to_owned(), tmp.into());
// Ok all good
Value::from(res).ok()
}
@ -178,25 +178,25 @@ impl InfoStatement {
for v in run.all_ev(opt.ns(), opt.db(), tb).await?.iter() {
tmp.insert(v.name.to_string(), v.to_string().into());
}
res.insert("ev".to_owned(), tmp.into());
res.insert("events".to_owned(), tmp.into());
// Process the fields
let mut tmp = Object::default();
for v in run.all_fd(opt.ns(), opt.db(), tb).await?.iter() {
tmp.insert(v.name.to_string(), v.to_string().into());
}
res.insert("fd".to_owned(), tmp.into());
res.insert("fields".to_owned(), tmp.into());
// Process the tables
let mut tmp = Object::default();
for v in run.all_ft(opt.ns(), opt.db(), tb).await?.iter() {
tmp.insert(v.name.to_string(), v.to_string().into());
}
res.insert("ft".to_owned(), tmp.into());
res.insert("tables".to_owned(), tmp.into());
// Process the indexes
let mut tmp = Object::default();
for v in run.all_ix(opt.ns(), opt.db(), tb).await?.iter() {
tmp.insert(v.name.to_string(), v.to_string().into());
}
res.insert("ix".to_owned(), tmp.into());
res.insert("indexes".to_owned(), tmp.into());
// Ok all good
Value::from(res).ok()
}

224
lib/tests/define.rs
View file

@ -22,7 +22,7 @@ async fn define_statement_namespace() -> Result<(), Error> {
let tmp = res.remove(0).result?;
let val = Value::parse(
"{
ns: { test: 'DEFINE NAMESPACE test' },
namespaces: { test: 'DEFINE NAMESPACE test' },
}",
);
assert_eq!(tmp, val);
@ -47,9 +47,9 @@ async fn define_statement_database() -> Result<(), Error> {
let tmp = res.remove(0).result?;
let val = Value::parse(
"{
db: { test: 'DEFINE DATABASE test' },
nl: {},
nt: {},
databases: { test: 'DEFINE DATABASE test' },
logins: {},
tokens: {},
}",
);
assert_eq!(tmp, val);
@ -76,15 +76,15 @@ async fn define_statement_function() -> Result<(), Error> {
let tmp = res.remove(0).result?;
let val = Value::parse(
"{
az: {},
dl: {},
dt: {},
fc: { test: 'DEFINE FUNCTION fn::test($first: string, $last: string) { RETURN $first + $last; }' },
pa: {},
sc: {},
pa: {},
sc: {},
tb: {},
analyzers: {},
logins: {},
tokens: {},
functions: { test: 'DEFINE FUNCTION fn::test($first: string, $last: string) { RETURN $first + $last; }' },
params: {},
scopes: {},
params: {},
scopes: {},
tables: {},
}",
);
assert_eq!(tmp, val);
@ -109,13 +109,13 @@ async fn define_statement_table_drop() -> Result<(), Error> {
let tmp = res.remove(0).result?;
let val = Value::parse(
"{
az: {},
dl: {},
dt: {},
fc: {},
pa: {},
sc: {},
tb: { test: 'DEFINE TABLE test DROP SCHEMALESS' },
analyzers: {},
logins: {},
tokens: {},
functions: {},
params: {},
scopes: {},
tables: { test: 'DEFINE TABLE test DROP SCHEMALESS' },
}",
);
assert_eq!(tmp, val);
@ -140,13 +140,13 @@ async fn define_statement_table_schemaless() -> Result<(), Error> {
let tmp = res.remove(0).result?;
let val = Value::parse(
"{
az: {},
dl: {},
dt: {},
fc: {},
pa: {},
sc: {},
tb: { test: 'DEFINE TABLE test SCHEMALESS' },
analyzers: {},
logins: {},
tokens: {},
functions: {},
params: {},
scopes: {},
tables: { test: 'DEFINE TABLE test SCHEMALESS' },
}",
);
assert_eq!(tmp, val);
@ -175,13 +175,13 @@ async fn define_statement_table_schemafull() -> Result<(), Error> {
let tmp = res.remove(0).result?;
let val = Value::parse(
"{
az: {},
dl: {},
dt: {},
fc: {},
pa: {},
sc: {},
tb: { test: 'DEFINE TABLE test SCHEMAFULL' },
analyzers: {},
logins: {},
tokens: {},
functions: {},
params: {},
scopes: {},
tables: { test: 'DEFINE TABLE test SCHEMAFULL' },
}",
);
assert_eq!(tmp, val);
@ -206,13 +206,13 @@ async fn define_statement_table_schemaful() -> Result<(), Error> {
let tmp = res.remove(0).result?;
let val = Value::parse(
"{
az: {},
dl: {},
dt: {},
fc: {},
pa: {},
sc: {},
tb: { test: 'DEFINE TABLE test SCHEMAFULL' },
analyzers: {},
logins: {},
tokens: {},
functions: {},
params: {},
scopes: {},
tables: { test: 'DEFINE TABLE test SCHEMAFULL' },
}",
);
assert_eq!(tmp, val);
@ -249,10 +249,10 @@ async fn define_statement_event() -> Result<(), Error> {
let tmp = res.remove(0).result?;
let val = Value::parse(
"{
ev: { test: 'DEFINE EVENT test ON user WHEN true THEN (CREATE activity SET user = $this, value = $after.email, action = $event)' },
fd: {},
ft: {},
ix: {},
events: { test: 'DEFINE EVENT test ON user WHEN true THEN (CREATE activity SET user = $this, value = $after.email, action = $event)' },
fields: {},
tables: {},
indexes: {},
}",
);
assert_eq!(tmp, val);
@ -306,10 +306,10 @@ async fn define_statement_event_when_event() -> Result<(), Error> {
let tmp = res.remove(0).result?;
let val = Value::parse(
r#"{
ev: { test: "DEFINE EVENT test ON user WHEN $event = 'CREATE' THEN (CREATE activity SET user = $this, value = $after.email, action = $event)" },
fd: {},
ft: {},
ix: {},
events: { test: "DEFINE EVENT test ON user WHEN $event = 'CREATE' THEN (CREATE activity SET user = $this, value = $after.email, action = $event)" },
fields: {},
tables: {},
indexes: {},
}"#,
);
assert_eq!(tmp, val);
@ -363,10 +363,10 @@ async fn define_statement_event_when_logic() -> Result<(), Error> {
let tmp = res.remove(0).result?;
let val = Value::parse(
"{
ev: { test: 'DEFINE EVENT test ON user WHEN $before.email != $after.email THEN (CREATE activity SET user = $this, value = $after.email, action = $event)' },
fd: {},
ft: {},
ix: {},
events: { test: 'DEFINE EVENT test ON user WHEN $before.email != $after.email THEN (CREATE activity SET user = $this, value = $after.email, action = $event)' },
fields: {},
tables: {},
indexes: {},
}",
);
assert_eq!(tmp, val);
@ -412,10 +412,10 @@ async fn define_statement_field() -> Result<(), Error> {
let tmp = res.remove(0).result?;
let val = Value::parse(
"{
ev: {},
fd: { test: 'DEFINE FIELD test ON user' },
ft: {},
ix: {},
events: {},
fields: { test: 'DEFINE FIELD test ON user' },
tables: {},
indexes: {},
}",
);
assert_eq!(tmp, val);
@ -444,10 +444,10 @@ async fn define_statement_field_type() -> Result<(), Error> {
let tmp = res.remove(0).result?;
let val = Value::parse(
"{
ev: {},
fd: { test: 'DEFINE FIELD test ON user TYPE string' },
ft: {},
ix: {},
events: {},
fields: { test: 'DEFINE FIELD test ON user TYPE string' },
tables: {},
indexes: {},
}",
);
assert_eq!(tmp, val);
@ -476,10 +476,10 @@ async fn define_statement_field_value() -> Result<(), Error> {
let tmp = res.remove(0).result?;
let val = Value::parse(
r#"{
ev: {},
fd: { test: "DEFINE FIELD test ON user VALUE $value OR 'GBR'" },
ft: {},
ix: {},
events: {},
fields: { test: "DEFINE FIELD test ON user VALUE $value OR 'GBR'" },
tables: {},
indexes: {},
}"#,
);
assert_eq!(tmp, val);
@ -508,10 +508,10 @@ async fn define_statement_field_assert() -> Result<(), Error> {
let tmp = res.remove(0).result?;
let val = Value::parse(
"{
ev: {},
fd: { test: 'DEFINE FIELD test ON user ASSERT $value != NONE AND $value = /[A-Z]{3}/' },
ft: {},
ix: {},
events: {},
fields: { test: 'DEFINE FIELD test ON user ASSERT $value != NONE AND $value = /[A-Z]{3}/' },
tables: {},
indexes: {},
}",
);
assert_eq!(tmp, val);
@ -540,10 +540,10 @@ async fn define_statement_field_type_value_assert() -> Result<(), Error> {
let tmp = res.remove(0).result?;
let val = Value::parse(
r#"{
ev: {},
fd: { test: "DEFINE FIELD test ON user TYPE string VALUE $value OR 'GBR' ASSERT $value != NONE AND $value = /[A-Z]{3}/" },
ft: {},
ix: {},
events: {},
fields: { test: "DEFINE FIELD test ON user TYPE string VALUE $value OR 'GBR' ASSERT $value != NONE AND $value = /[A-Z]{3}/" },
tables: {},
indexes: {},
}"#,
);
assert_eq!(tmp, val);
@ -582,10 +582,10 @@ async fn define_statement_index_single_simple() -> Result<(), Error> {
let tmp = res.remove(0).result?;
let val = Value::parse(
"{
ev: {},
fd: {},
ft: {},
ix: { test: 'DEFINE INDEX test ON user FIELDS age' },
events: {},
fields: {},
tables: {},
indexes: { test: 'DEFINE INDEX test ON user FIELDS age' },
}",
);
assert_eq!(tmp, val);
@ -624,10 +624,10 @@ async fn define_statement_index_single() -> Result<(), Error> {
let tmp = res.remove(0).result?;
let val = Value::parse(
"{
ev: {},
fd: {},
ft: {},
ix: { test: 'DEFINE INDEX test ON user FIELDS email' },
events: {},
fields: {},
tables: {},
indexes: { test: 'DEFINE INDEX test ON user FIELDS email' },
}",
);
assert_eq!(tmp, val);
@ -668,10 +668,10 @@ async fn define_statement_index_multiple() -> Result<(), Error> {
let tmp = res.remove(0).result?;
let val = Value::parse(
"{
ev: {},
fd: {},
ft: {},
ix: { test: 'DEFINE INDEX test ON user FIELDS account, email' },
events: {},
fields: {},
tables: {},
indexes: { test: 'DEFINE INDEX test ON user FIELDS account, email' },
}",
);
assert_eq!(tmp, val);
@ -720,10 +720,10 @@ async fn define_statement_index_single_unique() -> Result<(), Error> {
let tmp = res.remove(0).result?;
let val = Value::parse(
"{
ev: {},
fd: {},
ft: {},
ix: { test: 'DEFINE INDEX test ON user FIELDS email UNIQUE' },
events: {},
fields: {},
tables: {},
indexes: { test: 'DEFINE INDEX test ON user FIELDS email UNIQUE' },
}",
);
assert_eq!(tmp, val);
@ -778,10 +778,10 @@ async fn define_statement_index_multiple_unique() -> Result<(), Error> {
let tmp = res.remove(0).result?;
let val = Value::parse(
"{
ev: {},
fd: {},
ft: {},
ix: { test: 'DEFINE INDEX test ON user FIELDS account, email UNIQUE' },
events: {},
fields: {},
tables: {},
indexes: { test: 'DEFINE INDEX test ON user FIELDS account, email UNIQUE' },
}",
);
assert_eq!(tmp, val);
@ -864,10 +864,10 @@ async fn define_statement_index_single_unique_existing() -> Result<(), Error> {
let tmp = res.remove(0).result?;
let val = Value::parse(
"{
ev: {},
fd: {},
ft: {},
ix: {},
events: {},
fields: {},
tables: {},
indexes: {},
}",
);
assert_eq!(tmp, val);
@ -911,10 +911,10 @@ async fn define_statement_index_multiple_unique_existing() -> Result<(), Error>
let tmp = res.remove(0).result?;
let val = Value::parse(
"{
ev: {},
fd: {},
ft: {},
ix: {},
events: {},
fields: {},
tables: {},
indexes: {},
}",
);
assert_eq!(tmp, val);
@ -944,16 +944,16 @@ async fn define_statement_analyzer() -> Result<(), Error> {
let tmp = res.remove(0).result?;
let val = Value::parse(
"{
az: {
analyzers: {
autocomplete: 'DEFINE ANALYZER autocomplete FILTERS LOWERCASE,EDGENGRAM(2,10)',
english: 'DEFINE ANALYZER english TOKENIZERS SPACE,CASE FILTERS LOWERCASE,SNOWBALL(ENGLISH)',
},
dl: {},
dt: {},
fc: {},
pa: {},
sc: {},
tb: {}
logins: {},
tokens: {},
functions: {},
params: {},
scopes: {},
tables: {}
}",
);
assert_eq!(tmp, val);
@ -985,10 +985,10 @@ async fn define_statement_search_index() -> Result<(), Error> {
let tmp = res.remove(0).result?;
let val = Value::parse(
"{
ev: {},
fd: {},
ft: {},
ix: { blog_title: 'DEFINE INDEX blog_title ON blog FIELDS title SEARCH english BM25(1.2,0.75,100) HIGHLIGHTS' },
events: {},
fields: {},
tables: {},
indexes: { blog_title: 'DEFINE INDEX blog_title ON blog FIELDS title SEARCH english BM25(1.2,0.75,100) HIGHLIGHTS' },
}",
);
assert_eq!(tmp, val);

14
lib/tests/param.rs
View file

@ -25,13 +25,13 @@ async fn define_global_param() -> Result<(), Error> {
let tmp = res.remove(0).result?;
let val = Value::parse(
"{
az: {},
dl: {},
dt: {},
fc: {},
pa: { test: 'DEFINE PARAM $test VALUE 12345' },
sc: {},
tb: {},
analyzers: {},
logins: {},
tokens: {},
functions: {},
params: { test: 'DEFINE PARAM $test VALUE 12345' },
scopes: {},
tables: {},
}",
);
assert_eq!(tmp, val);

28
lib/tests/remove.rs
View file

@ -27,13 +27,13 @@ async fn remove_statement_table() -> Result<(), Error> {
let tmp = res.remove(0).result?;
let val = Value::parse(
"{
az: {},
dl: {},
dt: {},
fc: {},
pa: {},
sc: {},
tb: {}
analyzers: {},
logins: {},
tokens: {},
functions: {},
params: {},
scopes: {},
tables: {}
}",
);
assert_eq!(tmp, val);
@ -61,13 +61,13 @@ async fn remove_statement_analyzer() -> Result<(), Error> {
let tmp = res.remove(0).result?;
let val = Value::parse(
"{
az: {},
dl: {},
dt: {},
fc: {},
pa: {},
sc: {},
tb: {}
analyzers: {},
logins: {},
tokens: {},
functions: {},
params: {},
scopes: {},
tables: {}
}",
);
assert_eq!(tmp, val);

30
lib/tests/strict.rs
View file

@ -232,7 +232,7 @@ async fn loose_mode_all_ok() -> Result<(), Error> {
let tmp = res.remove(0).result?;
let val = Value::parse(
"{
ns: { test: 'DEFINE NAMESPACE test' },
namespaces: { test: 'DEFINE NAMESPACE test' },
}",
);
assert_eq!(tmp, val);
@ -240,9 +240,9 @@ async fn loose_mode_all_ok() -> Result<(), Error> {
let tmp = res.remove(0).result?;
let val = Value::parse(
"{
db: { test: 'DEFINE DATABASE test' },
nl: {},
nt: {},
databases: { test: 'DEFINE DATABASE test' },
logins: {},
tokens: {},
}",
);
assert_eq!(tmp, val);
@ -250,13 +250,13 @@ async fn loose_mode_all_ok() -> Result<(), Error> {
let tmp = res.remove(0).result?;
let val = Value::parse(
"{
az: {},
dl: {},
dt: {},
fc: {},
pa: {},
sc: {},
tb: { test: 'DEFINE TABLE test SCHEMALESS PERMISSIONS NONE' },
analyzers: {},
logins: {},
tokens: {},
functions: {},
params: {},
scopes: {},
tables: { test: 'DEFINE TABLE test SCHEMALESS PERMISSIONS NONE' },
}",
);
assert_eq!(tmp, val);
@ -264,10 +264,10 @@ async fn loose_mode_all_ok() -> Result<(), Error> {
let tmp = res.remove(0).result?;
let val = Value::parse(
"{
ev: {},
fd: { extra: 'DEFINE FIELD extra ON test VALUE true' },
ft: {},
ix: {},
events: {},
fields: { extra: 'DEFINE FIELD extra ON test VALUE true' },
tables: {},
indexes: {},
}",
);
assert_eq!(tmp, val);

8
lib/tests/table.rs
View file

@ -40,10 +40,10 @@ async fn define_foreign_table() -> Result<(), Error> {
let tmp = res.remove(0).result?;
let val = Value::parse(
"{
ev: {},
fd: {},
ft: { person_by_age: 'DEFINE TABLE person_by_age SCHEMALESS AS SELECT count(), age, math::sum(age) AS total, math::mean(score) AS average FROM person GROUP BY age' },
ix: {},
events: {},
fields: {},
tables: { person_by_age: 'DEFINE TABLE person_by_age SCHEMALESS AS SELECT count(), age, math::sum(age) AS total, math::mean(score) AS average FROM person GROUP BY age' },
indexes: {},
}",
);
assert_eq!(tmp, val);