Dataframe do SQL Spark

Um quadro de dados semelhante ao RDD é uma abstração fornecida para dados estruturados na biblioteca Spark SQL. É uma coleção distribuída de dados que pode ser considerada uma tabela em um banco de dados relacional com um esquema anexado. Também pode ser definido como a coleção de colunas nomeadas. O Spark SQL é uma das bibliotecas disponíveis na pilha do Spark que contém informações sobre a estrutura e o cálculo que está sendo executado nos dados. Essas informações adicionais são usadas para executar otimizações. Um dataframe incorpora os benefícios do RDD, juntamente com técnicas de otimização, e esta API está disponível em Python, R, Scala e Java.

As diferentes fontes que geram um quadro de dados são-

  • RDD existente
  • Arquivos de dados estruturados e bancos de dados
  • Hive Tables

Necessidade de Dataframe

A comunidade do spark sempre tentou trazer estrutura para os dados, onde os quadros de dados SQL do spark são as etapas seguidas nessa direção. A API inicial do spark, RDD é para dados não estruturados, onde os cálculos e os dados são opacos. Portanto, havia um requisito para criar uma API capaz de fornecer benefícios adicionais de otimização. Abaixo estão os poucos requisitos que formaram a base do quadro de dados

  • Processo estruturado e semidados
  • Várias fontes de dados
  • Integração com múltiplas linguagens de programação
  • O número de operações que podem ser executadas nos dados, como selecionar e filtrar.

Como criar o Spark SQL Dataframe?

Antes de entender maneiras de criar um quadro de dados, é importante entender outro conceito pelo qual os aplicativos spark criam o quadro de dados a partir de diferentes fontes. Esse conceito é conhecido como sparksession e é o ponto de entrada para toda a funcionalidade do spark. Antes, tivemos que criar sparkConf, sparkContext ou sqlContext individualmente, mas com sparksession, todos são encapsulados em uma sessão em que o spark atua como um objeto de sparksession.

import org.apache.spark.sql.SparkSession
val spark = SparkSession
.builder()
.appName("SampleWork")
.config("config.option", "value")
.getOrCreate()

Maneiras de criar um quadro de dados

  1. Do RDD existente

Há duas maneiras pelas quais um Dataframe pode ser criado por meio do RDD. Uma maneira é usar a reflexão que infere automaticamente o esquema dos dados e a outra abordagem é criar um esquema programaticamente e depois aplicar ao RDD.

  • Inferindo o esquema

Uma maneira fácil de converter um RDD em Dataframe é quando ele contém classes de casos devido à interface SQL do Spark. Os argumentos passados ​​para as classes de caso são buscados usando reflexão e se tornam o nome das colunas da tabela. Sequências e matrizes também podem ser definidas em classes de caso. O RDD que será criado usando a classe case pode ser implicitamente convertido em Dataframe usando o método toDF ().

val sqlContext = new org.apache.spark.sql.SQLContext(sc)
import sqlContext.implicits._
case class Transport(AutoName: String, year: Int)
val Vehicle = sc.textFile("//path//").map(_.split(", ")).map(p => Transport(p(0), p(1)).toDF()

Um veículo de quadro de dados é criado e pode ser registrado como uma tabela na qual as instruções sql podem ser executadas.

  • Especificando programaticamente o esquema

Pode haver casos em que não tenhamos conhecimento antecipadamente do esquema ou cenários em que as classes de casos não possam ter mais de 22 campos. Em tais condições, usamos a abordagem de criar programaticamente o esquema. Primeiramente, um RDD de linhas é criado a partir do RDD original, ou seja, convertendo o objeto rdd de rdd (t) para rdd (linha). Em seguida, crie um esquema usando os objetos StructType (Table) e StructField (Field). Esse esquema é aplicado ao RDD de linhas usando o método createDataFrame, que se assemelha à estrutura do rdd (linha) criada anteriormente.

val Vehicle = sc.textFile("//path")
import org.apache.spark.sql._
val schema = StructType(Array(StructField("AutoName", StringType, true), StructField("Year", IntegerType, true)))
scala> val rowRDD = vehicle.map(_.split(", ")).map(p => org.apache.spark.sql.Row(p(0), p(1).toInt))
val vehicleSchemaRDD = sqlContext.applySchema(rowRDD, schema)

  1. Através de fontes de dados

O Spark permite a criação de quadros de dados através de várias fontes, como hive, json, parquet, csv e arquivos de texto que também podem ser usados ​​para criar quadros de dados.

Val file=sqlContext.read.json(“path to the json file”)
Val file=sqlContext.read.csv(“path to the json file”)
Val file=sqlContext.read.text(“path to the json file”)
val hiveData = new org.apache.spark.sql.hive.HiveContext(sc)
val hiveDF = hiveData.sql(“select * from tablename”)

Operações de DataFrame

Como os dados são armazenados em um formato tabular, juntamente com o esquema, há várias operações que podem ser executadas nos quadros de dados. Ele permite várias operações que podem ser executadas em dados em quadros de dados.

Considerar arquivo é um quadro de dados que foi criado a partir de um arquivo csv com duas colunas - FullName e AgePerPA

  1. printSchema () - Para visualizar a estrutura do esquema

file.printSchema()
// |-- AgePerPA: long (nullable = true)
// |-- FullName: string (nullable = true)

  1. select- Similar à instrução select no SQL, mostra os dados conforme mencionado na instrução select.

file.select("FullName").show()
// +-------+
// | name|
// +-------+
// |Sam|
// |Jodi|
// | Bala|
// +-------+

  1. Filtro - para visualizar os dados filtrados do quadro de dados. A condição mencionada no comando

file.filter($"AgePerPA" > 18).show()

  1. GroupBy- Para agrupar pelos valores

file.groupBy("AgePerPA").count().show()

  1. show () - para exibir o conteúdo do quadro de dados

file.show()

Limitações

Embora com quadros de dados você possa detectar um erro de sintaxe sql no próprio tempo de compilação, ele não é capaz de lidar com nenhum erro relacionado à análise até o tempo de execução. Por exemplo, se um nome de coluna não existente estiver sendo referido no código, ele não será percebido até o tempo de execução. Isso levaria ao desperdício de tempo e custo do projeto do desenvolvedor.

Conclusão - Spark SQL Dataframe

Este artigo fornece uma imagem geral (necessidade, criação, limitações) sobre a API de dataframe do Spark SQL. Devido à popularidade das APIs de dataframe, o Spark SQL continua sendo uma das bibliotecas amplamente usadas. Assim como um RDD, ele fornece recursos como tolerância a falhas, avaliação lenta, processamento na memória e alguns benefícios adicionais. Pode ser definido como dados distribuídos pelo cluster em forma de tabela. Assim, um quadro de dados terá um esquema associado a ele e pode ser criado através de várias fontes via objeto de sessão spark.

Artigos recomendados

Este é um guia para o Spark SQL Dataframe. Aqui discutimos as maneiras de criar um quadro de dados com as operações e limitações do DataFrame. Você também pode consultar o seguinte artigo para saber mais -

  1. Comandos do Spark Shell
  2. Cursores no SQL
  3. Restrições SQL
  4. Banco de dados em SQL
  5. Tipos de junções no Spark SQL (exemplos)
  6. Guia para a lista de comandos do Unix Shell

Categoria:

Big Data