[SQL] How to hanlde NULL values in the SELECT statement and convert them to 0?

Introduction

SQL est un langage de programmation de base de données largement utilisé pour stocker, interroger et manipuler des données. Cependant, lors de l’utilisation de SQL, les utilisateurs peuvent rencontrer un problème courant : la présence de valeurs NULL dans les colonnes des bases de données.

Problème

Une valeur NULL est une valeur inconnue ou indéfinie qui peut être présente dans une colonne de base de données. Ces valeurs NULL peuvent causer des problèmes lors de l’exécution de certaines requêtes SQL, car elles peuvent produire des résultats inattendus ou des erreurs. En particulier, les opérations mathématiques et les comparaisons logiques ne peuvent pas être effectuées sur des valeurs NULL, ce qui peut rendre difficile le traitement des données.
Si vous essayez d'effectuer une opération mathématique ou une comparaison logique sur une valeur NULL, le résultat sera également NULL. Cela peut rendre difficile le traitement des données dans certaines situations, en particulier lorsqu'il est nécessaire de faire des calculs sur les données ou de les comparer avec d'autres valeurs.

Solution

Pour résoudre ce problème, SQL fournit la fonction ISNULL. Cette fonction permet de remplacer les valeurs NULL par une valeur par défaut lors de l’exécution d’une requête. 

Par exemple, si vous avez une table “orders” avec une colonne “total” contenant le montant total de la commande, vous pouvez utiliser ISNULL pour remplacer les valeurs NULL par 0. 

La requête serait alors :

SELECT SUM(ISNULL(total, 0)) AS total_amount FROM orders;

Discussion

En utilisant la fonction ISNULL, vous pouvez manipuler et traiter efficacement les valeurs NULL dans vos requêtes SQL et éviter les erreurs potentielles qui pourraient survenir si vous ne traitez pas correctement ces valeurs. 

En résumé, bien que la présence de valeurs NULL en SQL puisse causer des problèmes lors de l’exécution de certaines requêtes SQL, il existe des moyens efficaces pour gérer ces situations et éviter les erreurs potentielles.

https://stackoverflow.com/questions/16840522/replacing-null-with-0-in-a-sql-server-query

[Postgresql] pg_stat_activity

La table pg_stat_activity de PostgreSQL permet de surveiller les activités en cours dans la base de données. Il est important de surveiller l'état de la transaction dans cette table pour s'assurer que les transactions sont possibles. Si l'état est "idle", il est important de vérifier que le mode manuel de commit est activé pour permettre l'utilisation des transactions.

Voici un tableau comparatif des différents états de la table pg_stat_activity :

État	Signification
active	La session est en train d'exécuter une requête
idle	La session est connectée à la base de données mais n'exécute pas de requête
idle in transaction	La session est en mode manuel de commit et est en train d'exécuter une transaction
idle in transaction (aborted)	La session a été annulée en raison d'une erreur de transaction

Pour passer en mode manuel de commit, il suffit d'exécuter la commande suivante :

sql
BEGIN;

Cette commande active le mode de transaction et permet de valider ou d'annuler les requêtes manuellement. Lorsque le mode manuel de commit est activé, l'état de la transaction dans la table pg_stat_activity passe de "idle" à "idle in transaction".

Exemple pratique : pour s'assurer que les transactions sont possibles, il faut vérifier que l'état de la transaction dans la table pg_stat_activity est "idle in transaction". Si ce n'est pas le cas, il faut activer le mode manuel de commit en exécutant la commande BEGIN.

En résumé, en surveillant attentivement la table pg_stat_activity et en comprenant les différents états de la transaction, il est possible de garantir l'utilisation efficace des transactions dans PostgreSQL.

Configuring Elastic Common Schema (ECS) & OpenTelemetry for Spring Boot Application

Introduction

Le Elastic Common Schema (ECS) est un standard ouvert qui définit un ensemble commun de champs pour être utilisés lors de l’ingestion de données dans Elasticsearch¹. Il a été conçu pour aider les utilisateurs à normaliser leurs données afin de faciliter leur analyse¹.

Problème

Auparavant, il y avait deux standards séparés pour la structuration des données : le Elastic Common Schema (ECS) et les Conventions Sémantiques OpenTelemetry. Cela pouvait créer des problèmes de compatibilité et rendre plus difficile l’analyse des données provenant de différentes sources¹.

Solution

Elastic et OpenTelemetry ont annoncé une convergence entre le Elastic Common Schema (ECS) et les Conventions Sémantiques OpenTelemetry¹. L’objectif est d’atteindre une convergence de l’ECS et des Conventions Sémantiques OpenTelemetry en un seul schéma ouvert maintenu par OpenTelemetry¹. Cela signifie que les Conventions Sémantiques OpenTelemetry sont véritablement un successeur du Elastic Common Schema¹.

Pour utiliser le ECS dans une application Java Spring, vous pouvez configurer Logback, le logger par défaut pour Spring, pour utiliser le logging Java ECS². Les logs générés de cette manière seront structurés en tant qu’objets JSON et utiliseront des noms de champs conformes à l’ECS².

Discussion

La convergence du ECS et des Conventions Sémantiques OpenTelemetry est une étape importante pour améliorer la convergence de l’observabilité et de la sécurité¹. Cela apporte une grande valeur à la communauté open source car l’ECS a des années de succès prouvés dans les schémas de logs, de métriques, de traces et d’événements de sécurité, offrant une grande couverture des domaines problématiques communs¹.

De plus, la configuration du logging Java ECS dans une application Spring Boot est relativement simple et peut aider à améliorer l’observabilité et la traçabilité de l’application².

 https://www.elastic.co/guide/en/ecs-logging/java/current/setup.html

Spring Cloud Config : How to prevent Spring Config to reset my local git repository to origin/master

 git rm origin 

[Maven ] Updating Multiple Modules pom.xml -DprocessAllModules=true

 http://maven.apache.org/guides/mini/guide-multiple-modules.html

https://stackoverflow.com/questions/28154902/how-to-use-versions-maven-plugin-to-set-child-module-versions

mvn versions:set -DnewVersion=xxx -DprocessAllModules=true

[Java] Enum lookup values by label

L'utilisation des énumérations (enums) pour les valeurs de recherche est une pratique courante en Java, et pour de bonnes raisons. Dans cet article, nous allons discuter des avantages de cette pratique et expliquer comment elle peut améliorer la lisibilité, la sécurité et la maintenabilité de votre code.

• Lisibilité améliorée

Lorsque vous utilisez des énumérations pour définir des valeurs de recherche, vous donnez à votre code une signification claire et facilement compréhensible. Par exemple, au lieu de définir une chaîne de caractères telle que "M" pour représenter un mois, vous pouvez utiliser une énumération telle que "Janvier", "Février", etc. Cela rend votre code plus lisible et plus facile à comprendre pour les autres développeurs qui peuvent travailler sur votre code.

• Sécurité renforcée

Les énumérations offrent également une sécurité supplémentaire à votre code. En effet, elles garantissent que seules les valeurs prédéfinies peuvent être utilisées pour une recherche donnée. Cela évite les erreurs de saisie ou les valeurs incorrectes, qui peuvent entraîner des résultats inattendus ou des exceptions lors de l'exécution. Les énumérations sont également plus sûres que les chaînes de caractères, qui peuvent facilement être modifiées ou corrompues.

• Maintenabilité améliorée

En utilisant des énumérations pour les valeurs de recherche, vous pouvez également améliorer la maintenabilité de votre code. Si vous devez modifier une valeur de recherche, vous n'aurez qu'à le faire dans une seule classe, plutôt que de rechercher et de remplacer cette valeur dans plusieurs endroits du code. Cela rend les modifications plus rapides et moins risquées, car vous n'avez pas besoin de vous soucier des effets de bord ou des modifications involontaires dans d'autres parties du code.

• Exemple de code

Voici un exemple de code qui utilise une énumération pour les valeurs de recherche :

public enum SortOrder {

    ASC("asc"),
    DESC("desc");

    private static final HashMap<String, SortOrder> MAP = new HashMap<String, SortOrder>();

    private String value;

    private SortOrder(String value) {
        this.value = value;
    }

    public String getValue() {
        return this.value;
    }

    public static SortOrder getByName(String name) {
        return MAP.get(name);
    }

    static {
        for (SortOrder field : SortOrder.values()) {
            MAP.put(field.getValue(), field);
        }
    }
}

After that, just call:

SortOrder asc = SortOrder.getByName("asc");

https://www.baeldung.com/java-enum-values#caching

[Java] String format() Format Specifiers

From Javadoc : https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Formatter.html 

 Example :

Suppose we have int x = 123, and we want to pad 0 .

String.format("%1$013d", x);

• The format specifiers for general, character, and numeric types have the following syntax:

     %[argument_index$][flags][width][.precision]conversion
   

  The optional argument_index is a decimal integer indicating the position of the argument in the argument list. The first argument is referenced by "1$", the second by "2$", etc.

  The optional flags is a set of characters that modify the output format. The set of valid flags depends on the conversion.

  The optional width is a positive decimal integer indicating the minimum number of characters to be written to the output.

  The optional precision is a non-negative decimal integer usually used to restrict the number of characters. The specific behavior depends on the conversion.

  The required conversion is a character indicating how the argument should be formatted. The set of valid conversions for a given argument depends on the argument's data type.

• The format specifiers for types which are used to represents dates and times have the following syntax:

     %[argument_index$][flags][width]conversion
   

  The optional argument_index, flags and width are defined as above.

  The required conversion is a two character sequence. The first character is 't' or 'T'. The second character indicates the format to be used. These characters are similar to but not completely identical to those defined by GNU date and POSIX strftime(3c).

• The format specifiers which do not correspond to arguments have the following syntax:

     %[flags][width]conversion
   

  The optional flags and width is defined as above.

  The required conversion is a character indicating content to be inserted in the output.

Format Specifier	Data Type	Output
%a	floating point (except BigDecimal)	Returns Hex output of floating point number.
%b	Any type	"true" if non-null, "false" if null
%c	character	Unicode character
%d	integer (incl. byte, short, int, long, bigint)	Decimal Integer
%e	floating point	decimal number in scientific notation
%f	floating point	decimal number
%g	floating point	decimal number, possibly in scientific notation depending on the precision and value.
%h	any type	Hex String of value from hashCode() method.
%n	none	Platform-specific line separator.
%o	integer (incl. byte, short, int, long, bigint)	Octal number
%s	any type	String value
%t	Date/Time (incl. long, Calendar, Date and TemporalAccessor)	%t is the prefix for Date/Time conversions. More formatting flags are needed after this. See Date/Time conversion below.
%x	integer (incl. byte, short, int, long, bigint)	Hex string.

Source : 

https://www.javatpoint.com/java-string-format

https://stackoverflow.com/questions/5762836/what-does-1-mean-when-used-in-string-format-java

https://www.geeksforgeeks.org/format-specifiers-in-java/

[Java 8] Iterating over enum values in java using Java 8 findAny to find from string

public enum ContratType {

CDD,

CDI,

TEMPORARY;

public static ContratType fromString(String type) {

    return Stream.of(ContratType .values())

.filter(typec -> typec.name().equals(type))

.findAny().orElse(null);

}

}

Docker : How to run docker-compose in detached mode ?

 docker-compose -f ymlfile up -d

[Linux] Compresser et décompresser en tar.gz sous Linux

Compresser

 

tar czvf < nom_archive >.tar.gz < nom_rep >    

§  "c" : créer une nouvelle archive

§  "z" : permet d'activer la compression "gzip" pour un taux de compression plus important

§  "v" : mode verbeux, permet d'afficher dans le détail les fichiers compressés

§  "f" : indication de la donnée à compresser

 

Décompresser

 

tar xzvf < nom_archive >.tar.gz

§  "x" : extraire une archive

§  "z" : permet de décompresser le "gzip"

§  "v" : mode verbeux, permet d'afficher dans le détail les fichiers décompressés

§  "f" : indication de la donnée à décompresser 

Maven : Setting MAVEN_OPTS

Configuration de l'utilisation de la mémoire par Maven à partir de Java 8+

-Xmx : pour définir la mémoire MAX

-XX:MaxPermSize : pour d'information sur l'utilité et les modifications à partir de Java 8 + voir cet article : Où est passée la PermGen Java ?

 Linux:

export MAVEN_OPTS="-Xmx1024m -XX:MaxPermSize=1024m"

Windows

set MAVEN_OPTS="-Xmx1024m -XX:MaxPermSize=1024m"



Docker : Running Maven in Docker container via current user as non-root

Maven needs the user home to download artifacts to, and if the user does not exist in the image an extra user.home Java property needs to be set.

For example, to run as user 1000 mounting the host' Maven repo

$ docker run -v ~/.m2:/var/maven/.m2 -ti --rm -u 1000 -e MAVEN_CONFIG=/var/maven/.m2 maven mvn -Duser.home=/var/maven archetype:generate

Source : https://hub.docker.com/_/maven

https://stackoverflow.com/questions/52780802/run-maven-in-docker-container-via-current-user/52781822

Javascript : Object.defineProperty() add a new function property to an Object

 // For example Define the Product class -  the Constructor function 

function Product(id, name, price, expiryDate) {

   this.id = id;

   this.name = name;

   this.price = price;

   this.expiryDate = expiryDate;

  }

// Here, use Object.defineProperty to create property 

Object.defineProperty(Product, 'daysToExpire',{

    get() {

    return this.daysToExpire;

  }});

JavaScript / TypeScript: Object Writbale attribute, have more control on your properties

En JavaScript / TypeScript, chaque propriété d’un objet est liée à un descripteur (qui est lui-même un objet). 

Celui-ci donne plusieurs informations sur une propriété à l'aide la méthode Object.getOwnPropertyDescriptor(): 

• Est-elle configurable? 
• Est-elle énumérable ?
• Est-elle modifiable ? 
• Quelle est sa valeur ?
• etc

Exemple : 

const object1 = {

  property1: 42

};

const descriptor1 = Object.getOwnPropertyDescriptor(object1, 'property1');

console.log(descriptor1.configurable);

// expected output: true

console.log(descriptor1.value);

// expected output: 42

La méthode statique Object.defineProperty() permet de définir une nouvelle propriété ou de modifier une propriété existante, directement sur un objet. 

La méthode renvoie l'objet modifié.

Exemple de modification de proprieté: 

Object.defineProperty(object1, 'property1', {

  value: 42,

  writable: false

});

object1.property1 = 77;

// throws an error in strict mode

console.log(object1.property1);

Quelques cas d'usage pour les test avec Angular :

https://stackoverflow.com/questions/60296340/cannot-assign-to-var-because-it-is-a-read-only-property-in-angular-test-using/61820540#61820540

How to Handle Java 8 Dates and Time with Jackson in Spring Boot (JSR-310)

When you use Spring Boot, you can add the following line to the application.properties file:

spring.jackson.serialization.write-dates-as-timestamps=false

Spring Boot enables the configuration of the default ObjectMapper with properties under the spring.jackson prefix. Read the jackson section in the Spring Boot docs for more info on this.

more details :

https://www.baeldung.com/spring-boot-customize-jackson-objectmapper

https://codeboje.de/jackson-java-8-datetime-handling/

How to Trace Transaction Behavior Details in Spring Boot

To log transaction details in a Spring Boot application simply add the following settings in application.properties:

 logging.level.org.springframework.transaction.interceptor=TRACE

Docker : Dockerfile COPY vs ADD, which one to use?

From Docker Doc : 

ADD or COPY

• Dockerfile reference for the ADD instruction
• Dockerfile reference for the COPY instruction

Although ADD and COPY are functionally similar, generally speaking, COPY is preferred. That’s because it’s more transparent than ADD. COPY only supports the basic copying of local files into the container, while ADD has some features (like local-only tar extraction and remote URL support) that are not immediately obvious. Consequently, the best use for ADD is local tar file auto-extraction into the image, as in ADD rootfs.tar.xz /.

If you have multiple Dockerfile steps that use different files from your context, COPY them individually, rather than all at once. This ensures that each step’s build cache is only invalidated (forcing the step to be re-run) if the specifically required files change.

For example:

COPY requirements.txt /tmp/
RUN pip install --requirement /tmp/requirements.txt
COPY . /tmp/

Results in fewer cache invalidations for the RUN step, than if you put the COPY . /tmp/ before it.

Because image size matters, using ADD to fetch packages from remote URLs is strongly discouraged; you should use curl or wget instead. That way you can delete the files you no longer need after they’ve been extracted and you don’t have to add another layer in your image. For example, you should avoid doing things like:

ADD https://example.com/big.tar.xz /usr/src/things/
RUN tar -xJf /usr/src/things/big.tar.xz -C /usr/src/things
RUN make -C /usr/src/things all

And instead, do something like:

RUN mkdir -p /usr/src/things \
    && curl -SL https://example.com/big.tar.xz \
    | tar -xJC /usr/src/things \
    && make -C /usr/src/things all

For other items (files, directories) that do not require ADD’s tar auto-extraction capability, you should always use COPY.

Source : https://docs.docker.com/develop/develop-images/dockerfile_best-practices/

Only the instructions RUN, COPY, ADD create layers. Other instructions create temporary intermediate images, and do not increase the size of the build.