Project

General

Profile

INUIT datasource - Proposition d'ajouts post-v0.1.x

===== Propositions du 10.11.2015 =====

Mettre à disposition les commandes $group (ou distinct) et $sort (ou orderby)

Références :

Actuellement, l'application Front-End fait du "grouping" de plusieurs données pour récupérer les voitures et du "sorting" après avoir récupéré les données sur le temps (voitures + routes) avant de les afficher.

L'idée derrière cette proposition serait de plutôt utiliser le framework d'agrégation offert par MongoDB que de faire une nouvelle implémentation de ces opérations côté client.

Pas indispensable pour la v0.2.0 (ou de manière générale), mais à voir si une fois il y a possibilité de prendre un peu de temps à implémenter des paramètres pour utiliser ces commandes.

===== Propositions du 06.10.2015 =====

Référence : http://inuit.iict.ch/1/doc/spec2.html

Description du problème

L'application cliente (Front-End) ne devrait pas avoir à charger l'intégralité des données pour afficher juste ce qu'elle désire à l'écran. L'état actuel du datastore l'y oblige pourtant dans la situation suivante :

  • Je souhaite voir les roads dans la portée suivante : latitude dans [52.2; 52.3] et longitude dans [21.1; 21.2]
  • Les roads ne possèdent pas leur latitude/longitude source et latitude/longitude de destination -> Juste une référence sur les nodes
  • Comme les roads ne possèdent pas leur latitude/longitude source et latitude/longitude de destination -> Impossible de faire une requête where selon celles-ci

L'application est alors obligée de faire la requête where selon les latitudes/longitudes sur l'endpoint des nodes (où se trouvent latitudes/longitudes) et d'ensuite charger l'intégralité - ou une grande partie - des roads pour faire la relation entre les nodes et ces dernières. Un deuxième problème survient alors : rien ne prouve que nous avons chargé les 2 nodes de chaque road !

i.e. : nodeSrc était dans la portée, mais pas nodeDst.

Il faut du coup pour chaque road vérifier si les 2 nodes sont chargés, et ré-effectuer une requête pour chaque noeud de plus à charger. Au final, l'application cliente doit faire beaucoup de pré-traitements avant de pouvoir afficher les données, et le serveur se retrouve "assiégé" de requêtes.

Une jointure côté serveur serait préférable à la situation actuelle : certes le temps de traitement d'une requête sera plus long, mais il n'y en aura plus qu'une et le client aura des données prêtes à l'emploi !

NOTE : Les deux propositions de jointures plus bas parlent uniquement de edges, mais roads est également concerné par ce problème.

----- Proposition 1 : Jointure imbriquée -----

Effectuer une jointure imbriquée des nodes sur les edges et les roads afin d'autoriser le client à faire une requête where selon les latitudes/longitudes minimales/maximales :

curl -X GET -i -g 'http://inuit.iict.ch/1/edges?where={
    "$or"[
        {"$and": [
            {"nodeSrc.nodeLat": {"$gte": DECIMAL, "$lte": DECIMAL}},
            {"nodeSrc.nodeLon": {"$gte": DECIMAL, "$lte": DECIMAL}}
        ]},
        {"$and": [
            {"nodeDst.nodeLat": {"$gte": DECIMAL, "$lte": DECIMAL}},
            {"nodeDst.nodeLon": {"$gte": DECIMAL, "$lte": DECIMAL}}
        ]}
    ]
}'

Exemple : nouveau schéma pour edges :

{
    "$schema": "http://json-schema.org/draft-04/schema#",
    "title": "Edge",
    "description": "A graph edge in the CrowdStream project",
    "type": "object",
    "properties" : {
        "nodeSrc": {
            "nodeId": {
                "description": "unique node id",
                "type": "number" 
            },
            "nodeLat": {
                "description": "node latitude in the form [+-]DDD.DDDDD where D indicates degrees",
                "type": "number" 
            },
            "nodeLon": {
                "description": "node longitude in the form [+-]DDD.DDDDD where D indicates degrees",
                "type": "number" 
            }
        },
        "nodeDst": {
            "nodeId": {
                "description": "unique node id",
                "type": "number" 
            },
            "nodeLat": {
                "description": "node latitude in the form [+-]DDD.DDDDD where D indicates degrees",
                "type": "number" 
            },
            "nodeLon": {
                "description": "node longitude in the form [+-]DDD.DDDDD where D indicates degrees",
                "type": "number" 
            }
        },
        "dist": {
            "description": "distance between nodeSrc and nodeDst in km",
            "type": "number" 
        },
        "numLanes": {
            "description": "number of lanes between nodeSrc and nodeDst",
            "type": "number" 
        },
        "maxSpeed": {
            "description": "maximum speed between nodeSrc and nodeDst",
            "type": "number" 
        }                        
    } 
}

----- Proposition 2 : Jointure simple -----

Effectuer une jointure simple des nodes sur les edges et les roads afin d'autoriser le client à faire une requête where selon les latitudes/longitudes minimales/maximales :

curl -X GET -i -g 'http://inuit.iict.ch/1/edges?where={
    "$or"[
        {"$and": [
            {"nodeSrcLat": {"$gte": DECIMAL, "$lte": DECIMAL}},
            {"nodeSrcLon": {"$gte": DECIMAL, "$lte": DECIMAL}}
        ]},
        {"$and": [
            {"nodeDstLat": {"$gte": DECIMAL, "$lte": DECIMAL}},
            {"nodeDstLon": {"$gte": DECIMAL, "$lte": DECIMAL}}
        ]}
    ]
}'

Exemple : nouveau schéma pour edges :

{
    "$schema": "http://json-schema.org/draft-04/schema#",
    "title": "Edge",
    "description": "A graph edge in the CrowdStream project",
    "type": "object",
    "properties" : {
        "nodeSrcId": {
            "description": "unique node id",
            "type": "number" 
        },
        "nodeSrcLat": {
            "description": "node latitude in the form [+-]DDD.DDDDD where D indicates degrees",
            "type": "number" 
        },
        "nodeSrcLon": {
            "description": "node longitude in the form [+-]DDD.DDDDD where D indicates degrees",
            "type": "number" 
        }
        "nodeDstId": {
            "description": "unique node id",
            "type": "number" 
        },
        "nodeDstLat": {
            "description": "node latitude in the form [+-]DDD.DDDDD where D indicates degrees",
            "type": "number" 
        },
        "nodeDstLon": {
            "description": "node longitude in the form [+-]DDD.DDDDD where D indicates degrees",
            "type": "number" 
        },
        "dist": {
            "description": "distance between nodeSrc and nodeDst in km",
            "type": "number" 
        },
        "numLanes": {
            "description": "number of lanes between nodeSrc and nodeDst",
            "type": "number" 
        },
        "maxSpeed": {
            "description": "maximum speed between nodeSrc and nodeDst",
            "type": "number" 
        }                        
    } 
}

===== Propositions du 28.09.2015 =====

Référence : http://inuit.iict.ch/1/doc/spec.html

----- "edges" endpoint -----

Client request

curl -X GET -i -g 'http://inuit.iict.ch/1/edges?where={"locLat": {"$gte": DECIMAL, "$lte": DECIMAL}, "locLon": {"$gte": DECIMAL, "$lte": DECIMAL}}'

Server response (n = edges count)

{
    "nodeId1":     [n times INT],
    "locLat1":     [n times DECIMAL],
    "locLon1":     [n times DECIMAL],
    "nodeId2":     [n times INT],
    "locLat2":     [n times DECIMAL],
    "locLon2":     [n times DECIMAL],
    "distance":    [n times DECIMAL],
    "lanesCount":  [n times INT],
    "avgMaxSpeed": [n times DECIMAL]
}

----- "edges-data" endpoint -----

Client request

curl -X GET -i -g 'http://inuit.iict.ch/1/edges-data?where={"locLat": {"$gte": DECIMAL, "$lte": DECIMAL}, "locLon": {"$gte": DECIMAL, "$lte": DECIMAL}, "t": {"$gte": TIMESTAMP, "$lte": TIMESTAMP}}'

Server response (n = edges count, m = data count per edge)

{
    "nodeId1":  [n times INT],
    "nodeId2":  [n times INT],
    "t":        [n times [m times TIMESTAMP]],
    "avgSpeed": [n times [m times DECIMAL]]
}

----- "cars-data" endpoint -----

Client request

curl -X GET -i -g 'http://inuit.iict.ch/1/cars-data?where={"locLat": {"$gte": DECIMAL, "$lte": DECIMAL}, "locLon": {"$gte": DECIMAL, "$lte": DECIMAL}, "t": {"$gte": TIMESTAMP, "$lte": TIMESTAMP}}'

Server response (n = cars count, m = data count per car)

{
    "carId":   [n times INT],
    "t":       [n times [m times TIMESTAMP]],
    "nodeId1": [n times [m times INT]],
    "nodeId2": [n times [m times INT]],
    "speed":   [n times [m times DECIMAL]],
    "locLat":  [n times [m times DECIMAL]],
    "locLon":  [n times [m times DECIMAL]]
}