Ir para o conteúdo principal

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  
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

    1. Importar base de produção para o mesmo servidor que a nova base
    2. Substituir base origem e destino na instrução abaixo:
Script 
/*-----------------------------------------------------------------------------------
                             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

         3. 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.

Voltar ao topo