Formatos compatíveis de dados semiestruturados¶

O que é JSON?¶

O JSON (JavaScript Object Notation) é um formato leve, de texto sem formatação e troca de dados baseado em um subconjunto da linguagem de programação JavaScript.

Os dados JSON podem ser produzidos por qualquer aplicativo. Alguns exemplos comuns incluem:

• Aplicativos em JavaScript que usam métodos nativos para gerar JSON.

• Aplicativos que não são em JavaScript e usam bibliotecas (geralmente com extensões) para gerar dados JSON.

• Geradores de JavaScript ad hoc.

• Concatenação de documentos JSON (que podem ou não ser separados por linha).

Como não há uma especificação formal, existem diferenças significativas entre as várias implementações. Essas diferenças tornam impossível a importação de conjuntos de dados do tipo JSON se o analisador JSON for rigoroso na definição de linguagem. Para reduzir ao máximo os problemas com a importação de conjuntos de dados JSON, o Snowflake segue a regra «seja liberal no que você aceita». A intenção é aceitar a maior variedade possível de entradas JSON e semelhantes ao JSON que permitam uma interpretação inequívoca.

Este tópico descreve a sintaxe de documentos JSON aceitos pelo Snowflake.

Para obter mais informações sobre o JSON, consulte json.org.

Sintaxe básica do JSON¶

Os dados JSON são uma coleção hierárquica de pares nome/valor agrupados em objetos e matrizes:

• Dois pontos : separam os nomes e valores nos pares nome/valor.

• Chaves {} denotam os objetos.

• Colchetes [] denotam as matrizes.

• Vírgulas , separam as entidades em objetos e matrizes.

Pares nome/valor¶

Os pares nome/valor JSON consistem de um nome de campo (entre aspas duplas), seguido por dois pontos e depois um valor.

Por exemplo:

{"firstName":"John", "empid":45611}

Tipos de dados suportados¶

Um valor em um par nome/valor pode ser:

• Um número (inteiro ou ponto flutuante)

• Uma cadeia de caracteres (entre aspas duplas)

• Um booleano (verdadeiro ou falso)

• Uma matriz (entre colchetes)

• Um objeto (entre chaves)

• Nulo

Objetos¶

Os objetos JSON são escritos entre chaves. Um objeto pode conter vários pares de nomes/valores, separados por vírgulas. Por exemplo:

{"firstName":"John", "lastName":"Doe"}

Matrizes¶

As matrizes JSON são escritas entre colchetes. Uma matriz pode conter vários objetos, separados por vírgulas. Por exemplo:

{"employees":[
    {"firstName":"John", "lastName":"Doe"},
    {"firstName":"Anna", "lastName":"Smith"},
    {"firstName":"Peter", "lastName":"Jones"}
  ]
}

Exemplos de documentos JSON¶

FILE NAME: json_sample_data1

Contém uma matriz com 3 registros simples de funcionários (objetos):

{"root":[{"employees":[
    {"firstName":"John", "lastName":"Doe"},
    {"firstName":"Anna", "lastName":"Smith"},
    {"firstName":"Peter", "lastName":"Jones"}
]}]}

Copy

FILE NAME: json_sample_data2

Contém uma matriz com 3 registros de funcionários (objetos) e seus dados de dependentes associados (filhos, nomes e idades dos filhos, cidades onde o funcionário morou e os anos em que o funcionário morou nessas cidades):

{"root":
   [
    { "kind": "person",
      "fullName": "John Doe",
      "age": 22,
      "gender": "Male",
      "phoneNumber":
        {"areaCode": "206",
         "number": "1234567"},
      "children":
         [
           {
             "name": "Jane",
             "gender": "Female",
             "age": "6"
           },
           {
              "name": "John",
              "gender": "Male",
              "age": "15"
           }
         ],
      "citiesLived":
         [
            {
               "place": "Seattle",
               "yearsLived": ["1995"]
            },
            {
               "place": "Stockholm",
               "yearsLived": ["2005"]
            }
         ]
      },
      {"kind": "person", "fullName": "Mike Jones", "age": 35, "gender": "Male", "phoneNumber": { "areaCode": "622", "number": "1567845"}, "children": [{ "name": "Earl", "gender": "Male", "age": "10"}, {"name": "Sam", "gender": "Male", "age": "6"}, { "name": "Kit", "gender": "Male", "age": "8"}], "citiesLived": [{"place": "Los Angeles", "yearsLived": ["1989", "1993", "1998", "2002"]}, {"place": "Washington DC", "yearsLived": ["1990", "1993", "1998", "2008"]}, {"place": "Portland", "yearsLived": ["1993", "1998", "2003", "2005"]}, {"place": "Austin", "yearsLived": ["1973", "1998", "2001", "2005"]}]},
      {"kind": "person", "fullName": "Anna Karenina", "age": 45, "gender": "Female", "phoneNumber": { "areaCode": "425", "number": "1984783"}, "citiesLived": [{"place": "Stockholm", "yearsLived": ["1992", "1998", "2000", "2010"]}, {"place": "Russia", "yearsLived": ["1998", "2001", "2005"]}, {"place": "Austin", "yearsLived": ["1995", "1999"]}]}
    ]
}

Copy

O que é Avro?¶

O Avro é uma estrutura de código aberto para serialização de dados e RPC, desenvolvida originalmente para uso com o Apache Hadoop. Ele utiliza esquemas definidos em JSON para produzir dados serializados em um formato binário compacto. Os dados serializados podem ser enviados para qualquer destino (ou seja, aplicativo ou programa) e podem ser facilmente desserializados no destino porque o esquema está incluído nos dados.

Um esquema Avro consiste em uma cadeia de caracteres, objeto ou matriz JSON que define o tipo de esquema e os atributos de dados (nomes de campo, tipos de dados, etc.) do tipo de esquema. Os atributos variam de acordo com o tipo de esquema. Há suporte para tipos de dados complexos, como matrizes e mapas.

O Snowflake lê os dados Avro em uma única coluna VARIANT. Você pode consultar os dados em uma coluna VARIANT assim como faria com dados JSON, usando comandos e funções similares.

Para obter mais informações, consulte avro.apache.org.

Exemplo de um esquema Avro¶

{
 "type": "record",
 "name": "person",
 "namespace": "example.avro",
 "fields": [
     {"name": "fullName", "type": "string"},
     {"name": "age",  "type": ["int", "null"]},
     {"name": "gender", "type": ["string", "null"]}
     ]
}

O que é ORC?¶

ORC (Optimized Row Columnar) é um formato binário usado para armazenar dados do Hive. O ORC foi projetado para realizar uma compactação eficiente e melhorar o desempenho de leitura, gravação e processamento de dados em relação aos formatos de arquivos anteriores da Hive. Para obter mais informações sobre o ORC, consulte https://orc.apache.org/.

Snowflake lê os dados ORC em apenas uma coluna VARIANT. Você pode consultar os dados em uma coluna VARIANT assim como faria com dados JSON, usando comandos e funções similares.

Como alternativa, você pode extrair colunas de um arquivo ORC preparado em colunas de tabela separadas usando uma instrução CREATE TABLE AS SELECT.

Exemplo de dados ORC carregados em uma coluna VARIANT¶

+--------------------------------------+
| SRC                                  |
|--------------------------------------|
| {                                    |
|   "boolean1": false,                 |
|   "byte1": 1,                        |
|   "bytes1": "0001020304",            |
|   "decimal1": 12345678.654745,       |
|   "double1": -1.500000000000000e+01, |
|   "float1": 1.000000000000000e+00,   |
|   "int1": 65536,                     |
|   "list": [                          |
|     {                                |
|       "int1": 3,                     |
|       "string1": "good"              |
|     },                               |
|     {                                |
|       "int1": 4,                     |
|       "string1": "bad"               |
|     }                                |
|   ]                                  |
| }                                    |
+--------------------------------------+

O que é Parquet?¶

O Parquet é uma representação compacta e eficiente de dados colunares, elaborada para projetos no ecossistema do Hadoop. Esse formato de arquivo oferece suporte a estruturas complexas de dados aninhados e utiliza os algoritmos de fragmentação e montagem de registros de Dremel. Para obter mais informações, consulte parquet.apache.org/docs/.

O Snowflake lê os dados de Parquet em uma única coluna VARIANT. Você pode consultar os dados em uma coluna VARIANT assim como faria com dados JSON, usando comandos e funções similares.

Como alternativa, você pode extrair colunas selecionadas de um arquivo preparado Parquet para inserir em diferentes colunas de tabela usando uma instrução CREATE TABLE AS SELECT.

O parquet é um formato binário. Não é possível fornecer um exemplo de um arquivo Parquet.

Exemplo de dados Parquet carregados em uma coluna VARIANT¶

+------------------------------------------+
| SRC                                      |
|------------------------------------------|
| {                                        |
|   "continent": "Europe",                 |
|   "country": {                           |
|     "city": {                            |
|       "bag": [                           |
|         {                                |
|           "array_element": "Paris"       |
|         },                               |
|         {                                |
|           "array_element": "Nice"        |
|         },                               |
|         {                                |
|           "array_element": "Marseilles"  |
|         },                               |
|         {                                |
|           "array_element": "Cannes"      |
|         }                                |
|       ]                                  |
|     },                                   |
|     "name": "France"                     |
|   }                                      |
| }                                        |
+------------------------------------------+

O que é XML?¶

XML (eXtensible Markup Language) é uma linguagem de marcação que define um conjunto de regras para a codificação de documentos. Originalmente, ele foi baseado no SGML, outra linguagem de marcação desenvolvida para padronizar a estrutura e os elementos que compõem um documento.

Desde seu lançamento, o XML cresceu para além do seu foco inicial em documentos e hoje abrange uma ampla gama de usos, entre eles a representação de estruturas de dados arbitrárias e servindo como linguagem base para protocolos de comunicação. Devido a sua extensibilidade, versatilidade e usabilidade, tornou-se um dos padrões mais utilizados para a troca de dados na Web.

Um documento XML consiste principalmente das seguintes construções:

• Tags (identificadas por colchetes angulares, < e >)

• Elementos

Os elementos normalmente consistem de uma tag “start” e uma tag “end”, com o texto entre as tags constituindo o conteúdo do elemento. Um elemento também pode consistir de uma tag “empty-element” sem a tag “end”. As tags “start” e “empty-element” podem conter atributos que ajudam a definir as características ou os metadados do elemento.

Exemplo de um documento XML¶

<?xml version="1.0"?>
<!DOCTYPE parts system "parts.dtd">
<?xml-stylesheet type="text/css" href="xmlpartsstyle.css"?>
<parts>
   <title>Automobile Parts &amp; Accessories</title>
   <part>
      <item>Spark Plugs</item>
      <partnum>A3-400</partnum>
      <price> 27.00</price>
   </part>
   <part>
      <item>Motor Oil</item>
      <partnum>B5-200</partnum>
      <price> 14.00</price>
   </part>
   <part>
      <item>Motor Oil</item>
      <partnum>B5-300</partnum>
      <price> 16.75</price>
   </part>
   <part>
      <item>Engine Coolant</item>
      <partnum>B6-120</partnum>
      <price> 19.00</price>
   </part>
   <part>
      <item>Engine Coolant</item>
      <partnum>B6-220</partnum>
      <price> 18.25</price>
   </part>
</parts>