1
0
mirror of https://github.com/vlang/v.git synced 2023-08-10 21:13:21 +03:00
v/vlib/orm/orm_test.v

409 lines
7.1 KiB
V
Raw Normal View History

// import db.mysql
// import db.pg
2022-06-16 20:19:49 +03:00
import time
import db.sqlite
2020-06-07 16:44:33 +03:00
const (
offset_const = 2
)
2020-06-17 05:05:13 +03:00
struct Module {
id int [primary; sql: serial]
2020-12-26 15:40:22 +03:00
name string
2020-06-28 22:10:49 +03:00
nr_downloads int
2021-09-26 11:17:56 +03:00
test_id u64
user User
created time.Time
2020-06-28 22:10:49 +03:00
}
[table: 'userlist']
2020-06-28 22:10:49 +03:00
struct User {
id int [primary; sql: serial]
2023-05-02 18:00:54 +03:00
age int
name string [sql: 'username']
2023-05-02 18:00:54 +03:00
is_customer bool
skipped_string string [skip]
skipped_string2 string [sql: '-']
skipped_array []string [skip]
skipped_array2 []string [sql: '-']
2020-06-28 22:10:49 +03:00
}
struct Foo {
age int
2019-08-02 07:57:35 +03:00
}
2021-08-03 05:17:00 +03:00
struct TestTime {
id int [primary; sql: serial]
create time.Time
}
fn test_use_struct_field_as_limit() {
db := sqlite.connect(':memory:') or { panic(err) }
sql db {
create table User
}!
foo := Foo{
age: 10
}
sam := User{
age: 29
name: 'Sam'
skipped_string2: 'this should be ignored'
skipped_array: ['ignored', 'array']
skipped_array2: ['another', 'ignored', 'array']
}
sql db {
insert sam into User
}!
users := sql db {
select from User limit foo.age
}!
assert users.len == 1
assert users[0].name == 'Sam'
assert users[0].age == 29
2023-05-02 18:00:54 +03:00
assert users[0].skipped_string == ''
assert users[0].skipped_string2 == ''
assert users[0].skipped_array == [], 'skipped because of the [skip] tag, used for both sql and json'
assert users[0].skipped_array2 == [], "should be skipped, because of the sql specific [sql: '-'] tag"
}
2022-05-26 22:53:09 +03:00
fn test_orm() {
db := sqlite.connect(':memory:') or { panic(err) }
2022-05-26 22:53:09 +03:00
2021-04-07 16:27:02 +03:00
sql db {
2021-09-26 11:17:56 +03:00
create table Module
}!
sql db {
create table User
}!
name := 'Peter'
sam := User{
age: 29
name: 'Sam'
}
peter := User{
age: 31
name: 'Peter'
}
k := User{
age: 30
name: 'Kate'
is_customer: true
}
sql db {
insert sam into User
insert peter into User
insert k into User
}!
2021-02-01 23:44:09 +03:00
2021-04-08 03:13:25 +03:00
c := sql db {
select count from User where id != 1
}!
2021-04-08 03:13:25 +03:00
assert c == 2
2020-06-17 01:59:33 +03:00
nr_all_users := sql db {
select count from User
}!
2020-06-17 01:59:33 +03:00
assert nr_all_users == 3
2020-06-17 01:59:33 +03:00
nr_users1 := sql db {
select count from User where id == 1
}!
2020-06-17 01:59:33 +03:00
assert nr_users1 == 1
2020-06-17 01:59:33 +03:00
nr_peters := sql db {
select count from User where id == 2 && name == 'Peter'
}!
2020-06-17 01:59:33 +03:00
assert nr_peters == 1
nr_peters2 := sql db {
select count from User where id == 2 && name == name
}!
assert nr_peters2 == 1
nr_peters3 := sql db {
select count from User where name == name
}!
assert nr_peters3 == 1
peters := sql db {
2020-06-22 17:58:43 +03:00
select from User where name == name
}!
assert peters.len == 1
assert peters[0].name == 'Peter'
mut users := sql db {
2020-06-22 17:58:43 +03:00
select from User where name == name limit 1
}!
one_peter := users.first()
2020-06-22 17:58:43 +03:00
assert one_peter.name == 'Peter'
assert one_peter.id == 2
users = sql db {
2020-06-17 05:05:13 +03:00
select from User where id == 1
}!
user := users.first()
2020-06-17 05:05:13 +03:00
assert user.name == 'Sam'
assert user.id == 1
assert user.age == 29
users = sql db {
2020-06-17 15:18:32 +03:00
select from User where id > 0
}!
2020-06-17 15:18:32 +03:00
assert users.len == 3
assert users[0].name == 'Sam'
assert users[1].name == 'Peter'
assert users[1].age == 31
2020-06-17 15:29:44 +03:00
users2 := sql db {
select from User where id < 0
}!
2020-06-17 15:29:44 +03:00
assert users2.len == 0
2020-06-17 15:29:44 +03:00
users3 := sql db {
select from User where age == 29 || age == 31
}!
2020-06-17 15:29:44 +03:00
assert users3.len == 2
assert users3[0].age == 29
assert users3[1].age == 31
2020-12-26 15:40:22 +03:00
new_user := User{
name: 'New user'
age: 30
}
2020-06-19 17:43:32 +03:00
sql db {
insert new_user into User
}!
users = sql db {
2020-06-19 17:43:32 +03:00
select from User where id == 4
}!
x := users.first()
2020-06-19 17:43:32 +03:00
assert x.age == 30
assert x.id == 4
assert x.name == 'New user'
users = sql db {
2020-06-23 14:59:00 +03:00
select from User where id == 3
}!
kate := users.first()
2020-06-23 14:59:00 +03:00
assert kate.is_customer == true
users = sql db {
2020-06-23 14:59:00 +03:00
select from User where is_customer == true limit 1
}!
customer := users.first()
2020-06-23 14:59:00 +03:00
assert customer.is_customer == true
assert customer.name == 'Kate'
2020-06-24 15:32:14 +03:00
sql db {
update User set age = 31 where name == 'Kate'
}!
users = sql db {
2020-06-25 18:12:32 +03:00
select from User where id == 3
}!
kate2 := users.first()
2020-06-25 18:12:32 +03:00
assert kate2.age == 31
assert kate2.name == 'Kate'
2020-06-25 18:18:44 +03:00
sql db {
update User set age = 32, name = 'Kate N' where name == 'Kate'
}!
users = sql db {
select from User where id == 3
}!
mut kate3 := users.first()
assert kate3.age == 32
assert kate3.name == 'Kate N'
new_age := 33
sql db {
update User set age = new_age, name = 'Kate N' where id == 3
}!
users = sql db {
select from User where id == 3
}!
kate3 = users.first()
assert kate3.age == 33
assert kate3.name == 'Kate N'
foo := Foo{34}
sql db {
update User set age = foo.age, name = 'Kate N' where id == 3
}!
users = sql db {
select from User where id == 3
}!
kate3 = users.first()
assert kate3.age == 34
assert kate3.name == 'Kate N'
2020-06-26 21:38:17 +03:00
no_user := sql db {
select from User where id == 30
}!
assert no_user.len == 0
2020-06-27 17:19:12 +03:00
two_users := sql db {
select from User limit 2
}!
2020-06-27 17:19:12 +03:00
assert two_users.len == 2
2020-06-27 17:25:25 +03:00
assert two_users[0].id == 1
2020-06-27 17:25:25 +03:00
y := sql db {
select from User limit 2 offset 1
}!
2020-06-27 17:25:25 +03:00
assert y.len == 2
assert y[0].id == 2
2020-06-27 17:41:29 +03:00
z := sql db {
2022-05-26 22:53:09 +03:00
select from User order by id limit 2 offset offset_const
}!
2020-06-27 17:41:29 +03:00
assert z.len == 2
assert z[0].id == 3
users = sql db {
select from User order by age desc limit 1
}!
oldest := users.first()
2020-07-02 20:29:22 +03:00
assert oldest.age == 34
offs := 1
users = sql db {
select from User order by age desc limit 1 offset offs
}!
second_oldest := users.first()
assert second_oldest.age == 31
2020-07-07 17:55:32 +03:00
sql db {
delete from User where age == 34
}!
users = sql db {
2020-07-07 17:55:32 +03:00
select from User order by age desc limit 1
}!
updated_oldest := users.first()
2020-07-07 17:55:32 +03:00
assert updated_oldest.age == 31
2021-02-01 23:44:09 +03:00
2022-05-26 22:53:09 +03:00
// Remove this when pg is used
2022-06-16 20:19:49 +03:00
// db.exec('insert into User (name, age) values (NULL, 31)')
users = sql db {
2021-02-01 23:44:09 +03:00
select from User where id == 5
}!
assert users.len == 0
2020-06-16 13:14:22 +03:00
users = sql db {
select from User where id == 1
}!
age_test := users.first()
2020-06-07 16:44:33 +03:00
assert age_test.age == 29
2020-06-07 16:44:33 +03:00
sql db {
update User set age = age + 1 where id == 1
}!
2020-06-07 16:44:33 +03:00
users = sql db {
select from User where id == 1
}!
2020-06-07 16:44:33 +03:00
mut first := users.first()
assert first.age == 30
2020-06-07 16:44:33 +03:00
sql db {
update User set age = age * 2 where id == 1
}!
2020-06-07 16:44:33 +03:00
users = sql db {
select from User where id == 1
}!
2020-06-07 16:44:33 +03:00
first = users.first()
assert first.age == 60
2021-08-03 05:17:00 +03:00
sql db {
create table TestTime
}!
2021-08-03 05:17:00 +03:00
tnow := time.now()
time_test := TestTime{
create: tnow
}
sql db {
insert time_test into TestTime
}!
2021-08-03 05:17:00 +03:00
data := sql db {
select from TestTime where create == tnow
}!
2021-08-03 05:17:00 +03:00
assert data.len == 1
2022-06-16 20:19:49 +03:00
assert tnow.unix == data[0].create.unix
2021-09-26 11:17:56 +03:00
mod := Module{}
sql db {
insert mod into Module
}!
2021-09-26 11:17:56 +03:00
sql db {
update Module set test_id = 11 where id == 1
}!
2021-09-26 11:17:56 +03:00
mut modules := sql db {
2021-09-26 11:17:56 +03:00
select from Module where id == 1
}!
2021-09-26 11:17:56 +03:00
assert modules.first().test_id == 11
t := time.now()
sql db {
update Module set created = t where id == 1
}!
2022-05-26 22:53:09 +03:00
modules = sql db {
select from Module where id == 1
}!
2022-05-26 22:53:09 +03:00
// Note: usually updated_time_mod.created != t, because t has
// its microseconds set, while the value retrieved from the DB
// has them zeroed, because the db field resolution is seconds.
assert modules.first().created.format_ss() == t.format_ss()
2022-05-26 22:53:09 +03:00
users = sql db {
select from User where (name == 'Sam' && is_customer == true) || id == 1
}!
assert users.first() == first
2022-05-26 22:53:09 +03:00
sql db {
drop table Module
drop table TestTime
}!
2020-06-07 16:44:33 +03:00
}