Leis sobre uma tabela
Gramática: table-law
Uma lei escrita for table <nome> é sobre toda query naquela tabela. Ela recebe um parâmetro — o valor para quem a query roda, como o contato ou a sessão que pergunta — e seu corpo é um filtro SQL em vez de instruções: Hive só aparece em valores {…} e em condições if, como numa query. Um corpo que abre com if, or ou and é um bloco WHERE { }, cujo filtro vale onde seus ifs valem; qualquer outro corpo vale sempre.
Toda query que toca a tabela precisa receber um valor do tipo do parâmetro da lei, e o compilador lê o SQL dela para cobrar o filtro:
- o que ela lê, altera ou apaga carrega o filtro: uma das partes que o WHERE liga com AND é o filtro, ou diz mais —
fk_contact_from_id = {contact.id}sozinho carrega um filtro que aceita qualquer uma das duas colunas — onde quer que oifda lei valha; - uma linha que ela insere cai dentro do filtro, escrevendo o valor do filtro numa das suas partes
coluna = valor; - uma linha que ela atualiza continua dentro dele: definir uma coluna filtrada a define com o valor do filtro.
Junções, subqueries e cada lado de um UNION são lidos cada um por si, e uma coluna que a lei nomeia é da tabela quando escrita pelo apelido da tabela. hive.sql.unsafe não é uma query, então nenhuma lei o lê: SQL montado em tempo de execução fica fora da garantia, e fácil de achar.
type Contact {
id: Int
}
type Chat {
body: Str
}
law ownChatsOnly(contact: Contact) for table chats {
fk_contact_from_id = {contact.id} or
fk_contact_to_id = {contact.id}
}
query sent(contact: Contact): Chat[dyn] {
SELECT body FROM chats WHERE fk_contact_from_id = {contact.id}
}
query send(contact: Contact, to: Int, body: Str): void {
INSERT INTO chats (fk_contact_from_id, fk_contact_to_id, body) VALUES ({contact.id}, {to}, {body})
}
proc main(): void {
opened := hive.sql.pool(hive.sql.DatabaseDriver.SQLite(), ":memory:", 1, 1)
if opened is Result.Ok(db) {
_ := hive.sql.unsafe(db, "CREATE TABLE chats (fk_contact_from_id INTEGER, fk_contact_to_id INTEGER, body TEXT)")
_ := hive.sql.run(db, send(Contact(1), 2, "almoço?"))
echo hive.sql.run(db, sent(Contact(1)))
}
}type Organization {
id: Int
name: Str
}
type User {
Admin
Regular
id: Int
name: Str
org: Organization
}
type Session {
user: User
}
law sameOrganization(session: Session) for table people {
if session.user is User.Regular {
org_id = {session.user.org.id}
}
}
query names(session: Session): Str[dyn] {
SELECT name FROM people
WHERE {
if session.user is User.Regular { org_id = {session.user.org.id} }
}
ORDER BY name
}
proc main(): void {
bees := Organization(1, "Bees")
ada := Session(User.Regular(1, "Ada", bees))
root := Session(User.Admin(2, "Root", bees))
opened := hive.sql.pool(hive.sql.DatabaseDriver.SQLite(), ":memory:", 1, 1)
if opened is Result.Ok(db) {
hive.sql.unsafe(db, "CREATE TABLE people (name TEXT, org_id INTEGER)")
hive.sql.unsafe(db, "INSERT INTO people VALUES ('Ada', 1), ('Grace', 1), ('Tim', 2)")
echo hive.sql.run(db, names(ada))
echo hive.sql.run(db, names(root))
hive.sql.close(db)
}
}type Contact {
id: Int
}
type Chat {
body: Str
}
law ownChatsOnly(contact: Contact) for table chats {
fk_contact_from_id = {contact.id} or
fk_contact_to_id = {contact.id}
}
query everything(contact: Contact): Chat[dyn] {
SELECT body FROM chats
}
proc main(): void {
}$ hive check chats.hive
chats.hive:14: in `everything`: this query reads `chats` without the filter law `ownChatsOnly` keeps on it
its WHERE has to carry `fk_contact_from_id = {contact.id} OR fk_contact_to_id = {contact.id}`