Garinpando no MongoDB sem picareta e com elegância

Globalcode – Open4education
Trilha – BigData
Caliel Costa
Nerd, ouvinte de blues, pesquisador, esportista e fotógrafo amador, desenvolvedor e projetista de soluções em TI. Software
Designer no Superplayer.
Gabriel Ladeira
Sou estudante de Ciências da Computação na PUCRS. Atuo como desenvolvedor a cerca de seis anos, tendo contato com
diferentes tecnologias. Atualmente integro a equipe do Superplayer, como backend developer, vivenciando altas aventuras
com Mongodb :)

Agenda
• Geolocation
• Aggregation Pipelines
• MapReduce
• Single Purpose Aggregation Operations

Superplayer é um serviço de recomendação musical focado em melhorar
todos os momentos da vida das pessoas através da trilha sonora
perfeita.
Startup brasileira
Criado em 2012

Web, Android, iOS, Windows Phone, ...

+ 10.000.000
USUÁRIOS ÚNICOS
ACUMULADOS

+ 1.400.000
USUÁRIOS ÚNICOS POR MÊS

TOP
600SITES MAIS
ACESSADOS
DO BRASIL.
Alexa – Traffic Rank

Geolocation
Na versão 2.4 (em 2013) foi introduzido o suporte a geometrias GeoJSON,
podendo ser usadas em data e consultas.

Planeta Terra

Planeta Terra
Degrees, Minutes, Seconds to/from Decimal Degrees
Cidade Latitude Longitude
Porto Alegre -30.03128
30° 1' 52.6074" Sul
-51.2125487
51° 12' 45.1764" Oeste
São Paulo -23.598877
23° 35' 55.9572" Sul
-46.6749596
46° 40' 29.8554" Oeste
Londres 51.4994438
51° 29' 57.9978" Norte
0
0° 0' 0"
Hong Kong 22.3576782
22° 21' 27.6402" Norte
114.2196956
114° 13' 10.905" Leste

GeoJSON
type coordinates
Point deve ser uma posição simples
MultiPoint deve ser um array de posição
LineString deve ser um array de 2 ou mais posições
MultiLineString deve ser um array de array de LineString
Polygon deve ser um LinearRing, ou seja um LineString com 4 ou mais pontos,
onde o primeiro e o último são posições equivalentes
MultiPolygon deve ser um array de array de Polygon

GeoJSON - Point
{
"type": "Point",
"coordinates": [100.0, 0.0],
}

GeoJSON - LineString
{
"type": "LineString",
"coordinates": [
[100.0, 0.0],
[101.0, 1.0]
],
}

GeoJSON - Polygon
{
"type": "Polygon",
"coordinates": [
[
[100.0, 0.0], [101.0, 0.0],
[101.0, 1.0], [100.0, 1.0],
[100.0, 0.0]
]
],
}

GeoJSON - MultiPoint
{
"type": "MultiPoint",
"coordinates": [
[100.0, 0.0],
[101.0, 1.0]
],
}

GeoJSON - MutiLineString
{
"type": "MultiLineString",
"coordinates": [
[ [100.0, 0.0], [101.0, 1.0] ],
[ [102.0, 2.0], [103.0, 3.0] ]
]
}

GeoJSON - MultiPolygon
{
"type": "MultiPolygon",
"coordinates": [
[
[ [102.0, 2.0], [103.0, 2.0], [103.0, 3.0], [102.0, 3.0], [102.0, 2.0] ]
],
[
[ [100.0, 0.0], [101.0, 0.0], [101.0, 1.0], [100.0, 1.0], [100.0, 0.0] ],
[ [100.2, 0.2], [100.8, 0.2], [100.8, 0.8], [100.2, 0.8], [100.2, 0.2] ]
]
]
}

Brazil, seus 27 estados e
respectivas capitais

GeoJSON - Brasil
{
"_id" : ObjectId("54f4bd437da3100f4454e812"),
"level" : "Country",
"name" : "Brasil (BR)",
"loc" : {
"type" : "Polygon",
"coordinates" : [
[
[ -44.69501, -1.817778 ],
… 336 ...
[-44.69501, -1.817778 ]
]
]
}
}

Longitude e Latitude Vs
Latitude e Longitude
{
"loc" : {
"type" : "Polygon",
"coordinates" : [
[
[ -46.53766020909132, -23.36963320731797 ],
..310..
[ -46.53766020909132, -23.36963320731797 ]
]
]
}
}
Cidade Latitude Longitude
São Paulo -23.598877
-23° 35' 55.9572" Sul
-46.6749596
-46° 40' 29.8554" Oeste

Longitude e Latitude Vs
Latitude e Longitude
“All documents must store location data in the same order. If
you use latitude and longitude as your coordinate system,
always store longitude first. MongoDB’s 2d spherical index
operators only recognize [longitude, latitude] ordering.”

Indexando GeoJSON
Tipo Uso
2dsphere Suporta consultas que calculem geometrias em uma esfera tipo a Terra.
2d Gera um geohash de acordo com o valor das coordenadas
haystack Este índice é um tipo especial de índice otimizado para retornar resultados
sobre areas pequenas

Indexando GeoJSON
db.locations.createIndex({
"loc" : "2dsphere"
}, {
"name" : "loc_"
})
• Índice esparso
• Não pode ser usado como chave de sharding

Consultas GeoJSON
Function Objetivo
$geoWithin Seleciona geometrias dentro dos limites de outra
$geoIntersects Seleciona geometrias em interção com outra
$near Retorna objetos na proximidade de um ponto
$nearSphere Retorna objetos na proximidade de um ponto na esfera

Onde estou?
query: {
"loc": {
$geoIntersects: {
$geometry: {
type: "Point" ,
coordinates: [-51.2125487, -30.03128]
}
}
}
}

Onde estou?
query: {
"loc": {
$geoIntersects: {
$geometry: {
type: "Point" ,
coordinates: [-51.2125487, -30.03128]
}
}
}
}
Result:
Brasil (BR)
Rio Grande do Sul (RS)
Porto Alegre

Cidades perto de Gramado/RS
{
"level": "City",
"loc": {
$near: {
$geometry: { type: "Point", coordinates: [-50.8586806,-29.3851463] }
$minDistance: 1,
$maxDistance: 300000,
},
}
}

Cidades perto de Gramado/RS
{
"level": "City",
"loc": {
$near: {
$geometry: { type: "Point", coordinates: [-50.8586806,-29.3851463] }
$minDistance: 1,
$maxDistance: 300000,
},
}
}
Result:
Porto Alegre
Florianópolis

$NearSphere
Funciona igual ao Near só que ao invés de se usar
distâncias em metros usa-se em radianos.

Buscando playlists
query: {
$or: [
{ "location": { $not: { $exists: true } } },
{
"location": {
$geoIntersects: { $geometry: { type: "Point" , coordinates: [-47.0562422, -22.9084404] } }
}
}
],
}
Result:
Acorda, Peão!, Acorda, Vagabundo!, Bebendo no Boteco, Dia de Chuva, Men’s Health, Trabalhando
numa Boa, Whiskynho com a Rapaziada, ...

Conteúdo Localizado
• Playlists
• Spots
• Patrocínios de Playlists
• Log de Playlists ouvidas
• Log de Músicas (Tracks) ouvidas

Aggregation
Operações que processão conjuntos de dados e retornam
dados calculados.
• Aggregation Pipelines
• Map-Reduce
• Single Purpose Aggregation Operations

Aggregation Pipelines
Framework para agregação de dados modelado sob os conceitos de
pipelines

Aggregation Pipelines
Comando:
db.collection.aggregate(pipeline, options)
pipeline: []
options: {
"explain": <bool>,
"allowDiskUse": {batchSize : <bool> },
"cursor": {batchSize : <int> },
}
Limitações:
Estágios com limite de 100MB de RAM
Até a versão 2.6 result set está limitado ao tamanho máximo de um documento BSON
(16MB)

Pipeline Stage Operators
Cada etapa transforma os documentos a medida que estes passam
através do pipeline.
Operadores:
$project
$match
$redact
$limit
$skip
$unwind
$group
$sort
$geoNear
$out

Pipeline Expressions Operators
Especificam transformações aplicadas aos documentos que passam
pelo pipeline.
Principais tipos de operadores:
• expreções boleanas - $and, $or;
• expreções aplicadas sob conjuntos - $setIntersection, $setUnion;
• expreções de comparação - $eq, $gt, $lt, $cmp;
• expreções aritiméticos - $add, $subtract;
• expreções sob strings - $substr, $toLower;
• expreções acumuladoras - $sum, $avg, $max, $min;
• expreções condicionais - $cond, $ifNull;
• expreções sob data/hora - $dayOfMonth, $month, $year, $hour, $minute.

Plays por gênero
db.plays.aggregate([
{ $match: { createdat: {
$gte: ISODate("2015-05-01T00:00:00.000Z"),
$lte: ISODate("2015-05-31T23:59:59.000Z")
}
}},
{ $group: { _id: "$account.gender", plays: { $sum: 1 }}}
])

Plays por regiões do Brasil
$gte: ISODate("2015-05-01T00:00:00.000Z"),
$lte: ISODate("2015-05-31T23:59:59.000Z")
}
}},
{ $unwind: "$geolocation.locations" },
{ $project: { _id: "$_id", loc: "$geolocation.locations" }},
{ $match: { "loc.level": { $eq: "state" } }},
{ $group: { _id: "$loc.name", plays: { $sum: 1 }}}
])

Playlists mais tocadas por
região do Brasil
$gte: ISODate("2015-05-01T00:00:00.000Z"),
$lte: ISODate("2015-05-31T23:59:59.000Z")
}
}},
{ $unwind: "$playlists" },
{ $unwind: "$geolocation.locations" },
{ $project: {
playlist: "$playlists.name",
location: "$geolocation.locations.name"
}},
{ $group: { _id: { playlist: "$playlist", location: "$location" }, plays: { $sum: 1 }}}
])

MapReduce
… é um modelo de programação desenhado para processar grandes volumes de
dados em paralelo, dividindo o trabalho em um conjunto de tarefas
independentes.

Map
Responsável por transformar cada documento em nenhum, 1 ou muitos
documentos.
O melhor é retornar um documento igual para todas as chaves.
Ela não pode acessar o banco em hipótese alguma

Reduce
Ela não pode acessar o banco em hipotese alguma (mesmo que seja para
leitura)
Vai receber um array de documentos com o mesmo key
Deve retornar um documento só
O Tipo de retorno deve identico ao tipo de entrada

Output Param
Pode ser um literal que será transformada em uma nova coleção
Ou pode indicar uma resposta inline

Qual dia da semana escuta-se mais
música?
db.plays.mapReduce(function() {
emit(dayOfWeek(this.createdat), 1);
}, function(key, values) {
return Array.sum(values);
}, {
out: { inline: 1}
});

Voodoo behind MapReduce
Map
Reduce Reduce Reduce
Reduce

Plays por regiões do Brasil
db.plays.mapReduce(function() {
this.geolocation.locations.forEach(function(location) {
if (location.level === "state") { emit(location.name, 1); }
});
}, function(key, values) {
return Array.sum(values);
}, {
query: {
"geolocation.locations": { $exists: true, },
"createdat": { $gte: ISODate("2015-05-01T00:00:00.000Z"), $lte:
ISODate("2015-05-31T23:59:59.000Z") }
},
out: { inline: 1},
});

Plays por Cidade e Sexo
var map = function() {
var key = null;
this.geolocation.locations.forEach
(function(location) {
if (location.level === "city")
key = location.name;
});
if (key == null) return;
var gender = this.account.gender;
this.playlists.forEach(function
(playlist) {
var result = {}; result[gender] =
1; emit(key, result);
});
};
var reduce = function(key, values) {
var result = { "F": 0, "M": 0, };
values.forEach(function(value) {
result["F"] += (value["F"] || 0);
result["M"] += (value["M"] || 0);
});
return result;
};
db.plays.mapReduce(map, reduce, {
query: { "account.gender": {
$exists: true }, "geolocation.
locations": { $exists: true } },
out: "playlist_by_genre",
});

Single Purpose Aggregation Operations
Operações bem específicas para agregação de dados disponíveis no Mongodb.
São elas:
Count
Retorna o número total de documentos que satisfaz a cosulta informada.
Distinct
Retorna os valores distintos de um campo sob os documentos resultantes da consulta.
Group
Agrupa os documentos de uma coleção de acordo com uma chavee específica.
Análago ao GROUP BY em SQL.

Count
Comando:
db.database.count()
db.database.count(query)
Exemplos:
db.plays.count()
db.plays.count({ createdat: {
$gte: ISODate("2015-09-25T00:00:00.000Z"),
$lte: ISODate("2015-09-25T23:59:59.000Z")
}})

Distinct
Comando:
db.database.distinct(“field”)
db.database.distinct(“field”, query)
Exemplos:
db.plays.distinct("account.gender")
db.plays.distinct("playlists.name", { createdat: {
$gte: ISODate("2015-09-25T00:00:00.000Z"),
$lte: ISODate("2015-09-25T23:59:59.000Z")
}
})

Group
Comando:
db.database.group({
key: <key>,
reduce: <reduce function>,
keyf: <key function>,
cond: <query>,
finalize: <finalize function>
})
Limitações:
Não é possível de utilizar em coleções com sharding.
Result set está limitado ao tamanho máximo de um documento BSON (16MB)

Número de plays por plataforma
db.plays.group( {
key: { 'consumer.name': 1 },
reduce: function(cur, result) { result.plays += 1 },
initial: { plays: 0 }
})

jointheband@superplayer.fm

Garinpando no MongoDB sem picareta e com elegância

Recommandé

Recommandé

Contenu connexe

Similaire à Garinpando no MongoDB sem picareta e com elegância

Similaire à Garinpando no MongoDB sem picareta e com elegância (20)

Plus de Caliel Costa

Plus de Caliel Costa (6)

Dernier

Dernier (6)

Garinpando no MongoDB sem picareta e com elegância