Comme mentionné dans notre article de blog sur le support OData dans MendixOData est également utile si vous souhaitez accéder aux données de vos applications à partir de R or RStudioDans cet article de blog, je vais vous montrer comment procéder. Je donnerai également quelques exemples simples d'utilisation de R destinés aux personnes qui ne le connaissent pas.
Qu'est-ce que R ?
R est un langage de programmation d'analyse statistique open source très populaire utilisé par de nombreux data scientists. Vous pouvez télécharger une version open source gratuite, mais vous trouverez également la prise en charge de R dans de nombreux outils commerciaux, notamment Microsoft Revolution R, Tibco Spitfire, Pivotal, Oracle et Tableau. Ce qui est intéressant avec R, c'est qu'il existe un grand nombre de bibliothèques que vous pouvez utiliser. Les bibliothèques vont des algorithmes de manipulation de données aux graphiques, en passant par les rapports et l'apprentissage automatique.
Chargement d'OData dans R
Pour récupérer OData dans R, nous allons utiliser deux packages : httr et XMLLe premier package vous permet de lire des données à partir du Web, le second peut être utilisé pour analyser des documents XML.
Avec une petite fonction utilisant ces packages, vous pouvez récupérer une ressource OData et la transformer en données R.
dataset <- getODataResource(<url of the odata resource>,<username>,<password>)Avant de commencer, nous devons spécifier les bibliothèques dont nous avons besoin.
library('httr')
library('XML')
library('dplyr')
library('lubridate')La fonction getODataResource lit d'abord la ressource OData et analyse le document XML renvoyé à l'aide du package Httr. Ensuite, elle détermine les noms des attributs, récupère les valeurs et crée un cadre de données contenant les valeurs.
getODataResource <- function(resourcePath,domain,usr,pwd){
url <- paste(domain, resourcePath,sep="")
# get the OData resource
response <- GET(url,authenticate(usr,pwd))
# parse xml docucument
responseContent <- content(response,type="text/xml")
# determine the names of the attributes
xmlNames <- xpathSApply(responseContent,
'//ns:entry[1]//m:properties[1]/d:*',xmlName,
namespaces = c(ns = "https://www.w3.org/2005/Atom",
m="https://schemas.microsoft.com/ado/2007/08/dataservices/metadata",
d="https://schemas.microsoft.com/ado/2007/08/dataservices"))
# determine all attribute values
properties <- xpathSApply(responseContent,'//m:properties/d:*',xmlValue)
# cast the attributes values into a data frame
propertiesDF <-
as.data.frame(matrix(properties,ncol=length(xmlNames),byrow=TRUE))
# set the column names
names(propertiesDF) <- xmlNames
return(propertiesDF)
}Il s'agit de la fonctionnalité de base dont vous avez besoin pour récupérer Mendix Les ressources OData dans R. Dans sa forme actuelle, il ne gère pas les données imbriquées, par exemple les commandes avec des lignes de commande imbriquées dans les commandes. Il n'utilise pas non plus les informations de type de données incluses dans la ressource OData. Au lieu de cela, nous utiliserons certaines expressions R pour spécifier les types de données manuellement, comme illustré ci-dessous.
Exemple de cas d'utilisation
L'exemple Mendix L'application dispose de ressources pour les commandes, les clients et les adresses. Nous allons créer un aperçu du nombre de commandes par ville dans R.
Tout d’abord, nous allons définir comment se connecter aux ressources OData dans notre Mendix .
domain <- "https://localhost:8080/"
username <- "demo_reporter"
password <- "goSfcsDj00"[/bash]
The following will load all the objects in the customers and address entities into R data frames.
[bash]customers <- getODataResource("odata/Orders/Customers()",domain,username,password)
addresses <- getODataResource("odata/Orders/Address()",domain,username,password)Pour les commandes, nous nous intéressons uniquement aux commandes créées depuis le 1er janvier 2014. Nous pourrions filtrer par date de commande dans R, mais le spécifier sur l'URL de la ressource OData évite la surcharge liée à leur interrogation à partir de votre Mendix base de données et transportant toutes les données de la Mendix exécution vers R.
orders <- getODataResource(
"odata/Orders/Orders()/?$filter=OrderDate%20gt%20datetimeoffset'2014-01-01T00:00:00z'"
,domain,username,password)Les trames de données contiennent toutes les Mendix objets récupérés via des ressources OData. Les cinq premiers enregistrements de commandes ressemblent à ceci :
orders[1:5,c("OrderNumber","Order_Customer","OrderDate")]## OrderNumber Order_Customer OrderDate
## 1 1 2533274790395905 2015-01-18T10:32:00.000Z
## 2 2 2533274790395906 2014-01-30T07:01:00.000Z
## 3 3 2533274790395907 2014-04-16T13:15:00.000Z
## 4 4 2533274790395908 2014-09-19T07:52:00.000Z
## 5 5 2533274790395909 2015-01-14T07:28:00.000ZMaintenant que nous avons les données, nous devons nous assurer que nous utilisons les bons types de données. Mendix Les identifiants sont implémentés à l'aide de longs dans MendixDans R, vous pouvez utiliser des doubles.
customers$DateOfBirth <- ymd_hms(customers$DateOfBirth)
customers$ID <- as.double(customers$ID)
customers$Billing_Address <- as.double(customers$Billing_Address)
customers$Delivery_Address <- as.double(customers$Delivery_Address)
addresses$ID <- as.double(addresses$ID)
orders$ID <- as.double(orders$ID)
orders$Order_Customer <- as.double(orders$Order_Customer)
# for easy access, create separate columns with date and date time
orders$OrderDateTime <- ymd_hms(orders$OrderDate)
orders$OrderDate <- ymd(format(ymd_hms(orders$OrderDate),"%Y-%m-%d"))Ensuite, nous utiliserons la bibliothèque dplyr pour manipuler les données reçues. Dplyr vous permet de filtrer les données, d'ajouter de nouvelles colonnes, de sélectionner certaines colonnes et d'ordonner les lignes, un peu comme vous le feriez avec SQL dans une base de données classique.
L'expression dplyr suivante joint les trames de données des clients, des adresses et des commandes.
customerOrders <- customers %>%
rename(CustomerID=ID) %>%
left_join(addresses, by=c("Delivery_Address"="ID")) %>%
select(CustomerID,Firstname,Lastname,City,Country) %>%
left_join(orders, by=c("CustomerID"="Order_Customer")) %>%
select(Firstname,Lastname,City,Country,OrderNumber)Les premières lignes de ce bloc de données ressemblent à ceci :
customerOrders[1:5,]## Firstname Lastname City Country OrderNumber
## 1 Ivan Freeman New Orleans US 1
## 2 Ivan Freeman New Orleans US 499
## 3 Anthony Robinson Brighton US 2
## 4 Anthony Robinson Brighton US 500
## 5 Kaden Griffith Bridgeport US 3Nous pouvons maintenant compter le nombre de commandes par ville comme suit :
cityOrderCount <- customerOrders %>%
group_by(City) %>%
summarize(OrderCount = n()) %>%
arrange(desc(OrderCount))Le résultat:
cityOrderCount[1:5,]## Source: local data frame [5 x 2]
##
## City OrderCount
## 1 New York 28
## 2 Philadelphia 16
## 3 Chicago 15
## 4 Miami 12
## 5 Baltimore 10Créer des graphiques
L'exemple suivant utilise ggplot2 pour créer des graphiques. Vous pouvez également utiliser d'autres bibliothèques pour la création de graphiques, mais ggplot2 est l'une des plus populaires.
Nous commencerons par un graphique à barres simple représentant le nombre de commandes par mois.
library('ggplot2')
# Determine first day of month for every order, count number of orders per month
orderCount <- orders %>%
# Determine date of first day of the month, so ggplot understands it's a date
mutate(OrderMonth = ymd(format(OrderDate,"%Y-%m-01"))) %>%
group_by(OrderMonth) %>%
summarize(noOfOrders = n())
# generate barchart to display number of orders per month
ggplot() +
geom_bar(data=orderCount,aes(x=OrderMonth,y=noOfOrders), stat="identity") +
xlab("Month") +
ylab("Number of orders") +
ggtitle("Orders per month")
Ensuite, nous souhaitons voir quand les commandes sont passées au cours de la semaine. Tout d'abord, nous avons besoin de l'ensemble de données contenant le jour de la semaine et l'heure de la journée pour chaque commande.
ordersPerWeekHour <- orders %>%
mutate(DayOfWeek = wday(OrderDate)) %>%
mutate(HourOfDay = hour(OrderDateTime)) %>%
group_by(DayOfWeek,HourOfDay) %>%
summarize(noOfOrders = n())Maintenant, pour le graphique réel, nous pouvons utiliser rabot à tuiles pour afficher le nombre de commandes pour chaque heure de chaque jour. Nous mettons le jour sur l'axe des x, l'heure sur l'axe des y et utilisons le nombre de commandes pour déterminer la couleur affichée.
ggplot(ordersPerWeekHour, aes(x=DayOfWeek,y=HourOfDay))+
geom_tile(aes(fill=noOfOrders)) +
scale_fill_gradient(low="green", high="red") +
scale_x_continuous(breaks=1:7,labels=c("Sun","Mon","Tues","Wed","Thurs","Fri","Sat")) +
scale_y_continuous(breaks=0:24) +
labs(x="Day", y="Hour")
Vous pouvez désormais facilement constater que la plupart des commandes sont passées entre 16h00 et 22h00, réparties uniformément sur tous les jours de la semaine.
Générer des rapports à l'aide de R
R dispose de fonctionnalités de reporting intéressantes. Réduction, vous pouvez générer du HTML, du Word, du PDF ou même des diapositives directement à partir d'un rapport R.
Ce billet de blog a en fait été rédigé en utilisant rmarkdown, générant un document MS-Word. Pour mettre à jour le document Word avec les dernières données de mon Mendix application, je dois juste réexécuter le script rmarkdown.
La façon la plus simple de travailler avec Rmarkdown est d'utiliser les fonctions intégrées de RStudio. Vous pouvez également générer un rapport Rmarkdown sans RStudio avec du code R :
library(knitr) # required for knitting from rmd to md
require(rmarkdown) # required for md to html
setwd('<location of your rmarkdown file>')
render("<name of the rmarkdown script>", "all")Conclusion
La fonctionnalité OData dans Mendix ouvre de nombreuses possibilités pour Mendix utilisateurs. R est un outil puissant pour l'analyse statistique et la création de rapports de données. Utilisation d'OData Mendix l'utilisateur peut désormais bénéficier facilement de toutes ces facilités.