0Pricing
Coding Interview Prep · Leçon

Nombre de colonnes et compatibilité des types

Les règles que les ensembles de résultats doivent respecter pour être combinés et les erreurs courantes d’incompatibilité

Nombre de colonnes et compatibilité des types est une leçon Coding Interview Prep gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Coding Interview Prep, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Coding Interview Prep comprend 4 leçons au total.

Les règles de compatibilité vérifiées en entretien

Toute opération ensembliste (UNION, INTERSECT, EXCEPT) exige que les deux ensembles de résultats soient compatibles avec les opérations ensemblistes. Les recruteurs posent cette question pour vérifier que vous connaissez les façons discrètes dont ces requêtes peuvent échouer.

Deux règles déterminent la compatibilité : le même nombre de colonnes et des types de données compatibles, position par position. Si l'une ou l'autre règle n'est pas respectée, vous obtenez une erreur ou un résultat surprenant.

Règle 1 : même nombre de colonnes

Les deux requêtes doivent renvoyer le même nombre de colonnes. Si la première requête renvoie trois colonnes et la deuxième en renvoie deux, la base de données rejette l'instruction.

C'est l'erreur d'opération ensembliste la plus fréquente en entretien, notamment lorsqu'une personne modifie une branche et oublie l'autre.

SELECT id, name, city FROM a
UNION
SELECT id, name FROM b;
-- ERROR: each UNION query must have the same number of columns

Règle 2 : types compatibles selon la position

Les colonnes sont associées par position, et non par nom. La première colonne de la première requête est associée à la première colonne de la deuxième requête, et ainsi de suite. Chaque paire doit avoir des types compatibles.

Compatible signifie généralement convertible implicitement : un INT et un BIGINT conviennent ; un INT et une DATE ne conviennent généralement pas.

SELECT id, signup_date FROM a
UNION
SELECT id, signup_date FROM b;
-- positions: (int,date) vs (int,date) -> OK

C'est la position, et non le nom, qui compte

Un piège subtil : les colonnes peuvent avoir des noms différents et tout de même être combinées, à condition que leurs positions correspondent et que leurs types soient compatibles. À l'inverse, des noms identiques dans le mauvais ordre désaligneront les données.

Lisez toujours les opérations ensemblistes colonne par colonne. Les recruteurs intervertissent volontairement des colonnes pour vérifier ce point.

SELECT name, id FROM a
UNION ALL
SELECT id, name FROM b;
-- name<->id swapped: types may clash or data lands in wrong column

Les noms des colonnes de sortie

L'ensemble de résultats prend ses noms de colonnes dans la première requête. Les libellés de la deuxième requête sont supprimés. Pour contrôler les en-têtes, donnez un alias aux colonnes de la première branche.

C'est pourquoi un ORDER BY en aval doit utiliser les noms de la première requête ou des positions ordinales.

SELECT id AS user_id, city AS location FROM a
UNION ALL
SELECT id, town FROM b;
-- output headers: user_id, location

Conversion implicite des types

Lorsque deux colonnes associées par position ont des types différents mais compatibles, le moteur choisit un type de résultat suffisamment large pour contenir les deux. La combinaison d'un INT et d'un DECIMAL produit généralement un DECIMAL.

Mentionner cette conversion en entretien montre votre maîtrise du sujet : vous savez que la colonne ne provoque pas d'erreur, mais qu'elle est convertie vers le type plus large.

SELECT amount FROM int_table   -- INT
UNION ALL
SELECT amount FROM dec_table;  -- DECIMAL
-- result column is DECIMAL

Compléter les colonnes manquantes avec NULL

Lorsque deux requêtes ont naturellement des structures différentes, vous pouvez les aligner en ajoutant des colonnes de remplissage. Une technique courante consiste à sélectionner NULL (souvent en le convertissant dans un type) pour remplir un emplacement présent dans l'autre branche.

Convertir NULL évite que le moteur devine un type et garantit la compatibilité des colonnes.

SELECT id, phone, CAST(NULL AS VARCHAR) AS email FROM a
UNION ALL
SELECT id, CAST(NULL AS VARCHAR), email FROM b;

Un échec dû à une incompatibilité de types

Ici, la deuxième colonne contient une date dans une branche et une chaîne de caractères dans l'autre. Les moteurs stricts rejettent cette requête ; les moteurs permissifs peuvent effectuer une conversion imprévisible. La solution sûre consiste à utiliser un CAST explicite afin que les deux côtés utilisent le même type.

En entretien, proposez la conversion explicite plutôt que de vous appuyer sur une conversion implicite.

SELECT id, CAST(event_date AS VARCHAR) FROM a
UNION ALL
SELECT id, label FROM b;
-- both second columns now VARCHAR -> compatible

Ces règles s'appliquent à tous les opérateurs ensemblistes

Les règles concernant le nombre de colonnes et la compatibilité des types sont identiques pour UNION, UNION ALL, INTERSECT et EXCEPT. Tous empilent verticalement les ensembles de résultats et exigent des entrées compatibles avec les opérations ensemblistes.

Une seule liste mentale suffit donc pour toute opération ensembliste : compter les colonnes, vérifier les types par position et contrôler les noms à partir de la première requête.

SELECT id, city FROM a
INTERSECT
SELECT id, city FROM b;
-- same compatibility rules as UNION

La vérification préalable

Avant de combiner des ensembles de résultats, vérifiez les points suivants :

  • Le même nombre de colonnes dans chaque branche.
  • Chaque paire associée par position possède des types compatibles (utilisez une conversion explicite en cas de doute).
  • Les colonnes sont dans le même ordre logique.
  • Les alias sont définis dans la première requête pour obtenir des noms de sortie clairs.

Énoncer cette liste de vérification à voix haute en entretien permet d'éviter les erreurs silencieuses de désalignement.

Assembler le tout

Les problèmes de compatibilité sont pour la plupart évitables. Les erreurs sont visibles lorsque le nombre de colonnes diffère, mais restent discrètes lorsque les colonnes sont interverties ou converties de manière inattendue. Lire les requêtes colonne par colonne et effectuer les conversions délibérément permet de conserver des opérations ensemblistes correctes.

Une réponse assurée énonce les deux règles, mentionne l'association par position et précise que les noms de sortie proviennent de la première requête.

Vérification rapide

Comment SQL détermine-t-il quelles colonnes des deux branches UNION correspondent l'une à l'autre ?

Récapitulatif

Points essentiels :

  • Tous les opérateurs ensemblistes exigent le même nombre de colonnes dans chaque branche.
  • Les colonnes sont associées par position, et chaque paire doit avoir des types compatibles.
  • Les types compatibles peuvent être convertis vers un type commun plus large.
  • Utilisez CAST(NULL AS type) pour compléter des structures différentes.
  • Les noms de sortie proviennent de la première requête.

Questions Fréquemment Posées

La leçon « Nombre de colonnes et compatibilité des types » est-elle gratuite ?

Oui — le texte complet de « Nombre de colonnes et compatibilité des types » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Coding Interview Prep, passe à CoddyKit PRO. Le cours Coding Interview Prep comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Nombre de colonnes et compatibilité des types » ?

Les règles que les ensembles de résultats doivent respecter pour être combinés et les erreurs courantes d’incompatibilité Tu pratiques Coding Interview Prep avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Coding Interview Prep ?

Aucune expérience préalable n'est requise. Coding Interview Prep sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Nombre de colonnes et compatibilité des types » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Coding Interview Prep ?

Oui. Chaque leçon Coding Interview Prep inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. UNION ou UNION ALL
  2. Nombre de colonnes et compatibilité des types
  3. INTERSECT et EXCEPT pour comparer
  4. Émuler les opérations ensemblistes avec des jointures
← Retour à Coding Interview Prep