¿Cómo convertir JSON simple arbitrario a CSV usando jq?

Usando jq , ¿cómo se puede convertir a CSV la codificación JSON arbitraria de una matriz de objetos poco profundos?

Hay muchas preguntas y respuestas en este sitio que cubren modelos de datos específicos que codifican los campos, pero las respuestas a esta pregunta deberían funcionar dado cualquier JSON, con la única restricción de que es una matriz de objetos con propiedades escalares (no profundo / complejo / subobjetos, ya que aplanarlos es otra cuestión). El resultado debe contener una fila de encabezado con los nombres de los campos. Se dará preferencia a las respuestas que conserven el orden de campo del primer objeto, pero no es un requisito. Los resultados pueden incluir todas las celdas con comillas dobles, o solo incluir aquellas que requieran comillas (por ejemplo, 'a, b').

Ejemplos

1. Entrada:

   [
       {"code": "NSW", "name": "New South Wales", "level":"state", "country": "AU"},
       {"code": "AB", "name": "Alberta", "level":"province", "country": "CA"},
       {"code": "ABD", "name": "Aberdeenshire", "level":"council area", "country": "GB"},
       {"code": "AK", "name": "Alaska", "level":"state", "country": "US"}
   ]

   Salida posible:

   code,name,level,country
   NSW,New South Wales,state,AU
   AB,Alberta,province,CA
   ABD,Aberdeenshire,council area,GB
   AK,Alaska,state,US

   Salida posible:

   "code","name","level","country"
   "NSW","New South Wales","state","AU"
   "AB","Alberta","province","CA"
   "ABD","Aberdeenshire","council area","GB"
   "AK","Alaska","state","US"

2. Entrada:

   [
       {"name": "bang", "value": "!", "level": 0},
       {"name": "letters", "value": "a,b,c", "level": 0},
       {"name": "letters", "value": "x,y,z", "level": 1},
       {"name": "bang", "value": "\"!\"", "level": 1}
   ]

   Salida posible:

   name,value,level
   bang,!,0
   letters,"a,b,c",0
   letters,"x,y,z",1
   bang,"""!""",0

   Salida posible:

   "name","value","level"
   "bang","!","0"
   "letters","a,b,c","0"
   "letters","x,y,z","1"
   "bang","""!""","1"

Primero, obtenga una matriz que contenga todos los diferentes nombres de propiedad de objeto en su entrada de matriz de objeto. Esas serán las columnas de su CSV:

(map(keys) | add | unique) as $cols

Luego, para cada objeto en la entrada de la matriz de objetos, asigne los nombres de columna que obtuvo a las propiedades correspondientes en el objeto. Esas serán las filas de su CSV.

map(. as $row | $cols | map($row[.])) as $rows

Finalmente, coloque los nombres de las columnas antes de las filas, como un encabezado para el CSV, y pase el flujo de filas resultante al @csvfiltro.

$cols, $rows[] | @csv

Todos juntos ahora. Recuerde usar la -rbandera para obtener el resultado como una cadena sin formato:

jq -r '(map(keys) | add | unique) as $cols | map(. as $row | $cols | map($row[.])) as $rows | $cols, $rows[] | @csv'

El delgado

jq -r '(.[0] | keys_unsorted) as $keys | $keys, map([.[ $keys[] ]])[] | @csv'

o:

jq -r '(.[0] | keys_unsorted) as $keys | ([$keys] + map([.[ $keys[] ]])) [] | @csv'

Los detalles

Aparte

Describir los detalles es complicado porque jq está orientado a la transmisión, lo que significa que opera en una secuencia de datos JSON, en lugar de un valor único. El flujo JSON de entrada se convierte a algún tipo interno que se pasa a través de los filtros y luego se codifica en un flujo de salida al final del programa. El tipo interno no está modelado por JSON y no existe como un tipo con nombre. Se demuestra más fácilmente examinando la salida de un índice simple ( .[]) o el operador de coma (examinarlo directamente podría hacerse con un depurador, pero eso sería en términos de los tipos de datos internos de jq, en lugar de los tipos de datos conceptuales detrás de JSON) .

$ jq -c '. []' <<< '["a", "b"]'
"una"
"si"
$ jq -cn '"a", "b"'
"una"
"si"

Tenga en cuenta que la salida no es una matriz (lo que sería ["a", "b"]). La salida compacta (la -copción) muestra que cada elemento de la matriz (o argumento del ,filtro) se convierte en un objeto separado en la salida (cada uno está en una línea separada).

Una secuencia es como un JSON-seq , pero utiliza nuevas líneas en lugar de RS como separador de salida cuando se codifica. En consecuencia, este tipo interno se conoce con el término genérico "secuencia" en esta respuesta, con "flujo" reservado para la entrada y salida codificadas.

Construyendo el filtro

Las claves del primer objeto se pueden extraer con:

.[0] | keys_unsorted

Por lo general, las claves se mantendrán en su orden original, pero no se garantiza la conservación del orden exacto. En consecuencia, deberán usarse para indexar los objetos y obtener los valores en el mismo orden. Esto también evitará que los valores estén en las columnas incorrectas si algunos objetos tienen un orden de clave diferente.

Para generar las claves como la primera fila y hacerlas disponibles para indexación, se almacenan en una variable. La siguiente etapa de la canalización hace referencia a esta variable y usa el operador de coma para anteponer el encabezado al flujo de salida.

(.[0] | keys_unsorted) as $keys | $keys, ...

La expresión después de la coma es un poco complicada. El operador de índice de un objeto puede tomar una secuencia de cadenas (por ejemplo "name", "value"), devolviendo una secuencia de valores de propiedad para esas cadenas. $keyses una matriz, no una secuencia, por lo que []se aplica para convertirla en una secuencia,

$keys[]

que luego se puede pasar a .[]

.[ $keys[] ]

Esto también produce una secuencia, por lo que el constructor de la matriz se usa para convertirla en una matriz.

[.[ $keys[] ]]

Esta expresión debe aplicarse a un solo objeto. map()se usa para aplicarlo a todos los objetos de la matriz externa:

map([.[ $keys[] ]])

Por último, para esta etapa, esto se convierte en una secuencia para que cada elemento se convierta en una fila separada en la salida.

map([.[ $keys[] ]])[]

¿Por qué agrupar la secuencia en una matriz dentro de la mapúnica para desagregarla fuera? mapproduce una matriz; .[ $keys[] ]produce una secuencia. Aplicar mapa la secuencia de .[ $keys[] ]produciría una matriz de secuencias de valores, pero dado que las secuencias no son de tipo JSON, en su lugar obtiene una matriz plana que contiene todos los valores.

["NSW","AU","state","New South Wales","AB","CA","province","Alberta","ABD","GB","council area","Aberdeenshire","AK","US","state","Alaska"]

Los valores de cada objeto deben mantenerse separados, de modo que se conviertan en filas separadas en la salida final.

Finalmente, la secuencia se pasa a través del @csvformateador.

Alterno

Los elementos se pueden separar más tarde que temprano. En lugar de usar el operador de coma para obtener una secuencia (pasando una secuencia como el operando derecho), la secuencia de encabezado ( $keys) se puede envolver en una matriz y +usarse para agregar la matriz de valores. Esto aún debe convertirse en una secuencia antes de pasarlo @csv.

Creé una función que genera una matriz de objetos o matrices en csv con encabezados. Las columnas estarían en el orden de los encabezados.

def to_csv($headers):
    def _object_to_csv:
        ($headers | @csv),
        (.[] | [.[$headers[]]] | @csv);
    def _array_to_csv:
        ($headers | @csv),
        (.[][:$headers|length] | @csv);
    if .[0]|type == "object"
        then _object_to_csv
        else _array_to_csv
    end;

Entonces podrías usarlo así:

to_csv([ "code", "name", "level", "country" ])

El siguiente filtro es ligeramente diferente porque asegurará que cada valor se convierta en una cadena. (Nota: use jq 1.5+)

# For an array of many objects
jq -f filter.jq (file)

# For many objects (not within array)
jq -s -f filter.jq (file)

Filtrar: filter.jq

def tocsv($x):
    $x
    |(map(keys)
        |add
        |unique
        |sort
    ) as $cols
    |map(. as $row
        |$cols
        |map($row[.]|tostring)
    ) as $rows
    |$cols,$rows[]
    | @csv;

tocsv(.)

Esta variante del programa de Santiago también es segura, pero asegura que los nombres de clave en el primer objeto se usen como encabezados de la primera columna, en el mismo orden en que aparecen en ese objeto:

def tocsv:
  if length == 0 then empty
  else
    (.[0] | keys_unsorted) as $keys
    | (map(keys) | add | unique) as $allkeys
    | ($keys + ($allkeys - $keys)) as $cols
    | ($cols, (.[] as $row | $cols | map($row[.])))
    | @csv
  end ;

tocsv