# Persistance et bases de données

###### tags: `cours`

## Redis (2009)
- Stocker les variables des applications à l'extérieur des applications.
- En C

Redis et Cli

Jedis: client java
redis-py: client python

Fait pour du stockage en RAM (rapide)

Pas d'interprétation de la valeur (pas de jointure, filtres...)

## String
set key tot world
set key expire..
ttl key ..
mset a 10 b 10

## list
rpush list A
lpush list B
lrange list 0 -1
rpop
lpop
ltrim list _ _
brpop list2

## hash
hmset key:foo name enseirb adress talence creation 1900
hget

## set
sadd sett 1 0 7 9 7
smembers sett
sdel sett

Intersection:
sinter personne1 personne2 ....

type foo
keys regex
zremrangebyscore deck _ _
zrangebyscore -inf +inf
zrank deck _

pfadd

SCAN 0

set: String dans clef
push: Elements dans list

`docker-compose up --build -d`

see corrections Moodle

## MongoDB
- Codé en C++
- Utilisé avec Javascript, JSON ou plutôt.. BSON
- Utilisée pour la gestion de documents
- Eviter jointures

BSON: On étend JSON avec des timestamps, coordonées géographiques
Exemple: "new Date('')", ObjectId(), NumberLong()...

MongoDB
- Database
- Collections
- Documents

database always refered to db.
`db.aCollection.insertOne({x:1})`
`db.aCollection.insertMany( [{x:1}, ...`
`db.aCollection.find({age: { $gt : 18}}, ...`
`db.aCollection.updateMany( filter, $set: {...,...}`
updateOne
replaceOne
createView() -> restreint visibilité, read only, dématérialisée
$merge into -> vue matérialisée, read-write

au moins: $all

$in : {"toto", "tat"}
$or [..., ..., ]
$and
$size
$sum: "$amount"

ORDRE important.

PLus on a d'index plus c'est rapide en lecture, plus c'est lent en écriture.

1) filtre
2) projection

pas hésiter à créer des collections, prend pas bcp de place

### Clusters
Noeufs = shards
Chaque shard a des chunks (ensemble de shard keys)
Cette répartition doit être bien pensée car on souhaite faire des recherches sur un minimum de chunks.
Il faut que les chunks soient équitablement répartis.
--> shard key composées, attention aux key croissants

### TP (page 47)

#### Find
1) {categories : "Python"}
2) {categories : "Python", pageCount : { \$lt: 500}}
3) {\$and :
[{\$or :
[{pageCount : { \$gt: 1000}},
{pageCount: { \$lt: 300}}]},
{pageCount: { $ne : 0 }}]}
4) collection.find({ arrayElementName: { \$exists: true, $not: {\$size: 0} } })

#### Agrégation
page 22: https://moodle.bordeaux-inp.fr/pluginfile.php/189335/mod_resource/content/1/2021-10-12_mongodb.pdf

1)

{$group
    {
  _id: "$status", count:{$sum : 1}
    }
}

2)

{
    {$wind
        {
          path: "$authors"
        }
    }
    {$group
        {
          _id: "$authors", totalNbPages: {$sum: "$pageCount"}
        }
    }
}

3)

Changer le `$group` pour pousser les livres/isbn:

{
  _id: "$authors",
  totalPages: {
    $sum: "$pageCount"
  },
  books: {
    $push: {
      "title": "$title",
      "isbn": "$isbn"
    }
  }
}

Rajouter un `$sort` inversé:

{
  totalPages: -1
}

Enlever la string vide avec un `$match`:

{
  "_id": { "$ne": "" }
}

Et un `$limit` pour n’avoir que les 3 premiers.

## Neo4j (graphes)
### Intro
- Titan
- ArangoDB
- Neptune (AWS)
- Neo4j Aura (cloud)

- graphes des pages web
- des réseaux sociaux
- ... beaucoup de *relations*

==> fait pour l'analyse des groupes etc

## Requêtes
**Pour les noeuds:** `()`

- (matrix)
- `(:Movie)` : de label/type Movie
- `(matrix:Movie)` : variable matrix de label Movie
- `(matrix:Movie {title: 'The matrix; relased: 1997'})`

`CREATE (:Person:Actor {name: 'Tom Hanks', born: 1956})`

**Pour les relations:** `-->`
- necessité du type
- possiblité de propriétés de description
- relation disstance
- possibilité autoréférence

`CREATE -(:Person:Actor {name: 'Tom Hanks', born: 1956})`
filtrer selon propriétés, relation, label du nom

### TP

CREATE (f:Objet:Couvert {name: 'fourchette', prix: 3})
CREATE (c:Objet:Couvert {name: 'couteau', prix: 2})
CREATE (s:Objet:Aliment {name: 'steak', prix: 6})
CREATE (f)-[pi:PIQUE]->(s)
CREATE (c)-[co:COUPE]->(s)

MERGE (f:Objet:Couvert {name: 'fourchette'})
ON CREATE SET f.prix = 3
MERGE (c:Objet:Couvert {name: 'couteau'})
ON CREATE SET c.prix = 2
MERGE (s:Objet:Aliment {name: 'steak'})
ON CREATE SET s.prix = 6

MATCH (o:Objet)
WHERE o.prix >= 3
RETURN o

MATCH (c:Objet:Couvert)
WHERE c.prix >= 3
RETURN c

MATCH (c:Couvert {name: 'fourchette'})
RETURN c

MATCH (c:Objet)-[:COUPE]->(:Objet)
RETURN c

MATCH (c:Objet {prix: 3})-[f:PIQUE]->(a:Objet)
RETURN c, f, a

MATCH (t:Person {name: 'Tom Hanks'})-[role:ACTED_IN]->(m:Movie)
MATCH (p:Person)
RETURN p, role, m

MATCH(n)
DETACH DELETE n

MATCH(n)
RETURN n