Analisar o impacto de migração de dados do banco de produção do Perícias para a nova estrutura do banco, considerando a parte de cadastros

Data de elaboração	29/06/2023
Responsável pelo estudo	Raissa de Sousa Stodulski Taillon Miguel Gonçalves Ádelle Camarão Monteiro
Equipe do estudo	Tambakiss
Alvo	Perícia Médica
Origem	Objetivo estratégico, para identificar o impacto da migração de dados de produção para a nova base.
Objetivo	Com a análise do impacto, definir alterações estruturais ou tratamentos a serem realizados a fim melhorar a migração.
Documentação correlata (opcional)
Observações

1. Introdução

O sistema de Perícia Médica é o sistema responsável pelo controle, elaboração e compartilhamento de atas e laudos realizados por peritos médicos do CEPEM. Diante da necessidade de realizar a migração de dados de produção para a nova base, foi necessário analisar o impacto que a mesma acarretaria.

2. Desenvolvimento

Após uma análise realizada, foi levantado as seguintes informações.

2.1 Estruturas (DE-PARA)
Conforme planilha que pode ser acessada via link.

Novo Perícia
Tabela	Campo	Tipo	Nullable?	Valor	Tratar no sistema
Leis	Id	uniqueidentifier	Não	GUID
	Numero	nvarchar(40)	Não	Sem tratamento específico	Somentes números?
	Descricao	nvarchar(200)	Não	Sem tratamento específico	Tudo em CAPS?
	Ativo	bit	Não
	DataDaLei	datetime2	Não
	Texto	nvarchar(500)	Não	Sem tratamento específico

Antigo Perícia
Tabela	Campo	Nullable?	Valor	Tratado?	Count
LEI	COD_LEI	bigint	Não		27
	NUM_LEI	varchar(20)	Não	Letra e número; Tudo em CAPS
	DES_LEI	varchar(100)	Não	Letra e número; Tudo em CAPS
	IND_ATIVO	varchar(1)	Não	S-Ativo
	DAT_LEI	datetime	Não
	TXT_LEI	varchar(-1)	Não	Letra e número; Tudo em CAPS

Observações sobre a tabela de lei: novo perícias não possui padronização de texto (tudo em CAPS)

Novo Perícia
Tabela	Campo	Tipo	Nullable?	Valor	Tratar no sistema
TiposDeLicenca	Id	uniqueidentifier	Não	GUID
	LeiId	uniqueidentifier	Não
	Ativo	bit	Não
	Descricao	nvarchar	Não	Sem tratamento específico	Tudo em CAPS?

Antigo Perícia
Tabela	Campo	Nullable?	Valor	Tratado?	Count
TIPO_LICENCA	COD_TIPO_LICENCA	bigint	Não		34
	COD_LEI	bigint	Sim
	IND_ATIVO	char	Não	S-Ativo
	DES_TIPO_LICENCA	varchar(100)	Não	Letra e número; Tudo em CAPS

Observações sobre a tabela de tipo de licença: nenhuma.

Novo Perícia
Tabela	Campo	Tipo	Nullable?	Valor	Tratar no sistema
UnidadesPericiais	Id	uniqueidentifier	Não	GUID
	Nome	nvarchar(200)	Não	Sem tratamento específico	Tudo em CAPS?
	Ativo	bit	Não
	Telefone	nvarchar(-1)	Sim	Sem tratamento específico
	Celular	nvarchar(-1)	Sim	Sem tratamento específico
	EnderecoId	int	Sim
	HorarioDeFuncionamentoId	int	Sim
	HorarioPadraoId	int	Sim
Enderecos	Id	int	Não
	Cep	nvarchar(20)	Sim	Sem tratamento específico	Sem máscara?
	Municipio	nvarchar(100)	Sim	Sem tratamento específico
	Uf	nvarchar(4)	Sim	Sem tratamento específico
	Logradouro	nvarchar(100)	Sim	Sem tratamento específico
	Numero	nvarchar(20)	Sim	Sem tratamento específico
	Bairro	nvarchar(100)	Sim	Sem tratamento específico
	Complemento	nvarchar(100)	Sim	Sem tratamento específico
HorariosDeFuncionamento	Id	int	Não
	HorarioInicial	nvarchar(10)	Não	Formatado hh:mm
	HorarioFinal	nvarchar(10)	Não	Formatado hh:mm
	Domingo	bit	Não
	Segunda	bit	Não
	Terca	bit	Não
	Quarta	bit	Não
	Quinta	bit	Não
	Sexta	bit	Não
	Sabado	bit	Não
HorariosPadroes	Id	int	Não
	Duracao	nvarchar(10)	Não	Formatado hh:mm
	HorarioInicialManha	nvarchar(10)	Não	Formatado hh:mm
	HorarioFinalManha	nvarchar(10)	Não	Formatado hh:mm
	HorarioInicialTarde	nvarchar(10)	Não	Formatado hh:mm
	HorarioFinalTarde	nvarchar(10)	Sim	Formatado hh:mm

Antigo Perícia
Tabela	Campo	Nullable?	Valor	Tratado?	Count
UNIDADE_PERICIONAL	COD_UNIDADE_PERICIONAL	bigint	no		5
	NOM_UNIDADE_PERICIONAL	varchar(100)	no	Sem tratamento específico
	IND_ATIVO	char	no	S-Ativo
	NUM_TELEFONE	varchar(20)	yes	Quando preenchido, formatado com DDD
	NUM_CELULAR	varchar(20)	yes	Quando preenchido, formatado com DDD
	PUXAR VIA SCRIPT (EnderecoId)
	PUXAR VIA SCRIPT (HorarioDeFuncionamentoId)
	PUXAR VIA SCRIPT (HorarioPadraoId)
	GERAR VIA SCRIPT (Id (Endereço))
	NUM_CEP	varchar(8)	yes	Sem formatação, sem máscara
	COD_MUNICIPIO	bigint	yes
	COD_UF	bigint	yes
	COD_LOGRADOURO	bigint	yes
	NUM_NUMERO	varchar(50)	yes	Sem tratamento específico
	COD_BAIRRO	bigint	yes
	TXT_COMPLEMENTO	varchar(100)	yes	Sem tratamento específico
	GERAR VIA SCRIPT
	HOR_INICIO_UNIDADE	varchar(5)	yes	Formatado hh:mm (mas sem o primeiro zero)
	HOR_FIM_UNIDADE	varchar(5)	yes	Formatado hh:mm (mas sem o primeiro zero)
	IND_DOMINGO	char	yes	S-Sim
	IND_SEGUNDA	char	yes	S-Sim
	IND_TERCA	char	yes	S-Sim
	IND_QUARTA	char	yes	S-Sim
	IND_QUINTA	char	yes	S-Sim
	IND_SEXTA	char	yes	S-Sim
	IND_SABADO	char	yes	S-Sim
	GERAR VIA SCRIPT
	DURACAO_CONSULTA	varchar(5)	yes	Formatado hh:mm (mas sem o primeiro zero)
	HOR_INICIO_MANHA_PROFISSIONAL	varchar(5)	yes	Formatado hh:mm (mas sem o primeiro zero)
	HOR_FIM_MANHA_PROFISSIONAL	varchar(5)	yes	Formatado hh:mm (mas sem o primeiro zero)
	HOR_INICIO_TARDE_PROFISSIONAL	varchar(5)	yes	Formatado hh:mm (mas sem o primeiro zero)
	HOR_FIM_TARDE_PROFISSIONAL	varchar(5)	yes	Formatado hh:mm (mas sem o primeiro zero)

Observações sobre a tabela de tipo de licença: os campos de endereço se repetem em outras tabelas (perícia novo), campos de identificador único e chave estrangeiras precisam de ações com script.

Novo Perícia
Tabela	Campo	Tipo	Nullable?	Valor	Tratar no sistema
Cargos	Id	uniqueidentifier	Não	GUID
	EntidadeId	uniqueidentifier	Não
	Ativo	bit	Não
	Codigo	nvarchar(-1)	Sim	Sem tratamento específico	Somentes números?
	Descricao	nvarchar(-1)	Não	Sem tratamento específico	Tudo em CAPS?

Antigo Perícia
Tabela	Campo	Nullable?	Valor	Tratado?	Count
CARGO	ID_CARGO	bigint	Não		4909
	COD_ENTIDADE	bigint	Não
	IND_ATIVO	char	Não	S-Ativo
	COD_CARGO	varchar(10)	Sim	Somente números
	DES_CARGO	varchar(100)	Não	Sem tratamento específico

Observações sobre a tabela de Cargos: nenhuma.

Novo Perícia
Tabela	Campo	Tipo	Nullable?	Valor	Tratar no sistema
AreasMedicas	Id	uniqueidentifier	Não	GUID
	Descricao	nvarchar(200)	Não	Sem tratamento específico	Tudo em CAPS?
	Ativo	bit	Não

Antigo Perícia
Tabela	Campo	Nullable?	Valor	Tratado?	Count
AREA_MEDICA	COD_AREA_MEDICA	bigint	Não		3
	DES_AREA_MEDICA	varchar(100)	Não	Sem tratamento específico
	IND_ATIVO	varchar(1)	Não	S-Ativo, N-Inativo

Observações sobre a tabela de Áreas médicas: nenhuma.

Novo Perícia
Tabela	Campo	Tipo	Nullable?	Valor	Tratar no sistema
Profissionais	Id	uniqueidentifier	Não	GUID
	EnderecoId	int	Não
	DadoPessoalId	uniqueidentifier	Não	GUID
DadosPessoais	NomeCompleto	nvarchar(200)	Não	Sem tratamento específico	Tudo em CAPS?
Profissionais	Ativo	bit	Não
DadosPessoais	Cpf	nvarchar(22)	Não	Sem máscara
	Rg	nvarchar(20)	Não	Sem tratamento específico	Somentes números?
	DataDeNascimento	datetime2	Não
	Telefone	nvarchar(22)	Sim	Sem tratamento específico	Somentes números?
	Celular	nvarchar(22)	Sim	Sem tratamento específico	Somentes números?
Profissionais	NumeroDoConselho	nvarchar(20)	Não	Sem tratamento específico	Somente números?
API Perfil - Sem banco - Via API
Profissionais	AreaMedicaId	uniqueidentifier	Não
Enderecos	Id	int	Não
	Cep	nvarchar(20)	Sim	Sem tratamento específico	Sem máscara?
	Municipio	nvarchar(100)	Sim	Sem tratamento específico
	Uf	nvarchar(4)	Sim	Sem tratamento específico
	Logradouro	nvarchar(100)	Sim	Sem tratamento específico
	Numero	nvarchar(20)	Sim	Sem tratamento específico
	Bairro	nvarchar(100)	Sim	Sem tratamento específico
	Complemento	nvarchar(100)	Sim	Sem tratamento específico
AgendasDosProfissionais	Id	uniqueidentifier	Não	GUID
	UnidadePericialId	uniqueidentifier	Não	GUID
	ProfissionalId	uniqueidentifier	Não	GUID
DiasDaSemanaDasAgendas	Id	uniqueidentifier	Não	GUID
	AgendaDoProfissionalId	uniqueidentifier	Não	GUID
	DiaDaSemana	int	Não	enum
	HorarioInicialManha	datetime2	Sim
	HorarioFinalManha	datetime2	Sim
	HorarioInicialTarde	datetime2	Sim
	HorarioFinalTarde	datetime2	Sim

Antigo Perícia
Tabela	Campo	Nullable?	Valor	Tratado?	Count
PROFISSIONAL (WHERE IND_TIPO_PROFISSIONAL = MED)	COD_PROFISSIONAL	bigint	no		121 (109)
	PUXAR VIA SCRIPT (EnderecoId)
	PUXAR VIA SCRIPT (DadoPessoalId)
	NOM_PROFISSIONAL	varchar(100)	no	Maioria em CAPS mas sem tratamento específico
	IND_ATIVO	char	no	S-Ativo
	NUM_CPF	varchar(11)	no	Somente números
	NUM_RG	varchar(14)	no	Somente números
	DAT_NASCIMENTO	datetime	yes
	NUM_TELEFONE	varchar(20)	yes	Sem máscara
	NUM_CELULAR	varchar(20)	yes	Sem máscara
	NUM_CONSELHO	varchar(20)	yes	Letra e número; Tudo em CAPS
	IND_TIPO_PERFIL	char	yes	MED; NULL
	COD_AREA_MEDICA	bigint	yes
	GERAR VIA SCRIPT (Id (Endereço))
	NUM_CEP	char(8)	yes	Sem máscara
	COD_MUNICIPIO	bigint	yes
	COD_UF	bigint	yes
	COD_LOGRADOURO	bigint	yes
	NUM_NUMERO	varchar(50)	yes	Sem tratamento específico
	COD_BAIRRO	bigint	yes
	TXT_COMPLEMENTO	varchar(100)	yes	Sem tratamento específico
PROFISSIONAL_AGENDA (PROFISSIONAL_UNIDADE_PERICIAL)	GERAR VIA SCRIPT (Id (Agenda do profissional))				330 (68)
	COD_UNIDADE_PERICIONAL	bigint	no	PROFISSIONAL_UNIDADE_PERICIAL
	COD_PROFISSIONAL	bigint	no	PROFISSIONAL_UNIDADE_PERICIAL
	GERAR VIA SCRIPT (Id (Dias da semana)))
	PUXAR VIA SCRIPT (AgendaDoProfissionalId)
	IND_DIA_SEMANA	varchar	yes
	HOR_INICIO_MANHA	varchar(5)	yes	Formatado hh:mm (mas sem o primeiro zero)
	HOR_FIM_MANHA	varchar(5)	yes	Formatado hh:mm (mas sem o primeiro zero)
	HOR_INICIO_TARDE	varchar(5)	yes	Formatado hh:mm (mas sem o primeiro zero)
	HOR_FIM_TARDE	varchar(5)	yes	Formatado hh:mm (mas sem o primeiro zero)

Observações sobre a tabela de Profissional: campos de identificador único e chave estrangeiras precisam de ações com script.

Novo Perícia
Tabela	Campo	Tipo	Nullable?	Valor	Tratar no sistema
Lotacoes	Id	uniqueidentifier	Não	GUID
	EntidadeId	uniqueidentifier	Não
	Ativo	bit	Não
	Nome	nvarchar(100)	Não	Sem tratamento específico	Tudo em CAPS?
	Codigo	nvarchar(200)	Não	Sem tratamento específico	Somentes números?

Antigo Perícia
Tabela	Campo	Nullable?	Valor	Tratado?	Count
LOTACAO	ID_LOTACAO	bigint	no		103706
	COD_ENTIDADE	bigint	no
	IND_ATIVO	char	no	S-Ativo
	NOM_LOTACAO	varchar(100)	no	Sem tratamento específico
	COD_LOTACAO	varchar(10)	yes	Somente números

Observações sobre a tabela de Lotação: nenhuma.

Novo Perícia
Tabela	Campo	Tipo	Nullable?	Valor	Tratar no sistema
LocaisDeTrabalho	Id	uniqueidentifier	Não	GUID
	EntidadeId	uniqueidentifier	Não
	Ativo	bit	Não
	Codigo	nvarchar(200)	Não	Sem tratamento específico	Somentes números?
	Nome	nvarchar(100)	Não	Sem tratamento específico	Tudo em CAPS?

Antigo Perícia
Tabela	Campo	Nullable?	Valor	Tratado?	Count
LOCAL_TRABALHO	ID_LOCAL_TRABALHO	bigint	no		15629
	COD_ENTIDADE	bigint	no
	IND_ATIVO	char	no	S-Ativo
	COD_LOCAL_TRABALHO	varchar(10)	no	Somente números
	NOM_LOCAL_TRABALHO	varchar(100)	no	Letra e número; Tudo em CAPS

Observações sobre a tabela de Local de trabalho: nenhuma.

Novo Perícia
Tabela	Campo	Tipo	Nullable?	Valor	Tratar no sistema
Segurados	Id	uniqueidentifier	Não	GUID
	DadoDeOrigemId	uniqueidentifier	Não	GUID
	DadoDoSeguradoId	uniqueidentifier	Não	GUID
	EnderecoId	int	Não
	ContatoId	uniqueidentifier	Não	GUID
	VinculoId	uniqueidentifier	Não	GUID
	Nome	nvarchar(200)	Não	Sem tratamento específico	Tudo em CAPS?
	Ativo	bit	Não
DadosDeOrigem	Id	uniqueidentifier	Não	GUID
DadosDeOrigem	DataDeNascimento	datetime2	Não
DadosDosSegurados	Id	uniqueidentifier	Não	GUID
	Cpf	nvarchar(28)	Não	Sem tratamento específico	Somente números?
	Matricula	nvarchar(18)	Não	Sem tratamento específico	Somente números?
	Pis	nvarchar(22)	Sim	Sem tratamento específico	Somente números?
DadosDeOrigem	Sexo	nvarchar(30)	Não	enum	Feminino Masculino NaoIdentificado
DadosDosSegurados	EstadoCivil	nvarchar(20)	Não	enum	Casado Divorciado Solteiro Viuvo
	TipoDePrevidencia	nvarchar(200)	Não	enum	INSS IPERON NaoPossui
	GrauDeInstrucao	nvarchar(200)	Não	enum	FundamentalCompleto FundamentalIncompleto MedioCompleto MedioIncompleto PosGraduacaoCompleta PosGraduacaoIncompleta SuperiorCompleto SuperiorIncompleto
DadosDeOrigem	TipoSanguineo	nvarchar(4)	Não	enum	A AB B O
	FatorRh	nvarchar(16)	Não	enum	Negativo Positivo
	NomeDaMae	nvarchar(200)	Não	Sem tratamento específico	Tudo em CAPS?
	NomeDoPai	nvarchar(200)	Sim	Sem tratamento específico	Tudo em CAPS?
Contatos	Telefone	nvarchar(20)	Sim	Sem tratamento específico	Somente números?
	Celular	nvarchar(20)	Sim	Sem tratamento específico	Somente números?
	Email	nvarchar(200)	Sim	Sem tratamento específico
Vinculos	EntidadeId	uniqueidentifier	Sim	GUID
	LotacaoId	uniqueidentifier	Sim	GUID
	CargoId	uniqueidentifier	Sim	GUID
	LocalDeTrabalhoId	uniqueidentifier	Sim	GUID
Enderecos	Id	int	Não
	Cep	nvarchar(20)	Sim	Sem tratamento específico	Sem máscara?
	Municipio	nvarchar(100)	Sim	Sem tratamento específico
	Uf	nvarchar(4)	Sim	Sem tratamento específico
	Logradouro	nvarchar(100)	Sim	Sem tratamento específico
	Numero	nvarchar(20)	Sim	Sem tratamento específico
	Bairro	nvarchar(100)	Sim	Sem tratamento específico
	Complemento	nvarchar(100)	Sim	Sem tratamento específico

Antigo Perícia
Tabela	Campo	Nullable?	Valor	Tratado?	Count
SEGURADO	COD_SEGURADO	bigint	no		258879
	PUXAR VIA SCRIPT (DadoDeOrigemId)
	PUXAR VIA SCRIPT (DadoDoSeguradoId)
	PUXAR VIA SCRIPT (EnderecoId)
	PUXAR VIA SCRIPT (ContatoId)
	PUXAR VIA SCRIPT (VinculoId)
	NOM_SEGURADO	varchar(100)	no	Maioria em CAPS mas sem tratamento específico
	IND_ATIVO	char	yes	S-Ativo, N-Inativo
	GERAR VIA SCRIPT (Id (Dados de origem))
	DAT_NASCIMENTO	date	yes
	GERAR VIA SCRIPT (Id (Dados dos segurados))
	NUM_CPF	varchar	yes	Somente números
	NUM_MATRICULA	int	yes	Somente números
	NUM_PIS	varchar	yes	Somente números
	IND_SEXO	varchar(3)	yes	FEM, MAS, NULL
	IND_ESTADO_CIVIL	char(3)	yes	VIU, SOL, CAS, DIV, NULL
	IND_TIPO_PREVIDENCIA	varchar(100)	yes	NULL, NPP, IPERON, INSS
	IND_INSTRUCAO	char(3)	yes	FUC, SUC, MEI, NULL, MEC, SUI, FUI, POC
	IND_TIPO_SANGUE	char(2)	yes	A, NULL, O, B, AB
	IND_FATOR_RH	char	yes	-, NULL, +
	NOM_MAE	varchar(100)	yes	Maioria em CAPS mas sem tratamento específico
	NOM_PAI	varchar(100)	yes	Maioria em CAPS mas sem tratamento específico
	NUM_TELEFONE	char(11)	yes	Somente números
	NUM_CELULAR	varchar(11)	yes	Somente números
	DES_EMAIL	varchar(100)	yes
	COD_ENTIDADE	bigint	no
	ID_LOTACAO	bigint	yes
	ID_CARGO	bigint	yes
	ID_LOCAL_TRABALHO	bigint	yes
	GERAR VIA SCRIPT (Id (Endereço))
	NUM_CEP	varchar(8)	yes
	COD_MUNICIPIO	bigint	yes
	COD_UF	bigint	yes
	COD_LOGRADOURO	bigint	yes
	NUM_NUMERO	varchar(10)	yes
	COD_BAIRRO	bigint	yes
	TXT_COMPLEMENTO	varchar(100)	yes

Observações sobre a tabela de Segurado: campos de identificador único e chave estrangeiras precisam de ações com script.

Novo Perícia
Tabela	Campo	Tipo	Nullable?	Valor	Tratar no sistema
MedicosAssistentes	Id	uniqueidentifier	Não	GUID
	Nome	nvarchar(300)	Não	Sem tratamento específico	Tudo em CAPS?
	Crm	nvarchar(40)	Não	Sem tratamento específico	Somentes números?
	Uf	nvarchar(4)	Não	Sem tratamento específico	Tudo em CAPS?

Antigo Perícia
Tabela	Campo	Nullable?	Valor	Tratado?	Count
PROFISSIONAL (WHERE IND_TIPO_PROFISSIONAL IS NULL)	COD_PROFISSIONAL	bigint	no		12
	NOM_PROFISSIONAL	varchar(100)	no	Maioria em CAPS mas sem tratamento específico
	NUM_CONSELHO	varchar(20)	yes	Letra e número; Tudo em CAPS
	COD_UF	bigint	yes

Observações sobre a tabela de Profissional: nenhuma.

2.2 Passo-a-passo para importação

Importar base de produção para o mesmo servidor que a nova base

Substituir base origem e destino na instrução abaixo:

/*-----------------------------------------------------------------------------------
                             Passo 1: Importar Leis
-------------------------------------------------------------------------------------*/
-- Cria campo temporário para controlar ID antigo
ALTER TABLE [BASE_DESTINO].[dbo].[Leis]
ADD COD_LEI bigint

-- Importação
INSERT INTO [BASE_DESTINO].[dbo].[Leis] (
	Id,
	COD_LEI,
	Numero,
	Descricao,
	Ativo,
	DataDaLei,
	Texto)
SELECT 
	NEWID(), -- Gerar um GUID para ser o novo ID 
	COD_LEI, -- Campo temporário para controlar ID antigo
	NUM_LEI,
	DES_LEI,
	CASE WHEN IND_ATIVO = 'S' THEN 1 ELSE 0 END, -- Converte char em bit
	DAT_LEI,
	TXT_LEI
FROM [BASE_ORIGEM].[dbo].[LEI]

/*-----------------------------------------------------------------------------------
                          Passo 2: Importar TiposDeLicenca
-------------------------------------------------------------------------------------*/
-- Cria campos temporários para controlar IDs antigos
ALTER TABLE [BASE_DESTINO].[dbo].[TiposDeLicenca]
ADD COD_TIPO_LICENCA bigint
ALTER TABLE [BASE_DESTINO].[dbo].[TiposDeLicenca]
ADD COD_LEI bigint

-- Importação
INSERT INTO [BASE_DESTINO].[dbo].[TiposDeLicenca] (
	Id,
	COD_TIPO_LICENCA,
	LeiId,
	Ativo,
	Descricao)
SELECT 
	NEWID(), -- Gerar um GUID para ser o novo ID 
	t.COD_TIPO_LICENCA, -- Campo temporário para controlar ID antigo
	l.Id,
	CASE WHEN t.IND_ATIVO = 'S' THEN 1 ELSE 0 END, -- Converte char em bit
	t.DES_TIPO_LICENCA
FROM [BASE_ORIGEM].[dbo].[TIPO_LICENCA] AS t 
LEFT JOIN [BASE_DESTINO].[dbo].[Leis] AS l ON t.COD_LEI = l.COD_LEI

/*-----------------------------------------------------------------------------------
                Passo 3: Importar UnidadesPericiais [HorariosPadroes]
-------------------------------------------------------------------------------------*/
-- Cria campo temporário para controlar ID antigo
ALTER TABLE [BASE_DESTINO].[dbo].[HorariosPadroes]
ADD COD_UNIDADE_PERICIONAL bigint

-- Importação
INSERT INTO [BASE_DESTINO].[dbo].[HorariosPadroes] (
	COD_UNIDADE_PERICIONAL,
	Duracao,
	HorarioInicialManha,
	HorarioFinalManha,
	HorarioInicialTarde,
	HorarioFinalTarde)
SELECT 
	COD_UNIDADE_PERICIONAL, -- Campo temporário para controlar ID antigo
	CASE WHEN LEN(DURACAO_CONSULTA) = 4 THEN '0'+DURACAO_CONSULTA ELSE DURACAO_CONSULTA END,
	CASE WHEN LEN(HOR_INICIO_MANHA_PROFISSIONAL) = 4 THEN '0'+HOR_INICIO_MANHA_PROFISSIONAL ELSE HOR_INICIO_MANHA_PROFISSIONAL END,
	CASE WHEN LEN(HOR_FIM_MANHA_PROFISSIONAL) = 4 THEN '0'+HOR_FIM_MANHA_PROFISSIONAL ELSE HOR_FIM_MANHA_PROFISSIONAL END,
	CASE WHEN LEN(HOR_INICIO_TARDE_PROFISSIONAL) = 4 THEN '0'+HOR_INICIO_TARDE_PROFISSIONAL ELSE HOR_INICIO_TARDE_PROFISSIONAL END,
	CASE WHEN LEN(HOR_FIM_TARDE_PROFISSIONAL) = 4 THEN '0'+HOR_FIM_TARDE_PROFISSIONAL ELSE HOR_FIM_TARDE_PROFISSIONAL END
FROM [BASE_ORIGEM].[dbo].[UNIDADE_PERICIONAL]

/*-----------------------------------------------------------------------------------
                Passo 4: Importar UnidadesPericiais [Enderecos]
-------------------------------------------------------------------------------------*/
-- Cria campo temporário para controlar ID antigo
ALTER TABLE [BASE_DESTINO].[dbo].[Enderecos]
ADD COD_UNIDADE_PERICIONAL bigint

-- Importação
INSERT INTO [BASE_DESTINO].[dbo].[Enderecos] (
	COD_UNIDADE_PERICIONAL,
	Cep,
	Municipio,
	Uf,
	Logradouro,
	Numero,
	Bairro,
	Complemento)
SELECT 
	U.COD_UNIDADE_PERICIONAL, -- Campo temporário para controlar ID antigo
	U.NUM_CEP,
	M.NOM_MUNICIPIO,
	UF.SGL_UF,
	L.NOM_LOGRADOURO,
	U.NUM_NUMERO,
	B.NOM_BAIRRO,
	U.TXT_COMPLEMENTO
FROM [BASE_ORIGEM].[dbo].[UNIDADE_PERICIONAL] AS U
LEFT JOIN [BASE_ORIGEM].[dbo].[MUNICIPIO] AS M ON U.COD_MUNICIPIO = M.COD_MUNICIPIO
LEFT JOIN [BASE_ORIGEM].[dbo].[UF] AS UF ON U.COD_UF = UF.COD_UF
LEFT JOIN [BASE_ORIGEM].[dbo].[LOGRADOURO] AS L ON U.COD_LOGRADOURO = L.COD_LOGRADOURO
LEFT JOIN [BASE_ORIGEM].[dbo].[BAIRRO] AS B ON U.COD_BAIRRO = B.COD_BAIRRO

/*-----------------------------------------------------------------------------------
           Passo 5: Importar UnidadesPericiais [HorariosDeFuncionamento]
-------------------------------------------------------------------------------------*/
-- Cria campo temporário para controlar ID antigo
ALTER TABLE [BASE_DESTINO].[dbo].[HorariosDeFuncionamento]
ADD COD_UNIDADE_PERICIONAL bigint

-- Importação
INSERT INTO [BASE_DESTINO].[dbo].[HorariosDeFuncionamento] (
	COD_UNIDADE_PERICIONAL,
	HorarioInicial,
	HorarioFinal,
	Domingo,
	Segunda,
	Terca,
	Quarta,
	Quinta,
	Sexta,
	Sabado)
SELECT 
	COD_UNIDADE_PERICIONAL, -- Campo temporário para controlar ID antigo
	CASE WHEN LEN(HOR_INICIO_UNIDADE) = 4 THEN '0'+HOR_INICIO_UNIDADE ELSE HOR_INICIO_UNIDADE END,
	CASE WHEN LEN(HOR_FIM_UNIDADE) = 4 THEN '0'+HOR_FIM_UNIDADE ELSE HOR_FIM_UNIDADE END,
	CASE WHEN IND_DOMINGO='S' THEN 1 ELSE 0 END,
	CASE WHEN IND_SEGUNDA='S' THEN 1 ELSE 0 END,
	CASE WHEN IND_TERCA='S' THEN 1 ELSE 0 END,
	CASE WHEN IND_QUARTA='S' THEN 1 ELSE 0 END,
	CASE WHEN IND_QUINTA='S' THEN 1 ELSE 0 END,
	CASE WHEN IND_SEXTA='S' THEN 1 ELSE 0 END,
	CASE WHEN IND_SABADO='S' THEN 1 ELSE 0 END
FROM [BASE_ORIGEM].[dbo].[UNIDADE_PERICIONAL]

/*-----------------------------------------------------------------------------------
                       Passo 6: Importar UnidadesPericiais
-------------------------------------------------------------------------------------*/
-- Cria campo temporário para controlar ID antigo
ALTER TABLE [BASE_DESTINO].[dbo].[UnidadesPericiais]
ADD COD_UNIDADE_PERICIONAL bigint

-- Importação
INSERT INTO [BASE_DESTINO].[dbo].[UnidadesPericiais] (
	Id,
	COD_UNIDADE_PERICIONAL,

	Nome,
	Ativo,
	Telefone,
	Celular,

	EnderecoId,
	HorarioDeFuncionamentoId,
	HorarioPadraoId)
SELECT 
	NEWID(), -- Gerar um GUID para ser o novo ID 
	U.COD_UNIDADE_PERICIONAL, -- Campo temporário para controlar ID antigo

	U.NOM_UNIDADE_PERICIONAL,
	CASE WHEN U.IND_ATIVO = 'S' THEN 1 ELSE 0 END, -- Converte char em bit
	U.NUM_TELEFONE,
	U.NUM_CELULAR,

	E.Id,--EnderecoId,
	HF.Id,--HorarioDeFuncionamentoId,
	HP.Id--HorarioPadraoId

FROM [BASE_ORIGEM].[dbo].[UNIDADE_PERICIONAL] AS U
LEFT JOIN [BASE_DESTINO].[dbo].[Enderecos] AS E ON U.COD_UNIDADE_PERICIONAL = E.COD_UNIDADE_PERICIONAL
LEFT JOIN [BASE_DESTINO].[dbo].[HorariosDeFuncionamento] AS HF ON U.COD_UNIDADE_PERICIONAL = HF.COD_UNIDADE_PERICIONAL
LEFT JOIN [BASE_DESTINO].[dbo].[HorariosPadroes] AS HP ON U.COD_UNIDADE_PERICIONAL = HP.COD_UNIDADE_PERICIONAL

/*-----------------------------------------------------------------------------------
                   Passo 7: Importar Entidades [Enderecos]
-------------------------------------------------------------------------------------*/
-- Cria campo temporário para controlar ID antigo
ALTER TABLE [BASE_DESTINO].[dbo].[Enderecos]
ADD COD_ENTIDADE bigint

-- Importação
INSERT INTO [BASE_DESTINO].[dbo].[Enderecos] (
	COD_ENTIDADE,
	Cep,
	Municipio,
	Uf,
	Logradouro,
	Numero,
	Bairro,
	Complemento)
SELECT 
	E.COD_ENTIDADE, -- Campo temporário para controlar ID antigo
	E.NUM_CEP,
	M.NOM_MUNICIPIO,
	UF.SGL_UF,
	L.NOM_LOGRADOURO,
	E.NUM_NUMERO,
	B.NOM_BAIRRO,
	E.TXT_COMPLEMENTO
FROM [BASE_ORIGEM].[dbo].[ENTIDADE] AS E
LEFT JOIN [BASE_ORIGEM].[dbo].[MUNICIPIO] AS M ON E.COD_MUNICIPIO = M.COD_MUNICIPIO
LEFT JOIN [BASE_ORIGEM].[dbo].[UF] AS UF ON E.COD_UF = UF.COD_UF
LEFT JOIN [BASE_ORIGEM].[dbo].[LOGRADOURO] AS L ON E.COD_LOGRADOURO = L.COD_LOGRADOURO
LEFT JOIN [BASE_ORIGEM].[dbo].[BAIRRO] AS B ON E.COD_BAIRRO = B.COD_BAIRRO

/*-----------------------------------------------------------------------------------
                           Passo 8: Importar Entidades
-------------------------------------------------------------------------------------*/
-- Cria campo temporário para controlar ID antigo
ALTER TABLE [BASE_DESTINO].[dbo].[Entidades]
ADD COD_ENTIDADE bigint

-- Importação
INSERT INTO [BASE_DESTINO].[dbo].[Entidades] (
	Id,
	COD_ENTIDADE,

	Nome,
	Ativo,
	Cnpj,
	InscricaoEstadual,

	EnderecoId)
SELECT 
	NEWID(), -- Gerar um GUID para ser o novo ID 
	E.COD_ENTIDADE, -- Campo temporário para controlar ID antigo

	NOM_ENTIDADE,
	CASE WHEN IND_ATIVO = 'S' THEN 1 ELSE 0 END, -- Converte char em bit
	NUM_CNPJ,
	NUM_INSCRICAO_ESTADUAL,

	ED.Id--EnderecoId
FROM [BASE_ORIGEM].[dbo].[ENTIDADE] AS E
LEFT JOIN [BASE_DESTINO].[dbo].[Enderecos] AS ED ON E.COD_ENTIDADE = ED.COD_ENTIDADE

/*-----------------------------------------------------------------------------------
                           Passo 9: Importar Cargos
-------------------------------------------------------------------------------------*/
-- Cria campo temporário para controlar ID antigo
ALTER TABLE [BASE_DESTINO].[dbo].[Cargos]
ADD ID_CARGO bigint

-- Importação
INSERT INTO [BASE_DESTINO].[dbo].[Cargos] (
	Id,
	ID_CARGO,

	Ativo,
	Codigo,
	Descricao,

	EntidadeId)
SELECT 
	NEWID(), -- Gerar um GUID para ser o novo ID 
	C.ID_CARGO, -- Campo temporário para controlar ID antigo

	CASE WHEN C.IND_ATIVO = 'S' THEN 1 ELSE 0 END, -- Converte char em bit
	C.COD_CARGO, 
	C.DES_CARGO,

	E.Id--EntidadeId
FROM [BASE_ORIGEM].[dbo].CARGO AS C
LEFT JOIN [BASE_DESTINO].[dbo].[Entidades] AS E ON C.COD_ENTIDADE = E.COD_ENTIDADE

/*-----------------------------------------------------------------------------------
                           Passo 10: Importar AreasMedicas
-------------------------------------------------------------------------------------*/
-- Cria campo temporário para controlar ID antigo
ALTER TABLE [BASE_DESTINO].[dbo].[AreasMedicas]
ADD COD_AREA_MEDICA bigint

-- Importação
INSERT INTO [BASE_DESTINO].[dbo].[AreasMedicas] (
	Id,
	COD_AREA_MEDICA,
	Descricao,
	Ativo)
SELECT 
	NEWID(), -- Gerar um GUID para ser o novo ID 
	COD_AREA_MEDICA, -- Campo temporário para controlar ID antigo
	DES_AREA_MEDICA,
	CASE WHEN IND_ATIVO = 'S' THEN 1 ELSE 0 END -- Converte char em bit
FROM [BASE_ORIGEM].[dbo].[AREA_MEDICA]

/*-----------------------------------------------------------------------------------
                   Passo 11: Importar Profissionais [Enderecos]
-------------------------------------------------------------------------------------*/
-- Cria campo temporário para controlar ID antigo
ALTER TABLE [BASE_DESTINO].[dbo].[Enderecos]
ADD COD_PROFISSIONAL bigint

-- Alterar campo para ser compatível ao importar
ALTER TABLE [BASE_DESTINO].[dbo].[Enderecos]
ALTER COLUMN Complemento VARCHAR(100) COLLATE SQL_Latin1_General_CP1_CI_AI NULL

-- Importação
INSERT INTO [BASE_DESTINO].[dbo].[Enderecos] (
	COD_PROFISSIONAL,
	Cep,
	Municipio,
	Uf,
	Logradouro,
	Numero,
	Bairro,
	Complemento)
SELECT 
	P.COD_PROFISSIONAL, -- Campo temporário para controlar ID antigo
	P.NUM_CEP,
	M.NOM_MUNICIPIO,
	UF.SGL_UF,
	L.NOM_LOGRADOURO,
	P.NUM_NUMERO,
	B.NOM_BAIRRO,
	P.TXT_COMPLEMENTO
FROM [BASE_ORIGEM].[dbo].[PROFISSIONAL] AS P
LEFT JOIN [BASE_ORIGEM].[dbo].[MUNICIPIO] AS M ON P.COD_MUNICIPIO = M.COD_MUNICIPIO
LEFT JOIN [BASE_ORIGEM].[dbo].[UF] AS UF ON P.COD_UF = UF.COD_UF
LEFT JOIN [BASE_ORIGEM].[dbo].[LOGRADOURO] AS L ON P.COD_LOGRADOURO = L.COD_LOGRADOURO
LEFT JOIN [BASE_ORIGEM].[dbo].[BAIRRO] AS B ON P.COD_BAIRRO = B.COD_BAIRRO
WHERE IND_TIPO_PROFISSIONAL = 'MED'

-- Reverte alteração no campo 
ALTER TABLE [BASE_DESTINO].[dbo].[Enderecos]
ALTER COLUMN Complemento nvarchar(100) COLLATE Latin1_General_CI_AS NULL

/*-----------------------------------------------------------------------------------
                   Passo 12: Importar Profissionais [DadosPessoais]
-------------------------------------------------------------------------------------*/
-- Cria campo temporário para controlar ID antigo
ALTER TABLE [BASE_DESTINO].[dbo].[DadosPessoais]
ADD COD_PROFISSIONAL bigint

-- Alterar campo para ser compatível ao importar
ALTER TABLE [BASE_DESTINO].[dbo].[DadosPessoais]
ALTER COLUMN Rg VARCHAR(20) COLLATE SQL_Latin1_General_CP1_CI_AI NOT NULL

-- Importação
INSERT INTO [BASE_DESTINO].[dbo].[DadosPessoais] (
	Id,
	COD_PROFISSIONAL,

	NomeCompleto,
	Cpf,
	Rg,
	DataDeNascimento,
	Telefone,	
	Celular)
SELECT 
	NEWID(), -- Gerar um GUID para ser o novo ID 
	COD_PROFISSIONAL, -- Campo temporário para controlar ID antigo

	NOM_PROFISSIONAL,
	NUM_CPF,
	NUM_RG, 
	DAT_NASCIMENTO, 
	NUM_TELEFONE,
	NUM_CELULAR
FROM [BASE_ORIGEM].[dbo].[PROFISSIONAL] 
WHERE IND_TIPO_PROFISSIONAL = 'MED'

-- Reverte alteração no campo 
ALTER TABLE [BASE_DESTINO].[dbo].[DadosPessoais]
ALTER COLUMN Rg nvarchar(20) COLLATE Latin1_General_CI_AS NOT NULL

/*-----------------------------------------------------------------------------------
                        Passo 13: Importar Profissionais
-------------------------------------------------------------------------------------*/
-- Cria campo temporário para controlar ID antigo
ALTER TABLE [BASE_DESTINO].[dbo].[Profissionais]
ADD COD_PROFISSIONAL bigint

-- Alterar campo para ser compatível ao importar
ALTER TABLE [BASE_DESTINO].[dbo].[Profissionais]
ALTER COLUMN NumeroDoConselho VARCHAR(20) COLLATE SQL_Latin1_General_CP1_CI_AI NOT NULL

-- Importação
INSERT INTO [BASE_DESTINO].[dbo].[Profissionais] (
	Id,
	COD_PROFISSIONAL,

	Ativo,
	NumeroDoConselho,

	EnderecoId,
	DadoPessoalId,
	AreaMedicaId)
SELECT 
	NEWID(), -- Gerar um GUID para ser o novo ID 
	P.COD_PROFISSIONAL, -- Campo temporário para controlar ID antigo

	CASE WHEN P.IND_ATIVO = 'S' THEN 1 ELSE 0 END, -- Converte char em bit
	CASE WHEN P.NUM_CONSELHO IS NULL THEN '' ELSE P.NUM_CONSELHO END,

	E.Id,--EnderecoId,
	D.Id,--DadoPessoalId,
	A.Id--AreaMedicaId

FROM [BASE_ORIGEM].[dbo].[PROFISSIONAL] AS P
LEFT JOIN [BASE_DESTINO].[dbo].[Enderecos] AS E ON P.COD_PROFISSIONAL = E.COD_PROFISSIONAL
LEFT JOIN [BASE_DESTINO].[dbo].[DadosPessoais] AS D ON P.COD_PROFISSIONAL = D.COD_PROFISSIONAL
LEFT JOIN [BASE_DESTINO].[dbo].[AreasMedicas] AS A ON P.COD_AREA_MEDICA = A.COD_AREA_MEDICA
WHERE IND_TIPO_PROFISSIONAL = 'MED'

-- Reverte alteração no campo 
ALTER TABLE [BASE_DESTINO].[dbo].[Profissionais]
ALTER COLUMN NumeroDoConselho nvarchar(20) COLLATE Latin1_General_CI_AS NOT NULL

/*-----------------------------------------------------------------------------------
           Passo 14: Importar Profissionais [AgendasDosProfissionais]
-------------------------------------------------------------------------------------*/
-- Importação
INSERT INTO [BASE_DESTINO].[dbo].[AgendasDosProfissionais] (
	Id,
	UnidadePericialId,
	ProfissionalId)
SELECT 
	NEWID(), -- Gerar um GUID para ser o novo ID 
	U.Id,
	P.Id
FROM [BASE_ORIGEM].[dbo].[PROFISSIONAL_UNIDADE_PERICIAL] AS P_UP
LEFT JOIN [BASE_DESTINO].[dbo].[UnidadesPericiais] AS U ON P_UP.COD_UNIDADE_PERICIONAL = U.COD_UNIDADE_PERICIONAL
INNER JOIN [BASE_DESTINO].[dbo].[Profissionais] AS P ON P_UP.COD_PROFISSIONAL = P.COD_PROFISSIONAL

/*-----------------------------------------------------------------------------------
           Passo 15: Importar Profissionais [AgendasDosProfissionais]
-------------------------------------------------------------------------------------*/
-- Importação
INSERT INTO [BASE_DESTINO].[dbo].[DiasDaSemanaDasAgendas] (
	Id,
	AgendaDoProfissionalId,

	DiaDaSemana,
	HorarioInicialManha,
	HorarioFinalManha,
	HorarioInicialTarde,
	HorarioFinalTarde)
SELECT 
	NEWID(), -- Gerar um GUID para ser o novo ID 
	AP.Id,

	CASE WHEN IND_DIA_SEMANA = 'DOM' THEN 0
	     WHEN IND_DIA_SEMANA = 'SEG' THEN 1
	     WHEN IND_DIA_SEMANA = 'TER' THEN 2
		 WHEN IND_DIA_SEMANA = 'QUA' THEN 3
		 WHEN IND_DIA_SEMANA = 'QUI' THEN 4
		 WHEN IND_DIA_SEMANA = 'SEX' THEN 5
		 WHEN IND_DIA_SEMANA = 'SAB' THEN 6
		 END,
	CASE WHEN LEN(HOR_INICIO_MANHA) = 4 THEN '0'+HOR_INICIO_MANHA ELSE HOR_INICIO_MANHA END,
	CASE WHEN LEN(HOR_FIM_MANHA) = 4 THEN '0'+HOR_FIM_MANHA ELSE HOR_FIM_MANHA END,
	CASE WHEN LEN(HOR_INICIO_TARDE) = 4 THEN '0'+HOR_INICIO_TARDE ELSE HOR_INICIO_TARDE END,
	CASE WHEN LEN(HOR_FIM_TARDE) = 4 THEN '0'+HOR_FIM_TARDE ELSE HOR_FIM_TARDE END
FROM [BASE_ORIGEM].[dbo].[PROFISSIONAL_AGENDA] AS PA
LEFT JOIN [BASE_ORIGEM].[dbo].[PROFISSIONAL_UNIDADE_PERICIAL] AS PUP ON PA.COD_PROFISSIONAL_UNIDADE = PUP.COD_PROFISSIONAL_UNIDADE_PERICIONAL
LEFT JOIN [BASE_DESTINO].[dbo].[UnidadesPericiais] AS U ON PUP.COD_UNIDADE_PERICIONAL = U.COD_UNIDADE_PERICIONAL
INNER JOIN [BASE_DESTINO].[dbo].[Profissionais] AS P ON PUP.COD_PROFISSIONAL = P.COD_PROFISSIONAL
LEFT JOIN [BASE_DESTINO].[dbo].[AgendasDosProfissionais] AS AP ON U.Id = AP.UnidadePericialId 
                                                                   AND P.Id = AP.ProfissionalId
/*-----------------------------------------------------------------------------------
                          Passo 16: Importar Lotacoes
-------------------------------------------------------------------------------------*/
-- Cria campo temporário para controlar ID antigo
ALTER TABLE [BASE_DESTINO].[dbo].[Lotacoes]
ADD ID_LOTACAO bigint

-- Importação
INSERT INTO [BASE_DESTINO].[dbo].[Lotacoes] (
	Id,
	ID_LOTACAO,

	Ativo,
	Codigo,
	Nome,

	EntidadeId)
SELECT 
	NEWID(), -- Gerar um GUID para ser o novo ID 
	L.ID_LOTACAO, -- Campo temporário para controlar ID antigo

	CASE WHEN L.IND_ATIVO = 'S' THEN 1 ELSE 0 END, -- Converte char em bit
	L.COD_LOTACAO,
	L.NOM_LOTACAO,

	E.Id--EntidadeId
FROM [BASE_ORIGEM].[dbo].[LOTACAO] AS L
LEFT JOIN [BASE_DESTINO].[dbo].[Entidades] AS E ON L.COD_ENTIDADE = E.COD_ENTIDADE

/*-----------------------------------------------------------------------------------
                        Passo 17: Importar Lotacoes
-------------------------------------------------------------------------------------*/
-- Cria campo temporário para controlar ID antigo
ALTER TABLE [BASE_DESTINO].[dbo].[LocaisDeTrabalho]
ADD ID_LOCAL_TRABALHO bigint

-- Importação
INSERT INTO [BASE_DESTINO].[dbo].[LocaisDeTrabalho] (
	Id,
	ID_LOCAL_TRABALHO,

	Ativo,
	Codigo,
	Nome,

	EntidadeId)
SELECT 
	NEWID(), -- Gerar um GUID para ser o novo ID 
	L.ID_LOCAL_TRABALHO, -- Campo temporário para controlar ID antigo

	CASE WHEN L.IND_ATIVO = 'S' THEN 1 ELSE 0 END, -- Converte char em bit
	L.COD_LOCAL_TRABALHO,
	L.NOM_LOCAL_TRABALHO,

	E.Id--EntidadeId
FROM [BASE_ORIGEM].[dbo].[LOCAL_TRABALHO] AS L
LEFT JOIN [BASE_DESTINO].[dbo].[Entidades] AS E ON L.COD_ENTIDADE = E.COD_ENTIDADE

/*-----------------------------------------------------------------------------------
                        Passo 18: Importar MedicosAssistentes
-------------------------------------------------------------------------------------*/
-- Cria campo temporário para controlar ID antigo
ALTER TABLE [BASE_DESTINO].[dbo].[MedicosAssistentes]
ADD COD_PROFISSIONAL bigint

-- Importação
INSERT INTO [BASE_DESTINO].[dbo].[MedicosAssistentes] (
	Id,
	COD_PROFISSIONAL,

	Nome,
	Crm, 
	Uf)
SELECT 
	NEWID(), -- Gerar um GUID para ser o novo ID 
	P.COD_PROFISSIONAL, -- Campo temporário para controlar ID antigo

	P.NOM_PROFISSIONAL,
	CASE WHEN P.NUM_CONSELHO IS NULL THEN '' ELSE P.NUM_CONSELHO END,
	UF.SGL_UF

FROM [BASE_ORIGEM].[dbo].[PROFISSIONAL] AS P
LEFT JOIN [BASE_ORIGEM].[dbo].[UF] AS UF ON P.COD_UF = UF.COD_UF
WHERE IND_TIPO_PROFISSIONAL IS NULL

/*-----------------------------------------------------------------------------------
                        Passo 19: Importar Segurados [DadosDeOrigem]
-------------------------------------------------------------------------------------*/
-- Cria campo temporário para controlar ID antigo
ALTER TABLE [BASE_DESTINO].[dbo].[DadosDeOrigem]
ADD COD_SEGURADO bigint

-- Importação
INSERT INTO [BASE_DESTINO].[dbo].[DadosDeOrigem] (
	Id,
	COD_SEGURADO,

	DataDeNascimento,
	Sexo, 
	TipoSanguineo,
	FatorRh,
	NomeDaMae,
	NomeDoPai
)
SELECT 
	NEWID(), -- Gerar um GUID para ser o novo ID 
	S.COD_SEGURADO, -- Campo temporário para controlar ID antigo

	CASE WHEN DAT_NASCIMENTO IS NULL THEN '1899-01-01' ELSE DAT_NASCIMENTO END,
	CASE WHEN IND_SEXO = 'FEM' THEN 'Feminino'
	     WHEN IND_SEXO = 'MAS' THEN 'Masculino'
	     ELSE 'NaoIdentificado'
		 END,
	CASE WHEN IND_TIPO_SANGUE IS NULL THEN '-' ELSE IND_TIPO_SANGUE END,
	CASE WHEN IND_FATOR_RH = '+' THEN 'Positivo'
	     WHEN IND_FATOR_RH = '-' THEN 'Negativo'
	     ELSE 'N/I'
		 END,
	CASE WHEN NOM_MAE IS NULL THEN '' ELSE NOM_MAE END,
	NOM_PAI
FROM [BASE_ORIGEM].[dbo].[SEGURADO] AS S

/*-----------------------------------------------------------------------------------
                 Passo 20: Importar Segurados [DadosDosSegurados]
-------------------------------------------------------------------------------------*/
-- Cria campo temporário para controlar ID antigo
ALTER TABLE [BASE_DESTINO].[dbo].[DadosDosSegurados]
ADD COD_SEGURADO bigint

-- Importação
INSERT INTO [BASE_DESTINO].[dbo].[DadosDosSegurados] (
	Id,
	COD_SEGURADO,

	Cpf,
	Matricula,
	Pis,
	EstadoCivil,
	TipoDePrevidencia,
	GrauDeInstrucao
)
SELECT 
	NEWID(), -- Gerar um GUID para ser o novo ID 
	S.COD_SEGURADO, -- Campo temporário para controlar ID antigo

	CASE WHEN NUM_CPF IS NULL THEN '' ELSE NUM_CPF END,
	CASE WHEN NUM_MATRICULA IS NULL THEN '' ELSE NUM_MATRICULA END,
	NUM_PIS,

	CASE WHEN IND_ESTADO_CIVIL = 'VIU' THEN 'Viuvo'
	     WHEN IND_ESTADO_CIVIL = 'SOL' THEN 'Solteiro'
	     WHEN IND_ESTADO_CIVIL = 'CAS' THEN 'Casado'
	     WHEN IND_ESTADO_CIVIL = 'DIV' THEN 'Divorciado'
	     ELSE 'N/I'
		 END,
	
	CASE WHEN IND_TIPO_PREVIDENCIA = 'NPP' THEN 'NaoPossui'
	     WHEN IND_TIPO_PREVIDENCIA = 'IPERON' THEN 'IPERON'
	     WHEN IND_TIPO_PREVIDENCIA = 'INSS' THEN 'INSS'
	     ELSE 'NaoIdentificado'
		 END,
	
	CASE WHEN IND_INSTRUCAO = 'FUC' THEN 'FundamentalCompleto'
	     WHEN IND_INSTRUCAO = 'SUC' THEN 'SuperiorCompleto'
	     WHEN IND_INSTRUCAO = 'MEI' THEN 'MedioIncompleto'
	     WHEN IND_INSTRUCAO = 'MEC' THEN 'MedioCompleto'
	     WHEN IND_INSTRUCAO = 'SUI' THEN 'SuperiorIncompleto'
	     WHEN IND_INSTRUCAO = 'FUI' THEN 'FundamentalIncompleto'
	     WHEN IND_INSTRUCAO = 'POC' THEN 'PosGraduacaoCompleta'
	     WHEN IND_INSTRUCAO = 'POI' THEN 'PosGraduacaoIncompleta'
	     ELSE 'NaoIdentificado'
		 END
FROM [BASE_ORIGEM].[dbo].[SEGURADO] AS S

/*-----------------------------------------------------------------------------------
                 Passo 21: Importar Segurados [Contatos]
-------------------------------------------------------------------------------------*/
-- Cria campo temporário para controlar ID antigo
ALTER TABLE [BASE_DESTINO].[dbo].[Contatos]
ADD COD_SEGURADO bigint

-- Alterar campo para ser compatível ao importar
ALTER TABLE [BASE_DESTINO].[dbo].[Contatos]
ALTER COLUMN Telefone VARCHAR(20) COLLATE SQL_Latin1_General_CP1_CI_AI NULL
ALTER TABLE [BASE_DESTINO].[dbo].[Contatos]
ALTER COLUMN Celular VARCHAR(20) COLLATE SQL_Latin1_General_CP1_CI_AI NULL

-- Importação
INSERT INTO [BASE_DESTINO].[dbo].[Contatos] (
	Id,
	COD_SEGURADO,

	Telefone,
	Celular,
	Email)
SELECT 
	NEWID(), -- Gerar um GUID para ser o novo ID 
	S.COD_SEGURADO, -- Campo temporário para controlar ID antigo

	NUM_TELEFONE,
	NUM_CELULAR,
	DES_EMAIL
FROM [BASE_ORIGEM].[dbo].[SEGURADO] AS S

-- Reverte alteração no campo 
ALTER TABLE [BASE_DESTINO].[dbo].[Contatos]
ALTER COLUMN Telefone nvarchar(20) COLLATE Latin1_General_CI_AS NULL
ALTER TABLE [BASE_DESTINO].[dbo].[Contatos]
ALTER COLUMN Celular nvarchar(20) COLLATE Latin1_General_CI_AS NULL

/*-----------------------------------------------------------------------------------
                 Passo 21: Importar Segurados [Vinculos]
-------------------------------------------------------------------------------------*/
-- Cria campo temporário para controlar ID antigo
ALTER TABLE [BASE_DESTINO].[dbo].[Vinculos]
ADD COD_SEGURADO bigint

-- Importação
INSERT INTO [BASE_DESTINO].[dbo].[Vinculos] (
	Id,
	COD_SEGURADO,

	EntidadeId,
	LotacaoId,
	CargoId,
	LocalDeTrabalhoId)
SELECT 
	NEWID(), -- Gerar um GUID para ser o novo ID 
	S.COD_SEGURADO, -- Campo temporário para controlar ID antigo

	E.Id, --EntidadeId
	L.Id, --LotacaoId
	C.Id, --CargoId
	LT.Id --LocalDeTrabalhoId
FROM [BASE_ORIGEM].[dbo].SEGURADO AS S
LEFT JOIN [BASE_DESTINO].[dbo].[Entidades] AS E ON S.COD_ENTIDADE = E.COD_ENTIDADE
LEFT JOIN [BASE_DESTINO].[dbo].[Lotacoes] AS L ON S.ID_LOTACAO = L.ID_LOTACAO
LEFT JOIN [BASE_DESTINO].[dbo].[Cargos] AS C ON S.ID_CARGO = C.ID_CARGO
LEFT JOIN [BASE_DESTINO].[dbo].[LocaisDeTrabalho] AS LT ON S.ID_LOCAL_TRABALHO = LT.ID_LOCAL_TRABALHO

/*-----------------------------------------------------------------------------------
                 Passo 21: Importar Segurados [Enderecos]
-------------------------------------------------------------------------------------*/
-- Cria campo temporário para controlar ID antigo
ALTER TABLE [BASE_DESTINO].[dbo].[Enderecos]
ADD COD_SEGURADO bigint

-- Importação
INSERT INTO [BASE_DESTINO].[dbo].[Enderecos] (
	COD_SEGURADO,
	Cep,
	Municipio,
	Uf,
	Logradouro,
	Numero,
	Bairro,
	Complemento)
SELECT 
	U.COD_SEGURADO, -- Campo temporário para controlar ID antigo
	U.NUM_CEP,
	M.NOM_MUNICIPIO,
	UF.SGL_UF,
	L.NOM_LOGRADOURO,
	U.NUM_NUMERO,
	B.NOM_BAIRRO,
	U.TXT_COMPLEMENTO
FROM [BASE_ORIGEM].[dbo].[SEGURADO] AS U
LEFT JOIN [BASE_ORIGEM].[dbo].[MUNICIPIO] AS M ON U.COD_MUNICIPIO = M.COD_MUNICIPIO
LEFT JOIN [BASE_ORIGEM].[dbo].[UF] AS UF ON U.COD_UF = UF.COD_UF
LEFT JOIN [BASE_ORIGEM].[dbo].[LOGRADOURO] AS L ON U.COD_LOGRADOURO = L.COD_LOGRADOURO
LEFT JOIN [BASE_ORIGEM].[dbo].[BAIRRO] AS B ON U.COD_BAIRRO = B.COD_BAIRRO

/*-----------------------------------------------------------------------------------
                          Passo 23: Importar Segurados
-------------------------------------------------------------------------------------*/
-- Cria campo temporário para controlar ID antigo
ALTER TABLE [BASE_DESTINO].[dbo].Segurados
ADD COD_SEGURADO bigint

-- Importação
INSERT INTO [BASE_DESTINO].[dbo].Segurados (
	Id,
	COD_SEGURADO,

	Nome,
	Ativo,

	DadoDeOrigemId,
	DadoDoSeguradoId,
	EnderecoId, 
	ContatoId, 
	VinculoId)
SELECT 
	NEWID(), -- Gerar um GUID para ser o novo ID 
	S.COD_SEGURADO, -- Campo temporário para controlar ID antigo

	NOM_SEGURADO,
	CASE WHEN IND_ATIVO = 'S' THEN 1 ELSE 0 END, -- Converte char em bit

	DO.Id,--
	DS.Id,--DadoDoSeguradoId
	E.Id,--EnderecoId
	C.Id,--ContatoId
	V.Id--VinculoId
FROM [BASE_ORIGEM].[dbo].[SEGURADO] AS S
LEFT JOIN [BASE_DESTINO].[dbo].[Enderecos] AS E ON S.COD_SEGURADO = E.COD_SEGURADO
LEFT JOIN [BASE_DESTINO].[dbo].DadosDeOrigem AS DO ON S.COD_SEGURADO = DO.COD_SEGURADO
LEFT JOIN [BASE_DESTINO].[dbo].DadosDosSegurados AS DS ON S.COD_SEGURADO = DS.COD_SEGURADO
LEFT JOIN [BASE_DESTINO].[dbo].Contatos AS C ON S.COD_SEGURADO = C.COD_SEGURADO
LEFT JOIN [BASE_DESTINO].[dbo].Vinculos AS V ON S.COD_SEGURADO = V.COD_SEGURADO

Executar instrução

2.3 Alterações necessárias
Após a importação dos cadastros, foi identificado que não será necessário alterações estruturais e já foi realizado o tratamento/formatação dos dados (que precisaram) na própria instrução.

3. Conclusão

Concluímos que a nível de cadastros, a importação deve ocorrer sem impedimentos. Porém, na planilha foi levantado alguns dados que podem ter formatação padronizadas como, por exemplo, descrições/nomes em caixa alta ou cep/telefone/celular sem máscara ao salvar no banco. Será definido pelo P.O. o valor e a prioridade de tais alterações e tratamentos.