Fractionner la valeur d'un champ à deux

J'ai un champ de table membernamequi contient à la fois le nom et le prénom des utilisateurs. Est - il possible de diviser les champs en 2 memberfirst, memberlast?

Tous les enregistrements ont ce format "Prénom Nom" (sans guillemets et espace entre les deux).

Malheureusement, MySQL ne propose pas de fonction de chaîne fractionnée. Cependant, vous pouvez créer une fonction définie par l'utilisateur pour cela, telle que celle décrite dans l'article suivant:

• Fonction de chaîne fractionnée MySQL par Federico Cargnelutti

Avec cette fonction:

DELIMITER $$

CREATE FUNCTION SPLIT_STR(
  x VARCHAR(255),
  delim VARCHAR(12),
  pos INT
)
RETURNS VARCHAR(255) DETERMINISTIC
BEGIN 
    RETURN REPLACE(SUBSTRING(SUBSTRING_INDEX(x, delim, pos),
       LENGTH(SUBSTRING_INDEX(x, delim, pos -1)) + 1),
       delim, '');
END$$

DELIMITER ;

vous pourriez créer votre requête comme suit:

SELECT SPLIT_STR(membername, ' ', 1) as memberfirst,
       SPLIT_STR(membername, ' ', 2) as memberlast
FROM   users;

Si vous préférez ne pas utiliser de fonction définie par l'utilisateur et que la requête ne vous dérange pas d'être un peu plus verbeuse, vous pouvez également effectuer les opérations suivantes:

SELECT SUBSTRING_INDEX(SUBSTRING_INDEX(membername, ' ', 1), ' ', -1) as memberfirst,
       SUBSTRING_INDEX(SUBSTRING_INDEX(membername, ' ', 2), ' ', -1) as memberlast
FROM   users;

Variante SELECT (ne crée pas de fonction définie par l'utilisateur):

SELECT IF(
        LOCATE(' ', `membername`) > 0,
        SUBSTRING(`membername`, 1, LOCATE(' ', `membername`) - 1),
        `membername`
    ) AS memberfirst,
    IF(
        LOCATE(' ', `membername`) > 0,
        SUBSTRING(`membername`, LOCATE(' ', `membername`) + 1),
        NULL
    ) AS memberlast
FROM `user`;

Cette approche prend également en charge:

• les valeurs du nom de membre sans espace : il ajoutera la chaîne entière à memberfirst et définit memberlast à NULL.
• les valeurs de nom de membre qui ont plusieurs espaces : il ajoutera tout avant le premier espace à memberfirst et le reste (y compris les espaces supplémentaires) à memberlast.

La version UPDATE serait:

UPDATE `user` SET
    `memberfirst` = IF(
        LOCATE(' ', `membername`) > 0,
        SUBSTRING(`membername`, 1, LOCATE(' ', `membername`) - 1),
        `membername`
    ),
    `memberlast` = IF(
        LOCATE(' ', `membername`) > 0,
        SUBSTRING(`membername`, LOCATE(' ', `membername`) + 1),
        NULL
    );

Il semble que les réponses existantes sont trop compliquées ou pas une réponse stricte à la question particulière.

Je pense que la réponse simple est la requête suivante:

SELECT
    SUBSTRING_INDEX(`membername`, ' ', 1) AS `memberfirst`,
    SUBSTRING_INDEX(`membername`, ' ', -1) AS `memberlast`
;

Je pense qu'il n'est pas nécessaire de traiter des noms de plus de deux mots dans cette situation particulière. Si vous voulez le faire correctement, le fractionnement peut être très difficile voire impossible dans certains cas:

• Johann Sebastian Bach
• Johann Wolfgang von Goethe
• Edgar Allan Poe
• Jakob Ludwig Felix Mendelssohn-Bartholdy
• Petőfi Sándor
• 澤黒明

Dans une base de données bien conçue, les noms humains doivent être stockés à la fois en partie et en totalité. Ce n'est pas toujours possible, bien sûr.

Si vous prévoyez de le faire dans le cadre d'une requête, veuillez ne pas le faire ^(a) . Sérieusement, c'est un tueur de performances. Il peut y avoir des situations où vous ne vous souciez pas des performances (comme des tâches de migration ponctuelles pour diviser les champs permettant de meilleures performances à l'avenir) mais, si vous le faites régulièrement pour autre chose qu'une base de données mickey-mouse, vous gaspillent des ressources.

Si jamais vous ne devez traiter qu'une partie d'une colonne d'une manière ou d'une autre, la conception de votre base de données est défectueuse. Cela peut très bien fonctionner sur un carnet d'adresses personnel ou une application de recette ou sur l'une des myriades d'autres petites bases de données, mais il ne sera pas évolutif pour des systèmes «réels».

Stockez les composants du nom dans des colonnes séparées. Il est presque invariablement beaucoup plus rapide de joindre des colonnes avec une simple concaténation (lorsque vous avez besoin du nom complet) que de les séparer avec une recherche de caractères.

Si, pour une raison quelconque, vous ne pouvez pas diviser le champ, mettez au moins les colonnes supplémentaires et utilisez un déclencheur d'insertion / mise à jour pour les remplir. Bien que ce ne soit pas 3NF, cela garantira que les données sont toujours cohérentes et accélérera massivement vos requêtes. Vous pouvez également vous assurer que les colonnes supplémentaires sont en minuscules (et indexées si vous les recherchez) en même temps afin de ne pas avoir à manipuler les problèmes de cas.

Et, si vous ne pouvez même pas ajouter les colonnes et les déclencheurs, sachez (et informez votre client, si c'est pour un client) qu'il n'est pas évolutif.

^(a) Bien sûr, si votre intention est d'utiliser cette requête pour corriger le schéma afin que les noms soient placés dans des colonnes distinctes dans la table plutôt que dans la requête, je considérerais cela comme une utilisation valide. Mais je le répète, le faire dans la requête n'est pas vraiment une bonne idée.

utilisez ceci

SELECT SUBSTRING_INDEX(SUBSTRING_INDEX( `membername` , ' ', 2 ),' ',1) AS b, 
SUBSTRING_INDEX(SUBSTRING_INDEX( `membername` , ' ', -1 ),' ',2) AS c FROM `users` WHERE `userid`='1'

Je ne répondais pas exactement à la question, mais face au même problème, j'ai fini par faire ceci:

UPDATE people_exit SET last_name = SUBSTRING_INDEX(fullname,' ',-1)
UPDATE people_exit SET middle_name = TRIM(SUBSTRING_INDEX(SUBSTRING_INDEX(fullname,last_name,1),' ',-2))
UPDATE people_exit SET middle_name = '' WHERE CHAR_LENGTH(middle_name)>3 
UPDATE people_exit SET first_name = SUBSTRING_INDEX(fullname,concat(middle_name,' ',last_name),1)
UPDATE people_exit SET first_name = middle_name WHERE first_name = ''
UPDATE people_exit SET middle_name = '' WHERE first_name = middle_name

Dans MySQL, cette option fonctionne:

SELECT Substring(nameandsurname, 1, Locate(' ', nameandsurname) - 1) AS 
       firstname, 
       Substring(nameandsurname, Locate(' ', nameandsurname) + 1)    AS lastname 
FROM   emp  

Le seul cas où vous voudrez peut-être une telle fonction est une requête UPDATE qui modifiera votre table pour stocker le prénom et le nom dans des champs séparés.

La conception de la base de données doit suivre certaines règles, et la normalisation de la base de données est parmi les plus importantes

J'avais une colonne où le prénom et le nom étaient tous les deux dans une colonne. Le prénom et le nom étaient séparés par une virgule. Le code ci-dessous a fonctionné. Il n'y a AUCUNE vérification / correction d'erreur. Juste une scission stupide. Utilisé phpMyAdmin pour exécuter l'instruction SQL.

UPDATE tblAuthorList SET AuthorFirst = SUBSTRING_INDEX(AuthorLast,',',-1) , AuthorLast = SUBSTRING_INDEX(AuthorLast,',',1);

13.2.10 Syntaxe UPDATE

Cela prend smhg d'ici et curt's from Last index d'une sous-chaîne donnée dans MySQL et les combine. Ceci est pour mysql, tout ce dont j'avais besoin était d'obtenir une répartition décente du nom en prénom nom_nom avec le nom de famille un seul mot, le prénom tout avant ce mot unique, où le nom pourrait être nul, 1 mot, 2 mots ou plus de 2 mots. Ie: Null; Marie; Mary Smith; Mary A. Smith; Mary Sue Ellen Smith;

Donc, si nom est un mot ou nul, last_name est nul. Si nom est> 1 mot, last_name est le dernier mot et first_name tous les mots avant le dernier mot.

Notez que j'ai déjà coupé des trucs comme Joe Smith Jr.; Joe Smith Esq. et ainsi de suite, manuellement, ce qui était douloureux, bien sûr, mais c'était assez petit pour le faire, vous voulez donc vous assurer de bien regarder les données dans le champ de nom avant de décider de la méthode à utiliser.

Notez que cela réduit également le résultat, de sorte que vous ne vous retrouvez pas avec des espaces devant ou après les noms.

Je publie juste ceci pour d'autres qui pourraient chercher ce dont j'avais besoin sur Google. Cela fonctionne, bien sûr, testez-le d'abord avec le select.

C'est une chose ponctuelle, donc je me fiche de l'efficacité.

SELECT TRIM( 
    IF(
        LOCATE(' ', `name`) > 0,
        LEFT(`name`, LENGTH(`name`) - LOCATE(' ', REVERSE(`name`))),
        `name`
    ) 
) AS first_name,
TRIM( 
    IF(
        LOCATE(' ', `name`) > 0,
        SUBSTRING_INDEX(`name`, ' ', -1) ,
        NULL
    ) 
) AS last_name
FROM `users`;


UPDATE `users` SET
`first_name` = TRIM( 
    IF(
        LOCATE(' ', `name`) > 0,
        LEFT(`name`, LENGTH(`name`) - LOCATE(' ', REVERSE(`name`))),
        `name`
    ) 
),
`last_name` = TRIM( 
    IF(
        LOCATE(' ', `name`) > 0,
        SUBSTRING_INDEX(`name`, ' ', -1) ,
        NULL
    ) 
);

Méthode que j'avais utilisée pour diviser first_name en first_name et last_name lorsque les données arrivaient toutes dans le champ first_name. Ceci ne mettra que le dernier mot dans le champ du nom, donc "john phillips sousa" sera le prénom "john phillips" et le nom de famille "sousa". Cela évite également d'écraser les enregistrements qui ont déjà été corrigés.

set last_name=trim(SUBSTRING_INDEX(first_name, ' ', -1)), first_name=trim(SUBSTRING(first_name,1,length(first_name) - length(SUBSTRING_INDEX(first_name, ' ', -1)))) where list_id='$List_ID' and length(first_name)>0 and length(trim(last_name))=0

UPDATE `salary_generation_tbl` SET
    `modified_by` = IF(
        LOCATE('$', `other_salary_string`) > 0,
        SUBSTRING(`other_salary_string`, 1, LOCATE('$', `other_salary_string`) - 1),
        `other_salary_string`
    ),
    `other_salary` = IF(
        LOCATE('$', `other_salary_string`) > 0,
        SUBSTRING(`other_salary_string`, LOCATE('$', `other_salary_string`) + 1),
        NULL
    );

mysql 5.4 fournit une fonction de partage native:

SPLIT_STR(<column>, '<delimiter>', <index>)