A biblioteca padrão
Slide 74 de 85
74tableA biblioteca padrão

Leis sobre uma tabela

Gramática: table-law
fortableIDENT.IDENTSQL
table-law = "for" "table" IDENT { "." IDENT } SQL ;

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 o if da 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.

Um contato só lê as próprias conversas
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)))
	}
}
Administradores veem todas as organizações
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)
	}
}
chats.hive, errado de propósito
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 {
}
Como uma recusa aparece
$ 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}`