URL: https://linuxfr.org/users/spacefox/journaux/des-emojis-en-sql-c-est-possible-et-on-peut-aller-au-dela
Title: Des emojis en SQL ? C'est possible... et on peut aller au-delà !
Authors: SpaceFox
Date: 2019年03月09日T12:33:44+01:00
Tags: sql, emoji et postgresql
Score: 31
**Le saviez-vous ?** 
**[On peut utiliser des emojis en SQL](http://baldi.me/blog/emoji-in-sql?)**, et pas seulement pour les manipuler : les emojis peuvent servir d'identifieurs !
Avec PostgreSQL, peut donc faire des choses comme :
```sql
CREATE TABLE 👤(
	🔑 INTEGER PRIMARY KEY,
	🗣 varchar(64), -- name
	🗓 DATE -- date of registration
);
```
Voire carrément :
```sql
CREATE TYPE ⭐ AS ENUM ('🤢', '☹', '😐', '🙂', '😍');
-- [...]
-- select the most common rating for each book
-- MODE() is another function exclusive to PostgreSQL
--- https://wiki.postgresql.org/wiki/Aggregate_Mode
SELECT 📕.💬, MODE() WITHIN GROUP (ORDER BY 👤🏠📕.⭐) AS MostCommonRating
FROM 👤🏠📕 JOIN 📕 ON 👤🏠📕.📕 = 📕.🔑
GROUP BY 📕.🔑;
```
```console
 💬 | mostcommonrating
---------------------------+------------------
 Alice in Wonderland | NULL
 Moby Dick | NULL
 Through the Looking-Glass | 🙂
 Example Book | 😍
```
[Je vous renvoie vers cet article pour les détails](http://baldi.me/blog/emoji-in-sql?), et part du principe que vous l'avez lu dans la suite.
**Mais on peut faire mieux !** 
JPA avec Hibernate permet de gérer _nativement_ ces syntaxes... à condition d'utiliser Kotlin, qui permet d'utiliser les emojis en identifiants.
Le code ci-dessous est donc tout à fait valable, compile et, associé à SpingBoot, démarre :
```kotlin
package fr.spacefox.sqlmoji.model
import javax.persistence.*
@Entity
@Table
data class `✍` (
 @Id
 @GeneratedValue(strategy = GenerationType.IDENTITY)
 val `🔑`: Int,
 @Column(nullable = false, length = 64) val `🗣`: String,
 @OneToMany(mappedBy = "✍") val `📕`: Collection<`📕`>
)
@Entity
@Table
data class `👤` (
 @Id
 @GeneratedValue(strategy = GenerationType.IDENTITY)
 val `🔑`: Int,
 @Column(nullable = false, length = 64) val `🗣`: String,
 @Column val `🗓`: LocalDate,
 @ManyToMany
 @JoinTable(
 name = "👤🏠📕",
 joinColumns = arrayOf(JoinColumn(name = "👤" , referencedColumnName = "🔑")),
 inverseJoinColumns = arrayOf(JoinColumn(name = "📕", referencedColumnName = "🔑")))
 var `📕`: List<`📕`> = mutableListOf()
)
@Entity
@Table
data class `📕` (
 @Id
 @GeneratedValue(strategy = GenerationType.IDENTITY)
 val `🔑`: Int,
 @Column(nullable = false, length = 64) val `💬`: String, // Title
 @Column(length = 64) val `🔖`: String, // Genre/Tag
 @ManyToOne val `✍`: `✍`,
 @ManyToMany(mappedBy = "📕")
 var `👤`: List<`👤`> = mutableListOf()
)
```
La syntaxe bizarre à base d'accents graves autours des emojis[^md] permet d'utiliser un emoji – ou n'importe quel caractère Unicode [qui nécessite plus de 16 bits de représentation](https://en.wikipedia.org/wiki/Universal_Character_Set_characters#Surrogates) – en tant qu'identifiant Kotlin. C'est une spécificité du langage qui n'existe pas à ma connaissance en Java.
[^md]: Et qui visiblement ne peut pas s'échapper correctement avec le markdown LinuxFR.
Et donc, si couple ça à un SpringBoot, au démarrage ça me génère bien une base de données avec la structure suivante :
```sql
create table if not exists "✍"
(
	"🔑" serial not null
		constraint "✍_pkey"
			primary key,
	"🗣" varchar(64) not null
);
create table if not exists "👤"
(
	"🔑" serial not null
		constraint "👤_pkey"
			primary key,
	"🗓" date,
	"🗣" varchar(64) not null
);
create table if not exists "📕"
(
	"🔑" serial not null
		constraint "📕_pkey"
			primary key,
	"💬" varchar(64) not null,
	"🔖" varchar(64),
	"✍_🔑" integer
		constraint fk6bj8134ailsb7wn0rxoxra7t1
			references "✍"
);
create table if not exists "👤🏠📕"
(
	"👤" integer not null
		constraint fktm4c4ip5pvf57bj4fvq9xb4jk
			references "👤",
	"📕" integer not null
		constraint fkqpp0i83yuug00b7rhkbl55m6d
			references "📕"
);
```
**Et... ça s'arrête là.**
Si JPA et Hibernate gèrent très bien ce genre de fantaisie, c'est à peu près les seules bibliothèques dont c'est le cas. Toute tentative d'utiliser SpringBoot et ses outils REST avec des classes au nom aussi exotique se solde par un échec.
Ça vient probablement du fait qu'en interne Java utilise une variante d'UTF-16, et que tout ça implique des caractères que l'on ne peut pas représenter avec un seul bloc de 16 bits.
Et c'est probablement mieux comme ça.
----------
Ce contenu, [placé sous licence CC BY 4.0](https://creativecommons.org/licenses/by/4.0/), est une adaptation [de ce billet publié sur Zeste de Savoir](https://zestedesavoir.com/billets/3081/des-emojis-en-sql-cest-possible-et-on-peut-aller-au-dela/).
</div><div class="naked_ctrl">
<form action="/index.cgi/contrast" method="get" name="gate">
<p><a href="http://altstyle.alfasado.net">AltStyle</a> によって変換されたページ <a href="httpS://linuxfr.org/users/spacefox/journaux/des-emojis-en-sql-c-est-possible-et-on-peut-aller-au-dela.md">(-&gt;オリジナル)</a>
/ <label>アドレス: <input type="text" name="naked_post_url" value="httpS://linuxfr.org/users/spacefox/journaux/des-emojis-en-sql-c-est-possible-et-on-peut-aller-au-dela.md" size="22" /></label> <label>モード: <select name="naked_post_mode">
<option value="default">デフォルト</option>
<option value="speech">音声ブラウザ</option>
<option value="ruby">ルビ付き</option>
<option value="contrast" selected="selected">配色反転</option>
<option value="larger-text">文字拡大</option>
<option value="mobile">モバイル</option>
</select>
<input type="submit" value="表示" />
</p>
</form>
</div>