registros correspondentes com base no Nome de Pessoa

Question

Existem quaisquer ferramentas ou métodos que podem ser usados ??para correspondência pelo nome de uma pessoa entre duas fontes de dados diferentes?

Os sistemas não têm nenhuma outra informação comum e os nomes foram inseridos de forma diferente em muitos casos.

Os exemplos de jogos que não são exatas:

King Jr., Martin Luther = King, Martin (excluir sufixo)
Erving, o Dr. J. = Erving, J. (excluir prefixo)
Obama, Barak Hussein = Obama, Barak (excluir nome do meio)
Pufnstuf, H.R. = Pufnstuf, Haibane Renmei (abreviaturas jogo)
Tankengine, Thomas = Tankengine, Tom (coincidir com apelidos comuns)
Flair, Rick "o Natureboy" = Flair, Natureboy (jogo on nickname)

Answer 1

Eu tive que usar uma variedade de técnicas sugeridas. Graças me apontar na direção certa (s). Esperemos que a seguir ajudará alguém com este tipo de problema para resolver.

Remover caracteres excedentes

CREATE FUNCTION [dbo].[fn_StripCharacters]
(
    @String NVARCHAR(MAX), 
    @MatchExpression VARCHAR(255)
)
RETURNS NVARCHAR(MAX)
AS
BEGIN
    SET @MatchExpression =  '%['+@MatchExpression+']%'

    WHILE PatIndex(@MatchExpression, @String) > 0
        SET @String = Stuff(@String, PatIndex(@MatchExpression, @String), 1, '')

    RETURN @String

END

Uso:

--remove all non-alphanumeric and non-white space  
dbo.fn_StripCharacters(@Value, , '^a-z^0-9 ')  

nome dividida em partes

CREATE FUNCTION [dbo].[SplitTable] (@sep char(1), @sList StringList READONLY)
RETURNS @ResultList TABLE 
    (
        [ID] VARCHAR(MAX),
        [Val] VARCHAR(MAX)
    )
AS
BEGIN

declare @OuterCursor cursor
declare @ID varchar(max)
declare @Val varchar(max)

set @OuterCursor = cursor fast_forward for (SELECT * FROM @sList) FOR READ ONLY

open @OuterCursor

fetch next from @OuterCursor into @ID, @Val

while (@@FETCH_STATUS=0)
begin

    INSERT INTO @ResultList (ID, Val)   
    select @ID, split.s from dbo.Split(@sep, @Val) as split 
           where len(split.s) > 0

    fetch next from @OuterCursor into @ID, @Val
end

close @OuterCursor
deallocate @OuterCursor 

CREATE FUNCTION [dbo].[Split] (@sep char(1), @s varchar(8000))
RETURNS table
AS
RETURN (
    WITH Pieces(pn, start, stop) AS (
      SELECT 1, 1, CHARINDEX(@sep, @s)
      UNION ALL
      SELECT pn + 1, stop + 1, CHARINDEX(@sep, @s, stop + 1)
      FROM Pieces
      WHERE stop > 0
    )
    SELECT pn,
      LTRIM(RTRIM(SUBSTRING(@s, start, 
             CASE WHEN stop > 0 
                  THEN stop-start 
                  ELSE 8000 
             END))) AS s
    FROM Pieces
  )

RETURN

Uso:

--create split name list
DECLARE @NameList StringList 

INSERT INTO @NameList (ID, Val)
SELECT id, firstname FROM dbo.[User] u
WHERE PATINDEX('%[^a-z]%', u.FirstName) > 0 

----remove split dups
select u.ID, COUNT(*)
from dbo.import_SplitTable(' ', @NameList) splitList
INNER JOIN dbo.[User] u
ON splitList.id = u.id

As alcunhas comuns:

Eu criei uma tabela baseada em esta lista e usou-o para se juntar em nome comum equivalentes.

Uso:

SELECT u.id
, u.FirstName
, u_nickname_maybe.Name AS MaybeNickname
, u.LastName
, c.ID AS ContactID from
FROM dbo.[User] u 
INNER JOIN nickname u_nickname_match
ON u.FirstName = u_nickname_match.Name
INNER JOIN nickname u_nickname_maybe
ON u_nickname_match.relatedid = u_nickname_maybe.id
LEFT OUTER JOIN
(
    SELECT c.id, c.LastName, c.FirstName, 
         c_nickname_maybe.Name AS MaybeFirstName
    FROM dbo.Contact c
    INNER JOIN nickname c_nickname_match
    ON c.FirstName = c_nickname_match.Name
    INNER JOIN nickname c_nickname_maybe
    ON c_nickname_match.relatedid = c_nickname_maybe.id
    WHERE c_nickname_match.Name <> c_nickname_maybe.Name
) as c
ON c.AccountHolderID = ah.ID 
       AND u_nickname_maybe.Name = c.MaybeFirstName AND u.LastName = c.LastName
WHERE u_nickname_match.Name <> u_nickname_maybe.Name

algoritmos fonético (Jaro Winkler):

O artigo incrível, Além soundex - Funções para pesquisa fuzzy em MS SQL Server , mostra como instalar e usar o href="http://sourceforge.net/projects/simmetrics/" rel="noreferrer"> SimMetrics biblioteca em SQL Server. Esta biblioteca permite encontrar semelhança relativa entre as cordas e inclui inúmeros algoritmos. Acabei principalmente usando Jaro Winkler para coincidir com os nomes.

Uso:

SELECT
u.id AS UserID
,c.id AS ContactID
,u.FirstName
,c.FirstName 
,u.LastName
,c.LastName
,maxResult.CombinedScores
 from
(
    SELECT
      u.ID
    , 
        max(
            dbo.JaroWinkler(lower(u.FirstName), lower(c.FirstName))  
            * dbo.JaroWinkler(LOWER(u.LastName), LOWER(c.LastName))
        ) AS CombinedScores
    FROM dbo.[User] u, dbo.[Contact] c
    WHERE u.ContactID IS NULL
    GROUP BY u.id
) AS maxResult
INNER JOIN dbo.[User] u
ON maxResult.id  = u.id
INNER JOIN dbo.[Contact] c
ON maxResult.CombinedScores = 
dbo.JaroWinkler(lower(u.FirstName), lower(c.FirstName)) 
* dbo.JaroWinkler(LOWER(u.LastName), LOWER(c.LastName))

Answer 2

É um problema muito complexo - e há um monte de ferramentas caras para fazê-lo corretamente
. Se você já se perguntou por que você não pode check-in em um vôo como Tom, Dick ou Harry (ou Bill)
Ou por que não vôo listas e terroristas assistir listas não funcionam -Considere:

(1) Muammar Kadafi
(2) Mo'ammar Kadafi
(3) Muammar Kaddafi
(4) Muammar Kadafi
(5) Muamar El Kadhafi
(6) Muammar Gadafi
(7) Mu'ammar al-Qadafi
(8) Muamar El Kazzafi
(9) Moamar Kadhafi
(10) Mu'ammar Al Qathafi
(11) Muammar Al Qathafi
(12) Mo'ammar el-Kadafi
(13) Moamar El Kadhafi
(14) Muammar Kadafi
(15) Mu'ammar al-Qadhdhafi
(16) Mu'ammar Qadafi
(17) Moamar Gaddafi
(18) Mu'ammar Qadhdhafi
(19) Muammar Khaddafi
(20) Muammar Khaddafi
(21) Mu'amar al-Kadafi
(22) Muammar Ghaddafy
(23) Muammar Ghadafi
(24) Muammar Kadhafi
(25) Muamar Kadafi
(26) Muammar Quathafi
(27) Muammar Kadafi
(28) Muamar Al-Kaddafi
(29) Moammar Khadafy
(30) Moammar Qudhafi
(31) Mu'ammar al-Kadafi
(32) Mulazim Awwal Mu'ammar Muhammad Abu Minyar Kadafi

E isso é grafias apenas oficiais - não inclui erros

Answer 3

I muitas vezes empregam algoritmos do tipo soundex para este tipo de situação. Tente algoritmo Duplo Metaphone . Se você estiver usando SQL Server, há algum código-fonte para criar uma função definida pelo usuário.

Porque você ter transposto de dados, você pode querer normalizar um pouco, por exemplo, remover todas as vírgulas e as palavras tipo resultantes pela primeira letra. Isso lhe dará algum melhor potencial correspondente. No caso em que as palavras foram adicionados no meio, ele fica um pouco mais difícil. Você poderia considerar quebrar um nome em palavras, verificando com duplo Metaphone se existe uma palavra na outra coluna que partidas, e depois recolher a contagem geral de partidas vs. palavras, que lhe dirá o quão perto as duas colunas são.

Também gostaria de filtrar palavras como Dr., Sr., Sra, etc., antes de fazer as comparações.

Answer 4

Aqui estão algumas opções:

fonético algoritmos ...

Soundex ( http://en.wikipedia.org/wiki/Soundex )

Duplo Metaphone ( http://en.wikipedia.org/wiki/Double_Metaphone )

Editar Distância ( http://en.wikipedia.org/wiki/Levenshtein_distance )

Jaro-Winkler Distância ( http://en.wikipedia.org/wiki/Jaro- Winkler_distance )

Outra coisa que você poderia tentar seria comparar cada palavra (divisão de espaço e talvez hífen) com cada palavra no outro nome e veja quantas palavras combinam. Talvez combinar isso com algoritmos fonéticos para correspondência mais difusa. Para um enorme conjunto de dados, você gostaria de índice de cada palavra e combiná-lo com um nome ID. Para correspondência abreviatura você pode comparar apenas a primeira letra. Você provavelmente vai querer ignorar qualquer coisa, mas as letras quando você comparar as palavras também.

Muitos dos algoritmos fonéticos tem código aberto / amostras online.

Answer 5

Metaphone 3 é a terceira geração do algoritmo Metaphone. Ele aumenta a precisão de codificação fonética do 89% do dobro Metaphone a 98% , conforme testado contra um banco de dados das mais comuns Inglês palavras e nomes e palavras não-Inglês familiares no Norte América. Isso produz uma codificação fonética extremamente confiável para pronúncias americanos.

Metaphone 3 foi projetado e desenvolvido por Lawrence Philips, que projetado e desenvolvido o original Metaphone e Double Metaphone algoritmos.