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...
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 Modelo Ano Valor ";
//os resultados vem em um array de objetos
//varremos o nosso array e montamos um markup
for(var id in results){
markupList += "";
markupList += ""+ results[id].attributes.model +" ";
markupList += ""+ results[id].attributes.year +" ";
markupList += ""+ results[id].attributes.value +" ";
markupList +=
" ";
}
}else{
markupList = "Nenhum Resultado Encontrado ";
}
app.listOfCars.innerHTML = markupList;
},
//função para fazer o tratamento quando o usuário envia os dados do form
onSubmit: function(e){
var car = {};
car.model = app.inputModel.value;
//utilizamos parseInt para converter o nosso value que é uma string e inteiro
car.year = parseInt(app.inputYear.value);
car.value = parseInt(app.inputValue.value);
//passamos o nosso objeto para ser salvo na cloud
app.saveCar(car);
// utiliza o preventDefault para evitar do form realizar o reload da página
e.preventDefault();
},
//função específica para salvar as cars na nuvem
saveCar: function (car){
var carCloud = new app.Cars();
carCloud.save(car).then(function(object) {
console.log("Carro salvo com sucesso!");
//após a informação salva limpamos os dados dos inputs e atualizamos a lista
app.showAllCars();
app.inputModel.value =
app.inputYear.value =
app.inputValue.value = "";
});
}
}
window.addEventListener("load", app.initApp)
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.