Hay un lenguaje de consulta para JSON?

StackOverflow https://stackoverflow.com/questions/777455

Pregunta

Hay una (aproximadamente) de SQL o XQuery-como lenguaje para consultar JSON?

Estoy pensando muy pequeños conjuntos de datos que se asignan bien a JSON donde sería agradable fácilmente responder a preguntas tales como "¿cuáles son todos los valores de X donde Y > 3" o a hacer lo de siempre SUMA / contador de operaciones de tipo.

Completamente inventadas ejemplo, algo como esto:

[{"x": 2, "y": 0}}, {"x": 3, "y": 1}, {"x": 4, "y": 1}]

SUM(X) WHERE Y > 0     (would equate to 7)
LIST(X) WHERE Y > 0    (would equate to [3,4])

Estoy pensando que esto iba a funcionar, tanto del lado cliente y del lado del servidor con los resultados que se convierte en el idioma apropiado específicos de la estructura de los datos (o tal vez mantiene como JSON)

Una rápida búsqueda en Google sugiere que las personas han pensado e implementado un par de cosas (JAQL), pero no parece un uso estándar o un conjunto de bibliotecas ha surgido todavía.Mientras que cada función es bastante trivial para implementar en su propia, si alguien ya lo ha hecho la derecha no quiero volver a inventar la rueda.

Alguna sugerencia?

Editar:De hecho, esto puede ser una mala idea o JSON puede ser demasiado genérico de un formato para lo que estoy pensando..La razón para querer un lenguaje de consulta en lugar de sólo hacer el resumen/etc funciona directamente como necesario es que espero que para construir las consultas dinámicamente a partir de la entrada de usuario.Un poco como el argumento de que "no necesitamos SQL, podemos escribir las funciones que necesitamos".Finalmente, que la obtiene de la mano o se termina de escribir su propia versión de SQL como usted lo empuja más y más.(Vale, ya sé que es un poco tonto argumento, pero usted consigue la idea..)

¿Fue útil?

Solución

Por supuesto, ¿qué hay de:

Todos parecen ser un poco trabajo en progreso, pero trabajar en algún grado. También son similares a XPath y XQuery conceptualmente; a pesar de XML y JSON tienen diferentes modelos conceptuales (jerárquicos vs objeto / estructura).

editar Sep-2015: En realidad no es ahora JSON puntero estándar que permite el recorrido muy simple y eficiente del contenido JSON. No sólo se especifica formalmente, sino también con el apoyo de muchas bibliotecas JSON. Así que yo diría que es útil estándar real actual, aunque debido a su expresividad limitada que puede o no puede ser considerada lenguaje de consulta en sí misma.

Otros consejos

Me gustaría recomendar mi proyecto estoy trabajando en llamada jLinq . Estoy en busca de retroalimentación así que estaría interesado en escuchar lo que piensa.

Si le permite escribir consultas de forma similar a como lo haría en LINQ ... 

var results = jLinq.from(records.users)

    //you can join records
    .join(records.locations, "location", "locationId", "id")

    //write queries on the data
    .startsWith("firstname", "j")
    .or("k") //automatically remembers field and command names

    //even query joined items
    .equals("location.state", "TX")

    //and even do custom selections
    .select(function(rec) {
        return {
            fullname : rec.firstname + " " + rec.lastname,
            city : rec.location.city,
            ageInTenYears : (rec.age + 10)
        };
    });

Es completamente extensible también!

La documentación está todavía en curso, pero todavía se puede probar en línea.

Actualización: XQuery 3.1 puede consultar XML o JSON - o ambos juntos. Y XPath 3.1 puede también.

La lista está creciendo:

jmespath funciona realmente muy fácil y bien, http://jmespath.org/ Está siendo utilizado por Amazon en la interfaz de línea de comandos de AWS, así que es tiene que ser bastante estable.

El built-in array.filter() método hace que la mayoría de estos llamados javascript consulta de las bibliotecas obsoletas

Usted puede poner muchas condiciones dentro del delegado como se puede imaginar:una simple comparación, startsWith, etc.Yo no he probado pero que probablemente podría anidar filtros de consulta de las colecciones internas.

ObjectPath es simple y ligthweigth lenguaje de consulta de documentos JSON de estructura compleja o desconocida. Es similar a XPath o JSONPath, pero mucho más potente gracias a los cálculos aritméticos incorporados, mecanismos de comparación y funciones incorporadas.

Ejemplo

versión Python es maduro y utilizado en la producción. JS está todavía en fase beta.

Es probable que en un futuro próximo vamos a ofrecer una versión de pleno derecho Javascript. También queremos desarrollar aún más, de modo que pudiera servir como una alternativa más sencilla a las preguntas Mongo.

jq es un JHIJO query idioma, destinados principalmente para la línea de comandos, pero con los enlaces a una amplia gama de lenguajes de programación (Java, node.js, php, ...) y disponible en el navegador a través de jq-web.

Aquí están algunas ilustraciones basadas en la pregunta original, que dio este JSON como un ejemplo:

 [{"x": 2, "y": 0}}, {"x": 3, "y": 1}, {"x": 4, "y": 1}]

SUM(X), DONDE Y > 0 (equivaldría a 7)

map(select(.y > 0)) | add

LISTA(X), DONDE Y > 0 (se podría equiparar a [3,4])

map(.y > 0)

jq sintaxis se extiende la sintaxis JSON

Cada JSON expresión es válida jq expresión, y expresiones tales como [1, (1+1)] y {"a":(1+1)}` ilustrar cómo jq extiende la sintaxis JSON.

Un ejemplo más útil es el jq expresión:

{a,b}

que, dado el valor JSON {"a":1, "b":2, "c": 3}, evalúa a {"a":1, "b":2}.

Si está utilizando .NET continuación, Json.NET apoya sobre LINQ consulta la parte superior de JSON. Este posterior tiene algunos ejemplos. Es compatible con el filtrado, la cartografía, agrupación, etc.

Otra manera de mirar esto sería usar mongodb Usted puede almacenar su JSON en mongo y entonces se le pregunta que a través de la sintaxis de la consulta mongodb.

OK, este post es un poco viejo, pero ... si usted quiere hacer la consulta SQL-como en JSON nativo (o los objetos JS) en objetos JS, echar un vistazo a https://github.com/deitch/searchjs

Es a la vez un lenguaje jsql escrito enteramente en JSON, y una implementación de referencia. Se puede decir, "Quiero encontrar todos los objetos en una matriz que tiene nombre ===" John" && === años 25 como: 

{name:"John",age:25,_join:"AND"}

trabajos la implementación de referencia searchjs en el navegador, así como un paquete como NPM nodo 

npm install searchjs

También puede hacer cosas como complejo se une y la negación (NOT). Se hace caso omiso de forma nativa caso.

Aún no se haga la suma o la cuenta, pero es probable que sea más fácil hacer los que están fuera.

Aquí hay algunas bibliotecas de javascript simples que también hará el truco:

MongoDB conductores , esta es la forma en que iba a funcionar (en la consola mongo, no existen para un idioma de su elección). 

db.collection.insert({"x": 2, "y": 0}); // notice the ':' instead of ','
db.collection.insert({"x": 3, "y": 1});
db.collection.insert({"x": 4, "y": 1});

db.collection.aggregate([{$match: {"y": {$gt: 0}}}, 
                         {$group: {_id: "sum", sum: {$sum: "$x"}}}]);
db.collection.aggregate([{$match: {"y": {$gt: 0}}}, 
                         {$group: {_id: "list", list: {$push: "$x"}}}]);

Los tres primeros comandos de insertar los datos en su colección. (Sólo iniciar el servidor mongod y conectar con el cliente mongo.)

Los dos siguientes procesar los datos. $match filtros, $group aplica la sum y list, respectivamente.

SpahQL es el más prometedor y bien pensado de ellos, por lo que yo puedo decir. Recomiendo encarecidamente el registro.


Acabo de terminar una versión liberable de un clientside JS-lib (defiant.js) que hace lo que está buscando. Con defiant.js, se puede consultar una estructura JSON con las expresiones XPath que está familiarizado (no hay nuevas expresiones sintaxis que en JSONPath).

Ejemplo de cómo funciona (ver en el navegador aquí http: // defiantjs .com / defiant.js / demo / sum.avg.htm ): 

var data = [
       { "x": 2, "y": 0 },
       { "x": 3, "y": 1 },
       { "x": 4, "y": 1 },
       { "x": 2, "y": 1 }
    ],
    res = JSON.search( data, '//*[ y > 0 ]' );

console.log( res.sum('x') );
// 9
console.log( res.avg('x') );
// 3
console.log( res.min('x') );
// 2
console.log( res.max('x') );
// 4

Como se puede ver, DefiantJS extiende el objeto JSON global con una función de búsqueda y la matriz devuelta se entrega con funciones de agregado. DefiantJS contiene algunas otras funcionalidades pero los que están fuera del alcance de este tema. Anywho, se puede probar la lib con un clientside XPath Evaluador. Creo que las personas que no están familiarizadas con XPath se encuentra este evaluador útil.
http://defiantjs.com/#xpath_evaluator

Más información sobre defiant.js
http://defiantjs.com/
https://github.com/hbi99/defiant.js

Espero que les sea útil ... Saludos

  1. Google tiene un proyecto llamado Lovefield ; acaba de enterarse de ello, y se ve interesante, aunque es más complicado que simplemente dejar caer en el guión bajo o lodash.

    https://github.com/google/lovefield

  

Lovefield es un motor de consulta relacional escrito en JavaScript puro. Eso   también proporciona ayuda con la persistencia de datos en el lado del navegador, por ejemplo,   el uso de datos indexada para almacenar datos localmente. Proporciona sintaxis similar a SQL y   que funciona a través del navegador (en la actualidad el apoyo a Chrome 37+, 31+ Firefox, IE   10+, y Safari 5.1 + ...

  1. Otro reciente entrada interesante en este espacio llamado jinqJs .

    http://www.jinqjs.com/

    , parece prometedor, y la parece estar bien escrito documento API . 

function isChild(row) {
  return (row.Age < 18 ? 'Yes' : 'No');
}

var people = [
  {Name: 'Jane', Age: 20, Location: 'Smithtown'},
  {Name: 'Ken', Age: 57, Location: 'Islip'},
  {Name: 'Tom', Age: 10, Location: 'Islip'}
];

var result = new jinqJs()
  .from(people)
  .orderBy('Age')
  .select([{field: 'Name'}, 
     {field: 'Age', text: 'Your Age'}, 
     {text: 'Is Child', value: isChild}]);
  

jinqJs es un pequeño, simple, ligero y extensible javaScript   biblioteca que no tiene dependencias. jinqJs ofrece una forma sencilla de   realizar consultas SQL como las matrices de JavaScript, colecciones y Web   los servicios que devuelven una respuesta JSON. jinqJs es similar a la de Microsoft   expresión lambda para .Net, y proporciona capacidades similares a   colecciones de consulta mediante un SQL como la sintaxis y la funcionalidad predicado.   El propósito de jinqJs es proporcionar un SQL como la experiencia de los programadores   familiarizado con las consultas LINQ.

Voy a segundo la idea de usar sólo su propio javascript, pero algo un poco más sofisticado lo podría hacer en dojo datos . no han utilizado, pero parece que le da más o menos el tipo de interfaz de consulta que busca.

El procesamiento de grandes datos actuales objetivos de ejecución Jaql usando un cluster Hadoop, lo que podría ser más de lo necesario. Sin embargo, se ejecuta fácilmente sin un cluster Hadoop (pero todavía requiere el código de Hadoop y sus dependencias para ser compilados, que se incluyen en su mayoría). Una pequeña aplicación de Jaql que podrían ser insertados en JavaScript y un navegador sería una gran adición al proyecto.

Sus ejemplos anteriores son fácilmente escritos en jaql: 

$data = [{"x": 2, "y": 0}, {"x": 3, "y": 1}, {"x": 4, "y": 1}];

$data -> filter $.y > 0 -> transform $.x -> sum(); // 7

$data -> filter $.y > 0 -> transform $.x; // [3,4]

Por supuesto, hay mucho más también. Por ejemplo: 

// Compute multiple aggregates and change nesting structure:
$data -> group by $y = $.y into { $y, s:sum($[*].x), n:count($), xs:$[*].x}; 
    // [{ "y": 0, "s": 2, "n": 1, "xs": [2]   },
    //  { "y": 1, "s": 7, "n": 2, "xs": [3,4] }]

// Join multiple data sets:
$more = [{ "y": 0, "z": 5 }, { "y": 1, "z": 6 }];
join $data, $more where $data.y == $more.y into {$data, $more};
    // [{ "data": { "x": 2, "y": 0 }, "more": { "y": 0, "z": 5 }},
    //  { "data": { "x": 3, "y": 1 }, "more": { "y": 1, "z": 6 }},
    //  { "data": { "x": 4, "y": 1 }, "more": { "y": 1, "z": 6 }}]

Jaql se puede descargar / discute en http://code.google.com/p/jaql /

También puede utilizar Underscore.js que es básicamente una biblioteca de navaja suiza para manipular colecciones. Usando _.filter , _.pluck , _.reduce que puede hacer consultas SQL. 

var data = [{"x": 2, "y": 0}, {"x": 3, "y": 1}, {"x": 4, "y": 1}];

var posData = _.filter(data, function(elt) { return elt.y > 0; });
// [{"x": 3, "y": 1}, {"x": 4, "y": 1}]

var values = _.pluck(posData, "x");
// [3, 4]

var sum = _.reduce(values, function(a, b) { return a+b; });
// 7

Underscore.js funciona tanto del lado del cliente y del lado del servidor y es una notable biblioteca.

También puede utilizar Lo-Dash, que es un tenedor de Underscore.js con mejores actuaciones.

Siempre que sea posible me gustaría cambiar la totalidad de la consulta al backend en el servidor (en la base de datos SQL u otro tipo de base de datos nativa). La razón es que va a ser más rápido y más optimizado para hacer la consulta.

Sé que JSON puede ser independiente y no puede ser de +/- por tener un lenguaje de consulta, pero no puedo ver la ventaja si está recuperando los datos desde el servidor a un navegador, ya que la mayoría de los casos de uso de JSON. Consulta y filtro en el backend para obtener un dato tan pequeño que se necesita.

Si por cualquier razón necesita consultar en el front-end (en su mayoría en un navegador) entonces sugeriría simplemente usando array.filter (¿por qué inventar otra cosa?).

Una vez dicho lo que creo que sería más útil es una API de transformación para JSON ... que son más útiles ya que una vez que tenga los datos es posible que desee para mostrarla en un número de maneras. Sin embargo, una vez más, se puede hacer mucho de esto en el servidor (que puede ser mucho más fácil a escala) que en el cliente - Si está utilizando el servidor <->. Modelo cliente

Sólo mi 2 peniques por valor!

https://github.com/niclasko/Cypher.js (nota : soy el autor)

Es una dependencia cero implementación de JavaScript del lenguaje de consulta de base de datos gráfica Cypher, junto con una base de datos gráfica. Se ejecuta en el navegador (probado con Firefox, Chrome, IE).

En lo pertinente a la pregunta. Se puede utilizar para consultar los puntos finales JSON: 

load json from "http://url/endpoint" as l return l limit 10

Aquí está un ejemplo de la consulta de un documento JSON compleja y la realización de análisis en él:

Cypher.js JSON ejemplo de consulta

Se puede usar linq.js .

Esto permite utilizar agregaciones y selectings de un conjunto de datos de los objetos, como datos de otras estructuras. 

var data = [{ x: 2, y: 0 }, { x: 3, y: 1 }, { x: 4, y: 1 }];

// SUM(X) WHERE Y > 0     -> 7
console.log(Enumerable.From(data).Where("$.y > 0").Sum("$.x"));

// LIST(X) WHERE Y > 0    -> [3, 4]
console.log(Enumerable.From(data).Where("$.y > 0").Select("$.x").ToArray());
<script src="https://cdnjs.cloudflare.com/ajax/libs/linq.js/2.2.0.2/linq.js"></script>

Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top