Essa semana eu iniciei uma série de posts sobre o Parse, serviço de cloud do Facebook. Neste segundo post vou abordar como realizar consultas em nossa base. Caso não conheça o Parse veja o post de introdução: https://www.fellyph.com.br/blog/tutoriais/parse/.
No post anterior abordamos um pouco sobre consultas, primeiro resgatamos todos os valores de uma base com a função “find”, em seguida resgatamos um único item com a função “get”. Criei um cadastro de carros com as propriedades: modelo, ano e valor para cadastrar os dados utilizei os mesmo padrão do post anterior:
INDEX.HTML
Todo List App Parse
CAR LIST
Carregando...
%MINIFYHTML308e0755fcbcd879cb5fe69fd7214ac96%%MINIFYHTML308e0755fcbcd879cb5fe69fd7214ac97%%MINIFYHTML308e0755fcbcd879cb5fe69fd7214ac98%
APP.JS
Parse.initialize("YOUR_APP_ID", "YOUR_JS_KEY");
var app = {
Cars:null,
listOfCars:null,
inputModel:null,
inputValue:null,
inputYear:null,
//função para inicializar nosso app
initApp: function(){
app.Cars = Parse.Object.extend("Cars");
//showAllCars busca tarefas já cadastradas em nosso app
app.showAllCars();
//Adicionamos um lister para o nosso form
document.getElementById("form-car").addEventListener("submit",app.onSubmit);
//Fazemos um cache dos itens que acessamos mais de uma vez em nosso app
app.listOfCars = document.getElementById("list-cars");
app.inputModel = document.getElementById("model-car");
app.inputYear = document.getElementById("year-car");
app.inputValue = document.getElementById("value-car")
},
//função responsável por consultar os dados na nuvem
showAllCars: function(){
//chamamos a função Query do Parse parar varer a nossa base
var query = new Parse.Query("Cars");
//a função trata a query para sucesso ou erro de nossa consulta
query.find({
success:function(results){
//esse bloco será executado se ocorrer tudo bem com nossa query
app.updateOutputList(results)
},
error:function(error){
//tratamento para caso de erro
console.log("error",error)
}
})
},
updateOutputList: function(results){
var markupList = "";
if(results.length < 0){
markupList = "Modelo Ano Valor ";
markupList += ""+ results[id].attributes.model +" ";
markupList += ""+ results[id].attributes.year +" ";
markupList += ""+ results[id].attributes.value +" ";
markupList +=
" ";
}
}else{
markupList = "Nenhum Resultado Encontrado Cadastrei algumas informações na minha base para realizar a consulta:
Agora vamos dar uma olhada em algumas funções que podemos trabalhar com a classe Query. A primeira delas será a função equalTo:
equalTo
searchByModel: function (modelCar) {
/*
Meu App Já instaciou a Class Cars
caso contrario teria que instancia-la:
var Cars = Parse.Object.extend("Cars");
*/
var query = new Parse.Query(app.Cars);
query.equalTo("model", modelCar);
query.find({
success: function (results) {
app.updateOutputList(results)
},
error: function (error) {
alert("Error: " + error.code + " " + error.message);
}
});
}
Na função equealTo passamos dois parâmetros, o primeiro o nome da propriedade e a segunda o valor que você deseja comparar, detalhe sobre a função que sua consulta é case sensitive.
notEqualTo
query.notEqualTo("modelo", "Uno");
A função notEqualTo é o inverso da função equalsTo ela retorna todos os valores diferentes do valor repassado. Também é possível realizar queries compostas:
query.notEqualTo("model", "Uno");
query.equalTo("year",2000);
Na consulta acima o modelo do carro tem que ser diferente de "Uno" E o ano tem que ser igual a 2000, pensando em SQL seria um operador AND as duas condições tem que ser verdadeiras.
greaterThan & lessThan
Com essa consulta podemos receber valores maiores do que o valor informado para a função, por exemplo caso queira receber os carros com o ano superior a 2000 utilizamos a seguinte função:
query.greaterThan("year",2000);O função oposta seria lessThan ela retorna apenas os valores menores:
query.lessThan("year",2000);limit
Por padrão as consultas tem um limite 100 resultados por query, podemos modificar esse resultado de 1 até 1000. Para aplicar esse limite utilizamos a seguinte função:
query.limit(10);
first
Em nossa query podemos resgatar apenas o primeiro resultado isso é possível com a função first:
query.greaterThan("year",2000);
query.first({
success: function(object) {
// caso sucesso retorna o primeiro resultado
},
error: function(error) {
alert("Error: " + error.code + " " + error.message);
}
});skip
Podemos definir o limite de resultados e também podemos definir o índice inicial do resultado com a função skip, com essas duas funções podemos criar um esquema de paginação.
query.skip(10);
ascending & descending
Além de criar filtros, busca por valores, limitar a busca... criar paginação... Pensa que acabou? Não ainda podemos ordenar nossa consulta(por ascendente ou descendente):
//Instanciamos a query sobre "Cars"
var query = new Parse.Query(app.Cars);
//resgatamos os valores maiores que 2000
query.greaterThan("year",2000);
//definimos a ordenação
query.ascending("year");
query.find({
success: function (results) {
app.updateOutputList(results)
},
error: function (error) {
alert("Error: " + error.code + " " + error.message);
}
});
O resultado será o seguinte:
Outra opção com listagem de valores maiores para menores:
query.descending("year");
containedIn & notContainedIn
Caso queiramos realizar a consulta com mais de um modelo de carro, por exemplo, podemos utilizar a função containedIn ela espera um Array como parâmetro:
query.containedIn("model",["Uno", "Civic", "Gol"]);
O inverso da função containedIn seguindo o padrão é a função notContainedIn, ela retorna o resultado das palavras diferente das que constam no Array:
query.notContainedIn("model",["Uno", "Civic", "Gol"]);
exists & doesNotExist
O Parse permite criar objetos com propriedades vazias ou modificar os objetos depois de criados adicionando novos atributos, assim os objetos antigos ficam sem a informação gravada, para isso podemos utilizar a função exists para verificar se o objeto possui informação gravada na propriedade requisitada.
Vamos a um exemplo:
query.exists("year");No código acima verificamos os itens que tem a propriedade year cadastrada, o inverso seria:
query.doesNotexists("year"); matchesKeyInQuery & doesNotMatchKeyInQuery
A matchKeyInQuery serve para comparar dois objetos de classes diferentes que possuem duas propriedades iguais, por exemplo:
var Team = Parse.Object.extend("Team");
var teamQuery = new Parse.Query(Team);
var userQuery = new Parse.Query(Parse.User);
userQuery.matchesKeyInQuery("hometown", "city", teamQuery);
userQuery.find({
success: function(results) {
// results has the list of users with a hometown team with a winning record
}
});
No código acima temos duas class Team e Users esta classe deriva do Parse Porque é uma classe especial, vamos falar dela em um próximo post. Mas voltando a query, comparamos duas propriedades "hometown" e "city" presentes na classe User e Team quando eles forem idênticos apareceram em nossa consulta.
select
Caso queira consultar propriedades específicas com a função select passamos as keys das propriedades que queremos:
query.greaterThan("year",2000);
query.select("model", "year");
No caso da imagem acima utilizei a mesma função de exibir os resultados, por conta de utilizar o select a coluna valor veio "undefined" porque eu só escolhi duas propriedades "model" e "year".
startsWith
Na função equalsTo ele retorna valores estritamente idênticos, com a função podemos resgatar valores que iniciam com a String repassada, ela tem um funcionamento parecido com o operador LIKE do MySQL. Esta consulta também é case sensitive.
query.startsWith("model","F")
count
A função count conta "Dan", isso mesmo ela serve para contar o número de itens do resultado ela funciona da seguinte forma:
query.startsWith("model","F")
query.count({
success: function(count) {
// The count request succeeded. Show the count
alert("Carros que começam com F: " + count);
},
error: function(error) {
// The request failed
}
});
No exemplo anterior eu realizei um filtro sobre a query e a função count tem o tratamento similar a função find, falando nela podemos aplicar as duas em conjunto sem problemas. Temos outras queries aplicadas em objetos relacionais mas isso vamos abordar em um futuro. Até o próximo post Pessoal.