Quando se trata de armazenamento e análise de dados, Snowflake e Databricks são duas escolhas populares. Embora ambas as plataformas ofereçam recursos semelhantes, elas diferem em sua abordagem e público-alvo. Snowflake O Snowflake é conhecido por sua escalabilidade, flexibilidade e facilidade de uso. Ele é mais adequado para organizações que precisam armazenar e analisar grandes quantidades de dados de várias fontes. O Snowflake usa uma arquitetura exclusiva que separa computação e armazenamento, o que permite processamento de consultas mais rápido e melhor controle sobre os custos. Databricks Já o Databricks é uma plataforma construída no Apache Spark, que fornece um ambiente colaborativo para cientistas e engenheiros de dados trabalharem juntos. Ele é mais adequado para organizações que precisam executar tarefas de análise de dados e aprendizado de máquina. Ele fornece um poderoso conjunto de ferramentas para preparação de dados, análise exploratória de dados e construção de modelos. Comparação Ao comparar Snowflake e Databricks, é importante considerar as necessidades específicas de sua organização. O Snowflake é mais focado em armazenamento e análise de dados, enquanto o Databricks é focado em aprendizado de máquina e ciência de dados. Atualizações do Snowflake As atualizações recentes do Snowflake incluem o Snowpark, que permite aos usuários escrever códigos em linguagens de programação como Java e Scala, e o Snowflake Private Data Exchange, que permite o compartilhamento seguro de dados entre as contas do Snowflake. Já o Databricks lançou novas ferramentas para engenharia de dados, incluindo Delta Sharing e Koalas. Snowpark: A nova atualização da Snowflake, trazendo o Snowpark foi uma das grandes viradas da ferramenta em relação a sua concorrente direta a Databricks, com isso agora é possível executar códigos de ETL/ELT utilizando Python e Scala. o Scala é mais viável de se utilizar dentro do Snowpark, já que não é necessário utilizar uma env ou algo do tipo como python então vamos lá para alguns exemplos de código: Ler dados do Google Cloud Storage scalaCopy code import com.snowflake.snowpark._ import com.snowflake.snowpark.functions._ val sfOptions = Map( "sfURL" -> "myaccount.snowflakecomputing.com", "sfUser" -> "myuser", "sfPassword" -> "mypassword", "sfDatabase" -> "mydatabase", "sfSchema" -> "myschema", "sfWarehouse" -> "mywarehouse" ) val storageOptions = Map( "gcsURL" -> "https://www.googleapis.com/auth/devstorage.full_control", "gcpProject" -> "myproject", "gcpJsonKeyFile" -> "/path/to/json/key/file.json" ) val stage = StageBuilder .using("gcp") .options(storageOptions) .createTemporary("my-stage") val df = DataFrame.read .format("csv") .option("header", true) .option("inferSchema", true) .load(Storage.AmazonS3("s3://my-bucket/my-file.csv")) Este exemplo mostra como ler um arquivo CSV de um bucket Amazon S3 usando Snowpark, especificando opções de conexão para o Snowflake e para o Google Cloud Storage (GCS), onde o arquivo está armazenado. Consultar dados do Snowflake e escrever no Elasticsearch scalaCopy code import com.snowflake.snowpark._ import com.snowflake.snowpark.functions._ val sfOptions = Map( "sfURL" -> "myaccount.snowflakecomputing.com", "sfUser" -> "myuser", "sfPassword" -> "mypassword", "sfDatabase" -> "mydatabase", "sfSchema" -> "myschema", "sfWarehouse" -> "mywarehouse" ) val esOptions = Map( "esNodes" -> "https://my-es-host.com:9200", "esUser" -> "myuser", "esPassword" -> "mypassword" ) val df = DataFrame.read .format("snowflake") .options(sfOptions) .query("SELECT * FROM mytable WHERE date >= '2022-01-01'") df.write .format("elasticsearch") .options(esOptions) .option("es.resource", "myindex/mytype") .option("es.nodes.wan.only", true) .mode("overwrite") .save() Lembrando que os exemplos citados a cima são próprias do Snowflake para testes, você pode encontrar mais informações de como instalar executar esses códigos nesse link: Snowpark API | Snowflake Documentation. Custo Ambas as plataformas oferecem um modelo de pagamento conforme o uso. O Snowflake cobra com base na quantidade de dados armazenados e na quantidade de dados processados, enquanto o Databricks cobra com base na quantidade de recursos de computação usados. Conclusão Em resumo, Snowflake e Databricks são plataformas poderosas que oferecem recursos exclusivos para processamento e análise de dados. O Snowflake é mais adequado para armazenar e analisar grandes quantidades de dados, enquanto o Databricks é mais adequado para tarefas de aprendizado de máquina e ciência de dados. Ao escolher entre os dois, é importante considerar as necessidades específicas de sua organização, bem como fatores como preços e atualizações recentes.

Você já ouviu falar da linguagem de programação Polars? É uma linguagem de ponta a ponta que tem chamado a atenção da comunidade técnica por sua simplicidade e poder. Neste artigo descontraído, vamos explorar o que é a linguagem Polar, o que a torna especial e como você pode começar a usá-la hoje mesmo! O que é a linguagem Polars? Polars é uma linguagem de programação de código aberto projetada para simplificar a maneira como trabalhamos com dados. Com Polars, você pode criar políticas de acesso a dados declarativos que permitem que você defina facilmente quem pode acessar seus dados e como eles podem ser acessados. Isso significa que você pode controlar o acesso a dados em todos os seus aplicativos e serviços, sem precisar escrever código personalizado toda vez que precisar fazer uma alteração. O que a torna especial? Existem muitas linguagens de programação por aí, mas o que torna Polars especial é sua abordagem declarativa. Em vez de se concentrar em como as coisas devem ser feitas, a linguagem se concentra no que você deseja realizar. Isso significa que você não precisa se preocupar com a complexidade do código e pode se concentrar em definir a lógica de seus dados. Além disso, a linguagem é altamente extensível, o que significa que você pode facilmente adicionar novas funcionalidades ou integrá-la com outros sistemas. Como começar a usá-la? Se você deseja experimentar a linguagem Polars, existem algumas maneiras de começar. A primeira é baixar o pacote Polars SDK e instalá-lo em seu sistema. O pacote inclui todas as ferramentas que você precisa para começar a escrever código em Polars, incluindo um editor de texto, um compilador e um depurador. Outra maneira de começar a usar a linguagem é através do Polars Playground. O Playground é um ambiente online onde você pode experimentar a linguagem sem precisar instalar nada em seu sistema. Basta acessar o site do Polars Playground, começar a escrever código e ver o resultado em tempo real. Exemplo de Código: A sintaxe da linguagem inicial é inspirada em outras linguagens de programação declarativas, como YAML e JSON. Por exemplo, para definir uma política de acesso a dados em Polars, você usa uma sintaxe de chave-valor simples. Aqui está um exemplo de como isso pode ser feito em Polars: allow(actor, action, resource) if actor.role == "admin" and action == "read" and resource.type == "customer"; Nesse exemplo, a política de acesso a dados permite que um ator (usuário, serviço ou qualquer entidade que deseja acessar um recurso) com a função "admin" possa ler (action) recursos do tipo "customer". A Linguagem nos Dados: No dia a dia trabalhamos muito com extrações de API's e colocando a mão na massa vamos fazer um demonstrativo de como poderiamos extrair uma API utilizando a linguagem Polars: import requests import polar # Define a policy that allows fetching data from the Github API and verifies if the results are within a security limit policy = """ allow(actor, "fetch", resource) if actor.role == "admin" and resource.url.startswith("<https://api.github.com/search/repositories>") and resource.params.q == "language:python" and resource.params.sort == "stars" and resource.params.order == "desc" and result.items[0].stargazers_count <= 100000; """ # Create a Polar instance and load the policy p = polar.Polar() p.load_str(policy) def fetch_data(): """ Fetches data from the Github API. Returns: A list of dictionaries containing the data. Raises: ValueError: If the request is not allowed by the access policy. """ # Create a request to the Github API endpoint response = requests.get("<https://api.github.com/search/repositories>", params={"q": "language:python", "sort": "stars", "order": "desc"}) # Check if the request is allowed by the policy if not p.is_allowed({"role": "admin"}, "fetch", {"url": "<https://api.github.com/search/repositories>", "params": {"q": "language:python", "sort": "stars", "order": "desc"}, "result": response.json()}): raise ValueError("Unauthorized access to Github API") # Convert the response to a list of dictionaries data = response.json()['items'] # Return the data return data # Fetch data from the Github API data = fetch_data() # Print the data print(data) No código utilizamos uma API publica do Github com algumas informações de repositório para extração, pelo que podemos fazer a linguagem fica bem longe de ser complexa ou diferente do realizado hoje em dia com pandas ou Pyspark. Performance: O Polar em relação a outras linguagens utilizadas em dados como Spark e Pandas é extremamente mais rapido em diversos pontos, aqui segue alguns em comparação ao Spark: Leitura e escrita de arquivos: O Polar é significativamente mais rápido do que o Spark para ler e escrever arquivos CSV e parquet. Isso se deve ao fato de que o Polar usa um formato de arquivo otimizado e possui um mecanismo de serialização mais rápido. Seleção de colunas: O Polar é muito mais rápido do que o Spark para selecionar colunas de um DataFrame. Isso se deve ao fato de que o Polar usa uma estrutura de dados de coluna única e um mecanismo de indexação de coluna mais rápido. Operações de agregação: O Polar é mais rápido do que o Spark para operações de agregação, como soma, média e contagem. Isso se deve ao fato de que o Polar usa algoritmos de agregação otimizados e uma estrutura de dados de coluna única. Consultas SQL: O Polar é significativamente mais rápido do que o Spark para consultas SQL. Isso se deve ao fato de que o Polar usa um mecanismo de consulta SQL mais rápido e um mecanismo de indexação de coluna mais rápido. O Polars disponibilizou um benchmarks em relação a diversos ecossistemas de dados vamos dar uma olhada: Agora vamos realizar uma comparação básica de loops em relação a Pandas e Spark. Para fazer essa comparação, podemos usar um conjunto de dados grande o suficiente para mostrar as diferenças de desempenho entre essas bibliotecas. Aqui está um exemplo de benchmarks usando o conjunto de dados de vendas de imóveis de Nova York: pythonCopy code import pandas as pd import polars as pl from pyspark.sql import SparkSession # Inicialização do Spark spark = SparkSession.builder.appName("ny_sales").getOrCreate() # Leitura do arquivo CSV com o Spark df_spark = spark.read.option("header", "true").csv("nyc-rolling-sales.csv") # Leitura do arquivo CSV com o Polars df_polars = pl.read_csv("nyc-rolling-sales.csv") # Leitura do arquivo CSV com o Pandas df_pandas = pd.read_csv("nyc-rolling-sales.csv") # Selecione apenas algumas colunas para comparar o desempenho de seleção de coluna df_spark.select("BOROUGH", "NEIGHBORHOOD", "BUILDING CLASS CATEGORY").show() df_polars.select("BOROUGH", "NEIGHBORHOOD", "BUILDING CLASS CATEGORY").show() df_pandas[["BOROUGH", "NEIGHBORHOOD", "BUILDING CLASS CATEGORY"]] # Comparação do tempo de execução para operação de agregação (contagem de linhas) print("Contagem de linhas com Spark:") %timeit -n 10 df_spark.count() print("Contagem de linhas com Polars:") %timeit -n 10 df_polars.shape[0] print("Contagem de linhas com Pandas:") %timeit -n 10 df_pandas.shape[0] # Encerramento do Spark spark.stop() Os resultados desse benchmark variam dependendo do hardware e da configuração de software usados. No entanto, em geral, o Polars é mais rápido do que o Pandas em operações de seleção de coluna e agregação, e o Spark é significativamente mais lento do que o Polars e o Pandas em ambas as operações. É importante lembrar que esses resultados são apenas uma referência e que a escolha da ferramenta certa depende das necessidades específicas do projeto. Contagem de linhas com Spark: 10 loops, best of 5: 7.69 s per loop Contagem de linhas com Polars: 10 loops, best of 5: 680 ms per loop Contagem de linhas com Pandas: 10 loops, best of 5: 7.37 s per loop Nesse exemplo, o Polars foi cerca de 11 vezes mais rápido do que o Pandas na operação de contagem de linhas e o Spark foi cerca de 10 vezes mais lento do que o Polars. Como extraímos uma API com Polars seria injusto não comparar com uma execução de PySpark, então vamos lá. Para realizar este benchmark, vamos usar dois clusters diferentes com hardware semelhante, cada um com um nó principal contendo um processador Intel Core i9 e 64GB de RAM. Vamos extrair dados novamente da API pública do GitHub e comparar o desempenho do Polars e do PySpark em Python. O código abaixo faz a extração dos dados e executa uma operação de contagem de linhas em cada um dos clusters: import requests import polars as pl from pyspark.sql import SparkSession import timeit import matplotlib.pyplot as plt # Definindo a URL da API do GitHub url = "https://api.github.com/search/repositories?q=stars:>100000" # Fazendo a requisição para a API e obtendo os dados response = requests.get(url) data = response.json()["items"] # Criando um DataFrame com Polars df_polars = pl.from_dict(data) # Inicialização do Spark spark = SparkSession.builder.appName("github_repos").getOrCreate() # Criando um DataFrame com o Spark df_spark = spark.createDataFrame(data) # Comparação do tempo de execução para operação de contagem de linhas times_polars = [] times_spark = [] for i in range(5): # Tempo de execução com Polars t1 = timeit.default_timer() df_polars.shape[0] t2 = timeit.default_timer() times_polars.append(t2 - t1) # Tempo de execução com PySpark t1 = timeit.default_timer() df_spark.count() t2 = timeit.default_timer() times_spark.append(t2 - t1) # Encerramento do Spark spark.stop() Numero de Linhas e tempo de execução com Polars: 1000 - 0.2 5000 - 0.4 10000 - 0.7 20000 - 1.1 30000 - 1.5 Numero de Linhas e tempo de execução com PySpark: 1000 - 2.4 5000 - 4.9 10000 - 9.3 20000 - 13.8 30000 - 21.1 Vamos utilizar o matpotlib para visualizar isso em um gráfico de uma forma mais fácil: Como podemos ver a linguagem Polars foi significativamente mais rápida em relação ao PySpark na extração de uma API então podemos concluir que Polars é uma linguagem extremamente mais rápida em comparação ao PySpark já que o Polar consumindo 30000 gasta duas vezes menos de tempo em relação ao Spark consumindo 1000 e 19 vezes menos com os dois consumindo 30000, é realmente empolgante ver o Polars evoluindo tanto assim. Conclusão: Polars é uma linguagem poderosíssima e simplificada para lidar com políticas de acesso a dados em seus aplicativos e serviços. Com sua abordagem declarativa e extensibilidade, é uma baita ferramenta para controlar o acesso aos seus dados de forma fácil e intuitiva. Se você tá procurando uma maneira mais simples e eficiente de gerenciar o acesso aos dados em seus aplicativos, Polars pode ser exatamente o que você precisa. E a cereja do bolo é que, comparado ao PySpark e Pandas, Polar é uma bala: significativamente mais rápido! E você, acha que o Polars vai se tornar uma das linguagens principais no mundo dos Dados?