DEV Community: Cesar Castro

ROLLUP

Cesar Castro — Fri, 15 Nov 2024 17:10:28 +0000

Understanding the Use of the ROLLUP Function in SQL

The ROLLUP function is a powerful tool in SQL that allows you to generate subtotals and grand totals in aggregated queries. This feature is particularly useful for reports and analysis, where there is a need to calculate consolidated values at different levels of detail.

What is ROLLUP?

The ROLLUP function is used in conjunction with the GROUP BY clause to create hierarchical groupings. It automatically adds extra rows that represent subtotals (partial sums) and the grand total at the end of the query.

Basic Syntax

SELECT column1, column2, aggregation(column3)
FROM table
GROUP BY ROLLUP(column1, column2);

How Does it Work?

ROLLUP processes the columns specified in the GROUP BY clause in hierarchical order.
It starts by grouping all values for each more detailed level, then progressively moves to less detailed levels.
Finally, it adds a row with the grand total.

Practical Example

Let's work with the products table created in the code above, which contains information about products and their categories.

1. Normal Query

If we query only the grouping by category, we get the following result:

SELECT product_category, SUM(product_value) AS total
FROM products
GROUP BY product_category;

Result:

Category	Total
clothing	40.48
food	6.97

2. Query with ROLLUP

By adding the ROLLUP function, we include the subtotals and the grand total:

SELECT CASE
         WHEN product_category IS NULL THEN 'Grand Total'
         ELSE product_category
       END AS category,
       SUM(product_value) AS total
FROM products
GROUP BY ROLLUP(product_category);

Result:

Category	Total
clothing	40.48
food	6.97
Grand Total	47.45

3. Subtotals with Multiple Levels

We can go further and calculate subtotals at multiple levels. For example, to calculate subtotals by category and product:

SELECT CASE
         WHEN product_category IS NULL AND product_name IS NULL THEN 'Grand Total'
         WHEN product_name IS NULL THEN 'Subtotal - ' || product_category
         ELSE product_name
       END AS description,
       SUM(product_value) AS total
FROM products
GROUP BY ROLLUP(product_category, product_name);

Result:

Description	Total
T-shirt	10.99
Shorts	8.99
Shoes	20.50
Subtotal - clothing	40.48
Rice	1.99
Popcorn	0.99
Filet Steak	3.99
Subtotal - food	6.97
Grand Total	47.45

When to Use ROLLUP?

Reports that require consolidated summaries.
Scenarios where you want automation of total calculations without needing to write additional queries.
Hierarchical data that needs analysis at different levels of granularity.

The ROLLUP function simplifies the creation of complex reports, reducing the need for manual manipulation. This functionality is supported by many databases such as Oracle, SQL Server, and MySQL. Use it to make your queries more efficient and your reports more dynamic! 🚀

Lambdas in Java

Cesar Castro — Fri, 15 Nov 2024 16:59:58 +0000

Lambdas in Java

Lambdas are undeclared functions, meaning they do not need to be explicitly declared to be used. There is no need to specify a name, parameters, access modifiers, or return type. Essentially, a lambda is a simpler way to implement an interface with a single method.

In Java, the basic syntax of lambda functions is:

(args) -> (body)

Examples

(int x, int y) -> { return x * y; }
Aluno display = (Pessoa p) -> { System.out.println(p.idade); }
() -> System.out.println(new Date());
() -> { return 25.789; }
x -> x < 100;

Curly braces are required only when the function body contains more than one statement. For example:

(int x, int y) -> { return x * y; }

Can be written as:

(int x, int y) -> return x * y;

Both forms produce the same result.

Lambda functions can have parameters or none at all. The parameter types can also be omitted, as Java will infer their types.

Examples

Function with parameters (with declared types):

   (int x, int y) -> { return x * y; }

Function with parameters (without declared types):

   (x, y) -> { return x * y; }

Function without parameters:

   () -> System.out.println(new Date());

If no return keyword is used, the function's return type is inferred as void:

(a) -> this.x = a;

It is important to note that lambdas are different from anonymous classes. This can be observed in the generated .class files. Unlike anonymous classes, lambdas do not generate multiple .class files for each usage.

Applications of Lambdas in Java

Threads

Lambdas simplify code by reducing verbosity when working with threads.

// Implementing the Runnable interface and creating a thread with it
Runnable e = new Runnable() {
    public void run() {
        System.out.println(new Date());
    }
};
new Thread(e).start();

// The same implementation using a lambda expression
Runnable e = () -> System.out.println(new Date());
new Thread(e).start();

// Even more concise
new Thread(
    () -> System.out.println(new Date())
).start();

Collections

Lambdas simplify functions such as sorting and filtering in collections.

// Print all elements in a list
List<String> list = Arrays.asList("João", "Ana", "Maria", "Cesar");
for (String s : list) {
    System.out.println(s);
}

// Using lambdas
list.forEach(s -> System.out.println(s));

// Lambda with multiple statements
list.forEach(s -> {
    if (StringUtils.equals("Cesar", s)) {
        System.out.println(s);
    }
});

// Conventional sorting
Collections.sort(list, new Comparator<String>() {
    @Override
    public int compare(String s1, String s2) {
        return s1.compareTo(s2);
    }
});
list.forEach(p -> System.out.println(p));

// Sorting using lambdas
Collections.sort(list, (String s1, String s2) -> s1.compareTo(s2));
list.forEach(p -> System.out.println(p));

Listeners

Lambdas simplify code in listeners, which implement the Observer design pattern.

// Listening to an action on a button in a Swing window
button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println("Some actions...");
    }
});

// Using lambdas
button.addActionListener((e) -> {
    System.out.println("Some actions...");
});

Generic Functions

Lambdas can be used in generic functions to solve problems by passing lambda expressions as parameters.

public class Main {
    /*
    * A method that tests a condition
    */
    public static void testExpression(List<String> list, Predicate<String> predicate) {
        list.forEach(n -> {
            if (predicate.test(n)) {
                System.out.println(n);
            }
        });
    }

    /*
    * Calling the method with a lambda
    */
    public static void main(String[] args) {
        List<String> list = Arrays.asList("João", "Ana", "Maria", "Cesar");
        // Prints "Cesar" if it exists
        testExpression(list, (n) -> StringUtils.equals("Cesar", n));
        // Prints the entire list
        testExpression(list, (n) -> true);
        // Prints nothing
        testExpression(list, (n) -> false);
    }
}

Java - Lambdas

Cesar Castro — Fri, 09 Oct 2020 10:18:48 +0000

Lambdas são funções não declaradas, ou seja, que não precisam ser declaradas para serem utilizadas, sendo desnecessário declarar um nome, parametros, modificadores de acesso e retorno. Também podemos dizer que uma lambda é uma forma mais simples de implementar um interface que só tem um único método.

Básicamente, as funções lambdas, no Java, tem a sintaxe:
(args)->(corpo).
Exemplos:

(int x, int y) -> { return x * y; }
Aluno exibicao = (Pessoa p)-> { System.out.println(p.idade); }
() -> System.out.println(new Date());
() -> { return 25.789; }
x -> x < 100;

As chaves só são obrigatórias quando o corpo da função tiver mais de um comando.
Por exemplo:

(int x, int y) -> { return x * y; }

Pode ser escrito:

(int x, int y) -> return x * y;

Obtendo o mesmo resultado.

As funções podem ou não ter parâmetros, e os tipos podem ser omitidos, assim o Java vai inferir o tipo.

Exemplo:

Função com parâmetros (e com o tipo declarado!).

(int x, int y) -> { return x * y; }

Função com parâmetros, sem o tipo declarado.

(x, y) -> { return x * y; }

Função sem parâmetro.

() -> System.out.println(new Date());

Sem o return, o tipo da função é inferido como void.

(a) -> this.x = a;

É importante ressaltar que a lambda é diferente do uso de classes anônimas, observável pelos .class gerados. Observará que não terá gerado diversos .class que seriam comumente gerados caso utilizasse-mos, para cada classe anônima utilizada.

Aplicações:

Threads

Nas threads elas são utilizadas para simplificação do código, tornando menos verboso.

/*
* Implementação da interface Runnable seguido da criação 
* da thread com a implementação
*/
Runnable e = new Runnable(){
      public void run(){
           System.out.println(new Date());
      }
};
new Thread(e).start();

/*
* A mesma implementação, agora utilizando expressão 
* lambda
*/
Runnable e = () -> System.out.println(new Date());
new Thread(e).start();

/*
* Ainda pode ser mais simplificada!!
*/
new Thread(
() -> System.out.println(new Date())
).start();

Coleções

Nas Coleções flexibilização de funções de ordenação e filtros, por exemplo.

/*
* Imprimir todos os elementos de uma lista
*/
List l = Arrays.asList("João", "Ana", "Maria", "Cesar");
for(String s: l){
    System.out.println(s);
}

/*
* Agora utilizando lambda
*/
List l = Arrays.asList("João", "Ana", "Maria", "Cesar");
l.forEach(s -> System.out.println(s));

/*
* Lambda com mais de um comando
*/
List l = Arrays.asList("João", "Ana", "Maria", "Cesar");
l.forEach(s -> {
   if(StringUtils.equals("Cesar"){
       System.out.println(a);
  }
});

/*
* Ordenamento "convencional"
*/
List l = Arrays.asList("João", "Ana", "Maria", "Cesar");
Collections.sort(l, new Comparator(){
    @Override
    public int compare(String s1, String s2){
       return s1.compareTo(s2);
    }
});
l.forEach(p -> System.ou.println(p));

/*
* Ordenamento usando lambda
*/
List l = Arrays.asList("João", "Ana", "Maria", "Cesar");
Collections.sort(l, (String s1, String s2) -> s1.compareTo(s2));
l.forEach(p -> System.ou.println(p));

Listeners

Nos Listners usada para simplificação de código.
Listners são classes que implementam o Design Pattern Observer

/*
* "Ouvindo" uma ação em um botão em uma janela Swing
*/
botton.addActionListner(new ActionListner(){
    @Oberride
    public void actonPerformed(ActionEvent e){
        System.out.println("Algumas ações...");
    }
});

/*
* A mesma solução usando lambda
*/
button.addActionListner( (e) -> {
    System.out.println("Algumas ações...");
});

Funções Genéricas

Nas Funções genéricas utilizado para criar funções genéricas utilizadas para solução de problemas, quando as funções aceitam expressões lambdas como parâmetro.

public class Principal{
   /*
   * um método que testa uma condição
   */
   public static void testaExpressao(List l, Predicate p){
       l.forEach(n -> {
          if(p.test(n)){
             System.out.println(n);
          }
       });
   }

   /*
   * chamando com lambda
   */
   public void mai(String[] args){
      List l = Arrays.asList("João", "Ana", "Maria", "Cesar");
      //Imprime o nome do "Cesar", se existir
      testaExpressao(l, (n) -> StringUtils.equals("Cesar"));
      //Imprime toda a lista
      testaExpressao(l, (n) -> true);
      //Não imprime nada
      testaExpressao(l, (n) -> false);
   }
}