Basi di dati - Appunti lezione

NON SI PUO' MISCHIARE GRAFI DIRETTI CON GRAFI NON DIRETTI E VICEVERSA



Grafi diretti (relazione che hanno una direzione, i nodi sono asimmetrici quindi presenta la direzione

della freccia) (esempio: strada a senso unico). 

In questo caso NON esiste il concetto di GRADO DEL NODO OUTGOING-DEGREE (individuato dal

numero di archi uscenti, archi che nascono da quel nodo)

INGOING-DEGREE (individuato dal numero di archi incidenti, archi che indicono su quel nodo)



Grafi non diretti (relazione tra nodi è simmetrica, tutte le relazioni possibili ossia non è specificata la



direzione della freccia). GRADO DEL NODO degree di un nodo sono tutti gli archi che nascono da quel

nodo (contando il numero di archi che incidono su quel nodo)

Questo schema a grafo permette di realizzare query graph traversal (attraversamento dei grafi) come

quando si chiede di andare da un punto A ad un punto C e il come (il percorso) lo trova, ad esempio, google

map, la nostra query(interrogazione) non esprime il COME FARE ma esprime il COSA FARE.

Utili per modellare la base di dati dei social network, routing di rete, individuazione di situazioni

fraudolente.

I grafi li utilizziamo per immagazzinare le informazioni, i grafi sono SEMPRE diretti (asimmetrici ossia è

sempre presente il verso della relazione) in NEO4J.

Composto da 4 Building blocks per costruire grafi in neo4j :

1) Nodi (detti anche nodes o vertices)

2) Relazioni (detti anche edges o archi)

3) Etichette (labels)

4) Proprietà

Nel paradigma a grafo il dato e lo schema vengono letti entrambi contemporaneamente. Vantaggio è

proprio questo degli schemi a grafo. (PARAGONE) Per rappresentare questa base di dati con schema a

grafo in uno schema relazionale come si fa??



SCHEMA E-R (progettazione concettuale) 

SCHEMA RELAZIONALE (progettazione logica) Suppongo che la relazione che l’autore “ha scritto” il libro

sia una relazione 1:n, quindi si può fare un’unica tabella con gli autori e i libri (TABELLA AUTORI) e una

relazione “ha comprato” inserita in una tabella a parte (TABELLA LIBRO) con titolo del libro, data e il nome

di chi ha comprato il libro ed infine una tabella per le persone che non sono autori.

Spiegazione dei building blocks:



1) I nodi sono i V (vertex) del grafo, rappresentano le tuple (righe nel paradigma relazionale,

rispetto ad uno schema relazionale ogni nodo di un grafo sono da intendersi come una tupla)



2) Relazioni rappresentano connessioni binarie, ogni relazione deve avere un nome e una direzione

(asimmetrici in neo4j). Fanno parte dello schema free e fornisce di fatto una semantica (ossia la

relazione spiega cosa vuol dire). Possono contenere delle proprietà e devono avere sempre un

nodo di inizio e un nodo di fine (poiché altrimenti non rappresenta una relazione tra nodi).

E’ impossibile avere una relazione senza padre e senza un figlio, l’integrità del database è sempre

preservata, si può sempre navigare la relazione se è presente. Ci possono essere più relazioni tra i

nodi e una relazione può essere ricorsiva ossia sullo stesso nodo.

3) Le labels (etichette) sono definite sui nodi, si possono metterle/non metterle. Si possono taggare,

ossia si possono “taggare” più elementi che si vogliono. Si possono modellare e alterare i dati a

proprio piacimento

In SQL si specifica il COME arrivare al risultato

In Cypher si specifica il COSA ottenere

Linguaggio Cypher (lingua del DBMS utilizzato da neo4j)

Linguaggio dichiarativo:

 In questo linguaggio non ci si deve preoccupare di spiegare alla macchina ogni singola riga di

codice cosa e come deve fare ad arrivare al risultato che si vuole ottenere, ma in questi linguaggi

dichiarativi si deve spiegare soltanto il COSA si deve fare, la macchina pensa al COME fare. Si

descrive la caratteristica della soluzione che stiamo cercando e il DBMS pensa al COME fare e

trovare quella soluzione. DESCRIVI COSA VUOI NON COME OTTENERLO, AL COME CI PENSERA’ IL

DBMS

 E’ basato sul pattern-matching, ossia descrivere una caratteristica che stiamo cercando e tutte le

volte che viene trovata si fa un match, funziona così il linguaggio Cypher

 E’ case-sensitive (sensibile al maiuscolo e al minuscolo)

 Permette di fare la aggregate, group by, order by, limit

 Si può manipolare il grafo con CREATE, UPDATE, DELETE (crei, modifichi, distruggi)

(Neo4j ha una struttura deprecata ossia chi sviluppa un linguaggio avvisa che se ci fosse una prossima

versione quella funzione potrebbe essere non più supportata)

Con shift + invio si va a capo senza eseguire la query su neo4j

I nodi si scrivono tra parentesi (), le etichette si scrivono all’interno dei nodi e gli attributi del nodo si

scrivono tra parentesi con i loro “valori” {} esempio: (p:person {name: “Fabio”} )

Le relazioni si scrivono tra parentesi [] con all’interno il nome della relazione

Struttura del pattern da utilizzare:

1) () - - > ()

DIRE IL COSA (LA CARATTERISTICA DELLA SOLUZIONE) NON IL COME (con questa istruzione/pattern

neo4j ritorna l’intero grafo connesso, il DBMS naviga il grafo cercando di matchare le proprietà che

sono in relazione, stiamo scrivendo la caratteristica/proprietà della soluzione)

2) (:Person) – [:FRIEND OF] - - > (:Person)

Nel nodo si ha il nome dell’etichetta “person”, la relazione di amicizia(specificazione del nome della

relazione “friend of”), nell’ultimo nodo si ha ancora “person”. VOGLIO LA RELAZIONE IN CUI DUE

PERSONE SONO IN RELAZIONE DI AMICIZIA

3) (p1:Person {name: “Fabio”} ) – [:FRIEND OF] - - > (p2:Person {name:”Mario”} )

Esiste un nodo di tipo “person” che è l’etichetta, name è l’attributo del nodo, il valore è Fabio

p1, p2= identificativi ha la funzione simile all’operatore di rinomina as in SQL, serve per dichiarare i

vari nodi e quando si richiamano è più semplice.

Struttura query in Cypher:

Una interrogazione Cypher si inizia sempre con MATCH pattern (proprietà che si sta cercando) RETURN

risultato (cosa si vuole ottenere)

MATCH (:Person {name: “Fabio”} )

– [:FRIEND OF] - - > (friends)

RETURN friends

(Vantaggi dello schema free dei grafi in neo4j: se lo schema viene alterato e la query è scritta in un

certo modo, l’informazione tiene conto comunque dello schema modificato. Non solo la struttura si

adatta in automatico al dato, ma anche la query se scritta in maniera opportuna terrà conto del dato

nuovo e della struttura del dato. Se la query che ho scritto matcha comunque con la nuova struttura del

dato, sarà tenuto conto nella nuova query)

4) MATCH (:Person {name: “Fabio”} ) – [:FRIEND OF] - - > (friends) RETURN friends

5) COME CREARE I NODI E POTERLI MATCHARE in UNA RELAZIONE

create (:person :student ,name: “Charlie”- )

create (:person :student ,name: “Aurora”- )

match (a:person ,name: “Charlie”-) , (b: person ,name: “Aurora”-)

create (a) – [:SAME_COURSE] - - > (b)

create (a:person ,name: “Charlie”- )

create (:Skill ,name: “Medicine”- )

match (a:Person), (b:skill)

where a.name = “Charlie” and b.name = “Medicine”

create (a) – [r:interested_in] - - > (b)

return r

6) COME CREARE SHORTESTPATH

Uno degli algoritmi famosissimi sui i grafi, rappresenta il percorso più breve per andare da un punto

A ad un punto B (un modo per connettere il dato con il percorso più breve)

create (:person :student ,name: “Charlie”- )

create (:person :student ,name: “Aurora”- )

create (:person :student ,name: “Luca”- )

create (:person :student ,name: “Eleonora”- )

match (a:person ,name: “Charlie”-) , (b: person ,name: “Aurora”-), (c:person ,name: “Luca”- ) ,

(d:person ,name: “Eleonora”- )

create (a) – [:same_course] - - > (b)

create (b) – [:same_course] - - > (c)

create (c) – [:same_course] - - > (d) *

match p=shortestPath((n1:person {name:'Charlie'}) - [:same_course ] - (n2:person{name:'Eleonora'}))

return p

* = fai tutti i salti che vuoi, naviga tutte le relazioni che vuoi, basta che arrivi al risultato che ho

chiesto

UN MODO PER CONNETTERE IL DATO IN MODO MOLTO VELOCE

7) ELIMINARE UN NODO

MATCH (n:work)

DETACH DELETE n

Esercizio da sviluppare con neo4j:

Scaricare i file in formato CSV. Il graph DB permette di caricare il CSV, ci sono delle key-word per

costruire il grafo, per iniziare bisogna seguire questo script:

-creo le persone

LOAD CSV WITH HEADERS FROM 'file:/person.csv' AS row FIELDTERMINATOR ';'

CREATE (:person {name: row.name, gender: row.gender});

(meglio utilizzare non le virgolette “ “ ma gli apici ‘ ‘ )

-creo le skill

LOAD CSV WITH HEADERS FROM 'file:/skill.csv' AS row FIELDTERMINATOR ';'

CREATE (:skill {name: row.name});

-creo gli interessi delle persone (quindi le relazioni)

LOAD CSV WITH HEADERS FROM 'file:/interested_in.csv' AS row FIELDTERMINATOR ';'

MATCH (p:person {name:row.from}), (s:skill {name:row.to})

CREATE (p) – [r:INTERESTED_IN] - - > (s);

(gli attributi si possono mettere anche con la WHERE piuttosto che con le parentesi graffe)

LOAD CSV WITH HEADERS FROM 'file:/interested_in.csv' AS row FIELDTERMINATOR ';'

MATCH (p:person), (s:skill) WHERE p.name = row.from AND s.name=row.to

CREATE (p) – [r:INTERESTED_IN] - - > (s);

-creo i lavori possibili

LOAD CSV WITH HEADERS FROM 'file:/projects.csv' AS row FIELDTERMINATOR ';'

CREATE (:work{name: row.name});

-creo che lavoro fanno le persone (quindi le relazioni)

LOAD CSV WITH HEADERS FROM 'file:/worked_on.csv' AS row FIELDTERMINATOR ';'

MATCH (p:person {name:row.from}), (w:work {name:row.to})

CREATE (p) – [r:WORKED_ON] - - > (w);

-creo le compagnie

LOAD CSV WITH HEADERS FROM 'file:/company.csv' as row FIELDTERMINATOR ';'

CREATE (:company{name:row.name});

-creo la relazione tra le persone e le compagnie

LOAD CSV WITH HEADERS FROM 'file:/works_for.csv' as row FIELDTERMINATOR ';'

MATCH (p:person{name:row.from}),(c:company{name:row.to})

CREATE (p)-[r:WORKS_FOR]->(c);

RISULTATO:

[I nodi pozzo in questo grafo sono—skill—work—company] Lezione 08/04/2021

14 - “NOSQL- DataBase a grafo- 2 Parte”

Fino ad ora abbiamo solo creato (i nodi, le relazioni…) ora dobbiamo scrivere delle query

Approfondimento su come scrivere le query:

Come si fa una query?? Si definisce il pattern