SAP Business Objects Data Services por Gláucia Sibele

1. 

2. 

O BO Data Services é um software que permite planejar, organizar, desenvolver e administrar de forma visual os processos de ETL.

Benefícios:

•          Facilita o processo de organização de dados de diferentes fontes através de uma interface gráfica.

•          Extrai, transforma e carrega os dados de fontes heterogenias em um único banco de dados usando processos que organizam os fluxos de carga.

•          Compartilha objetos em um ambiente de ETL onde exista mais de um desenvolvedor.

•          Permite a administração dos projetos via WEB.

Arquitetura do Data Services:

O SAP BO Data Services contêm diversos componentes para desenvolver e administrar as rotinas de ETL, sendo eles:

•          Designer:

o    Interface de desenvolvimento para criar, testar e executar manualmente os processos de ETL.

•          Repository Manager:

o    Permite criar, atualizar e verificar as versões dos repositórios locais e Central.

–         Repositório Local: Armazena as definições dos objetos do Data Services Designer (como projetos, jobs, work flows e data flows) e metadados de origem/destino.

§  Cada desenvolvedor deve ter seu repositório local, ou seja, o repositório é individual

•       Repositório Central: Componente opcional utilizado para apoiar o desenvolvimento multiusuário.

•          Funciona como um SharePoint => Controla a versão dos objetos desenvolvidos.

•          Apenas um repositório central para todos os desenvolvedores. Deve-se criar o repositório Central com segurança para que apenas usuários cadastrados tenham o acesso ao projeto e Jobs desenvolvidos.

o    Repositórios devem estar criados no servidor de banco de dados.

•          Server Manager:

o     Responsável pela execução dos Jobs do Data Services Designer. Nele vinculam-se os repositórios locais para execução e configuração SMTP para envio de e-mail.

•          Management Console

o     Provê a administração e gerenciamento dos recursos do Data Services Designer via WEB. Nele é possível:

–         Agendamento, monitoramento e execução dos Batch jobs

–         Interrupção da execução dos Batch Jobs   

–         Configuração dos Repositórios Locais

–         Configuração do Repositório Central

–         Criação dos grupos e usuários para acesso ao Repositório Central

1.   Data Services Designer

Interface do Data Services Designer, possui:

- Barra de menu

- Project Area,

- Local Object Library

- Star Page.

}  Project Area: Possibilita visualizar os Jobs vinculados ao projeto, como também monitorar e verificar o log de execução. Contêm as seguintes abas.

•       Designer: Criar, visualizar e gerenciar projetos. Fornece uma visão hierárquica de todos os objetos utilizados no processo.

•       Monitor: Exibi o status das execuções dos Jobs e possibilita finalizar o processo durante a execução.

•       Log: Local onde se visualiza o histórico completo de execução dos jobs. Também podem ser visualizados com o Data Services Management Console.

  

}  Local Object Library

Job: Objeto executável. Pode conter:

·         Scripts: Para envio de e-mail, deleção de registros no banco de dados, habilitar e desabilitar índices e demais verificações necessárias em banco de dados e etc.

·         Conditional: Objeto utilizado para uma condição de execução do processo.

·         Work Flow: Objeto onde seqüencia-se e ordena-se o fluxo de execução. Composto por Data Flows. Também é utilizado para definir estratégias de tratamento de erros que possam ocorrer durante a execução do Job (bloco Try/Catch).

·         Data Flow: Processo pelo qual os dados de origem são transformados e carregados no destino. Envolve a extração o tratamento e a transferência dos dados de origem de uma ou mais fontes para uma ou mais tabelas ou arquivos de destino.

Projects: Agrupa os Jobs do processo de ETL.

•          Os Jobs devem ser associados a um projeto antes de serem executados na área de Projeto (Project Area) do Designer para que se possa monitorar e/ou cancelar o processo.

Datastore: Configuração da conexão com o banco de dados. Contêm a lista de tabelas que serão utilizadas no processo.

Formats: Definição dos Flat Files de origem e destino.

Transforms: Agrupa os componentes que serão utilizados para o processo de carga e demais transformações nos dados. Sendo os mais utilizados:

–         Query: Lookups, funções e demais transformações

–         SQL: Querys livres

–         Case: Condicional para gerar uma ou várias saídas

–         Merge: União dos dados vindos de várias origens

–         Key_Generation: Geração da Surrogate Key

–         History_Preserving: Slowly Change Dimension 2

–         Table_Comparison: Update, SCD 1

 

  

Start Page:

Local para o desenvolvimento das rotinas de ETL.

PL/SQL - Carga dimensão Tempo (Time Dimension Load)

Carga da Dimensão Tempo em PL/SQL

(Time Dimension load in PL/SQL)

Carga da dimensão de tempo com a seguinte estrutura em snow flake:

(Load of the time dimension with the following snow flake schema)

Para efeito didático o código carrega poucos campos nestas estruturas, porém é de fácil alteração para inclusão de novos cálculos de tempo.

(For didactic purposes the code loads few fields, but it is easy to change to include new time calculations.) Note that for english language natives, the six month period is unusual and can be dropped of the structure.

--Carga dimensão Ano (Year dimension load)

declare

  Data DATE;

  DataIni DATE;

  DataFim DATE;

  Data_Movel DATE;

BEGIN

  DataIni := to_date('2000/01/01','yyyy/mm/dd');

  DataFim := to_date('2040/12/31','yyyy/mm/dd');

  Data := DataIni;

WHILE Data <= DataFim LOOP

      INSERT INTO TRDIM.ANO ( ANO )

      VALUES ( TO_CHAR(extract(YEAR from Data)) );

      Data := add_months(Data,12);

      Data := add_months(Data,1) - extract(DAY from (add_months(Data,1)));

END LOOP;

COMMIT;

END;

--Carga dimensão Semestre (Six month period dimension load)

declare

  Data DATE;

  DataIni DATE;

  DataFim DATE;

  Data_Movel DATE;

BEGIN

  DataIni := to_date('2000/01/01','yyyy/mm/dd');

  DataFim := to_date('2040/12/31','yyyy/mm/dd');

   Data := DataIni;

WHILE Data <= DataFim LOOP

      INSERT INTO  TRDIM.SEMESTRE(SEMESTRE, DESCRICAO_SEMESTRE, ANO )

      VALUES

          (

            TO_CHAR(extract(YEAR from Data)) || DECODE(TO_NUMBER(TO_CHAR(Data,'Q'))

            ,1,'01'

            ,2,'01'

            ,3,'02'

            ,4,'02')

            ,DECODE(TO_NUMBER(TO_CHAR(Data,'Q'))

            ,1,'1º Semestre'

            ,2,'1º Semestre'

            ,3,'2º Semestre'

            ,4,'2º Semestre'),

            TO_CHAR(extract(YEAR from Data)) 

          );

      Data := add_months(Data,6);

      Data := add_months(Data,1) - extract(DAY from (add_months(Data,1)));

END LOOP;

COMMIT;

END;

--Carga dimensão trimestre (Quarter dimension load)

declare

  Data DATE;

  DataIni DATE;

  DataFim DATE;

  Data_Movel DATE;

BEGIN

  DataIni := to_date('2000/01/01','yyyy/mm/dd');

  DataFim := to_date('2040/12/31','yyyy/mm/dd');

   Data := DataIni;

WHILE Data <= DataFim LOOP

      INSERT INTO  TRDIM.TRIMESTRE(TRIMESTRE, DESCRICAO_TRIMESTRE, SEMESTRE,ANO)

      VALUES

          (

            TO_CHAR(extract(YEAR from Data)) || DECODE(TO_NUMBER(TO_CHAR(Data,'Q'))

            ,1,'01'

            ,2,'02'

            ,3,'03'

            ,4,'04')

            ,DECODE(TO_NUMBER(TO_CHAR(Data,'Q'))

            ,1,'1º Trimestre'

            ,2,'2º Trimestre'

            ,3,'3º Trimestre'

            ,4,'4º Trimestre'),  

            TO_CHAR(extract(YEAR from Data)) || DECODE(TO_NUMBER(TO_CHAR(Data,'Q'))

            ,1,'01'

            ,2,'01'

            ,3,'02'

            ,4,'02'),

            TO_CHAR(extract(YEAR from Data)) 

          );

      Data := add_months(Data,3);

      Data := add_months(Data,1) - extract(DAY from (add_months(Data,1)));

END LOOP;

COMMIT;

END;

--Carga dimensão mês (month dimension load)

declare

  Data DATE;

  DataIni DATE;

  DataFim DATE;

  Data_Movel DATE;

BEGIN

  DataIni := to_date('2000/01/01','yyyy/mm/dd');

  DataFim := to_date('2040/12/31','yyyy/mm/dd');

   Data := DataIni;

WHILE Data <= DataFim LOOP

      INSERT INTO TRDIM.MES (MES, DESCRICAO_MES, ANO, SEMESTRE, TRIMESTRE)

      VALUES

          (

             TO_CHAR(extract(YEAR from Data)) || TO_CHAR(Data, 'MM'),

            (CASE extract(MONTH from Data)

                  WHEN (1)    THEN ('JANEIRO')

                  WHEN (2)    THEN ('FEVEREIRO')

                  WHEN (3)    THEN ('MARÇO')

                  WHEN (4)    THEN ('ABRIL')

                  WHEN (5)    THEN ('MAIO')

                  WHEN (6)    THEN ('JUNHO')

                  WHEN (7)    THEN ('JULHO')

                  WHEN (8)    THEN ('AGOSTO')

                  WHEN (9)    THEN ('SETEMBRO')

                  WHEN (10)   THEN ('OUTUBRO')

                  WHEN (11)   THEN ('NOVEMBRO')

                  WHEN (12)   THEN ('DEZEMBRO')

            END) || ' DE ' || TO_CHAR(extract(YEAR from Data)),

            TO_CHAR(extract(YEAR from Data)),

            TO_CHAR(extract(YEAR from Data)) || DECODE(TO_NUMBER(TO_CHAR(Data,'Q'))

            ,1,'01'

            ,2,'01'

            ,3,'02'

            ,4,'02'),

            TO_CHAR(extract(YEAR from Data)) || DECODE(TO_NUMBER(TO_CHAR(Data,'Q'))

            ,1,'01'

            ,2,'02'

            ,3,'03'

            ,4,'04')

          );

      Data := add_months(Data,1);

      Data := add_months(Data,1) - extract(DAY from (add_months(Data,1)));

END LOOP;

COMMIT;

END;

--Carga dimensão Data (Day dimension load)

declare

  Data DATE;

  DataIni DATE;

  DataFim DATE;

  Data_Movel DATE;

BEGIN

  DataIni := to_date('2000/01/01','yyyy/mm/dd');

  DataFim := to_date('2040/12/31','yyyy/mm/dd');

  Data := DataIni;

  data_movel := DataFim;

WHILE Data <= DataFim LOOP

      INSERT INTO TRDIM.DATA (DATA,DIA_UTIL,ANO,SEMESTRE,TRIMESTRE,MES)

      VALUES

      (

      Data,

      CASE WHEN ( TO_NUMBER( TO_CHAR (Data, 'D') ) IN (1,7) ) THEN ('N')

           ELSE ('S') END,

      TO_CHAR(extract(YEAR from Data)),

      TO_CHAR(extract(YEAR from Data)) || DECODE(TO_NUMBER(TO_CHAR(Data,'Q'))

            ,1,'01'

            ,2,'01'

            ,3,'02'

            ,4,'02'),

            TO_CHAR(extract(YEAR from Data)) || DECODE(TO_NUMBER(TO_CHAR(Data,'Q'))

            ,1,'01'

            ,2,'02'

            ,3,'03'

            ,4,'04'),

            TO_CHAR(extract(YEAR from Data)) || TO_CHAR(Data, 'MM')

      );

      Data := Data + 1;

END LOOP;

COMMIT;

END;

T-SQL - Carga dimensão Tempo (Time Dimension Load)

Carga da Dimensão Tempo em T-SQL

(Time Dimension load in T-SQL)

Carga da dimensão de tempo com a seguinte estrutura em snow flake:

(Load of the time dimension with the following snow flake schema)

Para efeito didático o código carrega poucos campos nestas estruturas, porém é de fácil alteração para inclusão de novos cálculos de tempo.

(For didactic purposes the code loads few fields, but it is easy to change to include new time calculations.) Note that for english language natives, the six month period is unusual and can be dropped of the structure.

DECLARE @Data DATETIME, @DataIni DATETIME, @DataFim DATETIME

SET @DataIni = '2000-01-01 00:00:00.000'

SET @DataFim = '2020-12-31 00:00:00.000'

--Carga dimensão Ano (Year dimension load)

SET @Data = @DataIni

WHILE (@Data <= @DataFim)

BEGIN

                INSERT INTO ANO ( ANO )

                VALUES ( YEAR(@Data) )

                SET @Data = DATEADD(MONTH,12,@Data)

                SET @Data = DATEADD(MONTH,1, @Data) - DATEPART(DAY,DATEADD(MONTH,1, @Data))

END

--Carga dimensão Semestre (Six month period dimension load)

SET @Data = @DataIni

WHILE (@Data <= @DataFim)

BEGIN

                INSERT INTO SEMESTRE (

                                                                SEMESTRE,

                                                                DESCRICAO_SEMESTRE,

                                                                ANO  )

                VALUES

                                (

                                YEAR(@Data) * 100 + CASE WHEN ( DATEPART(QQ ,@Data) < 3 )  THEN (1) ELSE (2) END,

                                'SEMESTRE ' + CONVERT(VARCHAR,(CASE WHEN ( DATEPART(QQ ,@Data) < 3 )  THEN (1) ELSE (2) END)) + ' - ' + CONVERT(VARCHAR,YEAR(@Data)),

                                YEAR(@Data)  )

                SET @Data = DATEADD(MONTH,6,@Data)

                SET @Data = DATEADD(MONTH,1, @Data) - DATEPART(DAY,DATEADD(MONTH,1, @Data))

END

--Carga dimensão trimestre (Quarter dimension load)

SET @Data = @DataIni

WHILE (@Data <= @DataFim)

BEGIN

                INSERT INTO TRIMESTRE (

                                                                TRIMESTRE,

                                                                DESCRICAO_TRIMESTRE,

                                                                SEMESTRE,

                                                                ANO  )

                VALUES

                                (

                                YEAR(@Data) * 100 + DATEPART ( QQ , @Data ),

                                'TRIMESTRE ' + CONVERT(VARCHAR,DATEPART(QQ,@Data)) + ' - ' + CONVERT(VARCHAR,YEAR(@Data)),

                                YEAR(@Data) * 100 + CASE WHEN ( DATEPART(QQ ,@Data) < 3 )  THEN (1) ELSE (2) END,

                                YEAR(@Data) )

                SET @Data = DATEADD(MONTH,3,@Data)

                SET @Data = DATEADD(MONTH,1, @Data) - DATEPART(DAY,DATEADD(MONTH,1, @Data))

END

--Carga dimensão mês (month dimension load)

SET @Data = @DataIni

WHILE (@Data <= @DataFim)

BEGIN

                INSERT INTO MES (

                                                                MES,

                                                                DESCRICAO_MES,

                                                                ANO,

                                                                SEMESTRE,

                                                                TRIMESTRE )

                VALUES

                                (

                                YEAR(@Data) * 100 + MONTH(@Data),

                                (CASE (MONTH(@Data))

                                                WHEN (1)            THEN ('JANEIRO')

                                                WHEN (2)            THEN ('FEVEREIRO')

                                                WHEN (3)            THEN ('MARÇO')

                                                WHEN (4)            THEN ('ABRIL')

                                                WHEN (5)            THEN ('MAIO')

                                                WHEN (6)            THEN ('JUNHO')

                                                WHEN (7)            THEN ('JULHO')

                                                WHEN (8)            THEN ('AGOSTO')

                                                WHEN (9)            THEN ('SETEMBRO')

                                                WHEN (10)          THEN ('OUTUBRO')

                                                WHEN (11)          THEN ('NOVEMBRO')

                                                WHEN (12)          THEN ('DEZEMBRO')

                                END) + ' DE ' + CONVERT(VARCHAR,YEAR(@Data)),

                                YEAR(@Data),

                                YEAR(@Data) * 100 + CASE WHEN ( DATEPART(QQ ,@Data) < 3 )  THEN (1) ELSE (2) END,

                                YEAR(@Data) * 100 + DATEPART ( QQ , @Data ) )

                SET @Data = DATEADD(MONTH,1,@Data)

                SET @Data = DATEADD(MONTH,1, @Data) - DATEPART(DAY,DATEADD(MONTH,1, @Data))

END

--Carga dimensão Data (Day dimension load)

SET @Data = @DataIni

WHILE (@Data <= @DataFim)

BEGIN

                INSERT INTO DATA (

                                                                DATA,

                                                                ANO,

                                                                SEMESTRE,

                                                                TRIMESTRE,

                                                                MES,

                                                                DIA_UTIL)

                VALUES

                (@Data,

                YEAR(@Data),

                YEAR(@Data) * 100 + CASE WHEN ( DATEPART(QQ ,@Data) < 3 )  THEN (1) ELSE (2) END,

                YEAR(@Data) * 100 + DATEPART ( QQ , @Data ),

                YEAR(@Data) * 100 + MONTH(@Data),

                CASE WHEN ( DATEPART(DW ,@Data) IN (1,7) ) THEN ('N') ELSE ('S') END )

                SET @Data = @Data + 1

END

Real Time BI e Change Data Capture

Real-time business intelligence (RTBI) é o processo de fornecer informações sobre as operações de negócios assim que elas ocorrem.

As operações de negócio assim que ocorrem são alimentadas no sistema RTBI em tempo real (Ou Near real time) que demonstra o estado atual da empresa; permitindo assim não somente as clássicas visões do passado do sistema de DW. Fornecendo suporte tático em tempo real para impulsionar ações de empresas para que reajam imediatamente aos eventos que ocorrerem.

Uma das tecnologias que melhor fornece a habilidade de carga de dados Real Time e o CDC (Change Data Capture).

CDC é um conjunto de padrões de software usados ​​para determinar (e rastrear) os dados que foram alterados de modo que uma ação pode ser tomada utilizando os dados alterados. Além disso, Change Data Capture (CDC) é uma abordagem para a integração de dados que se baseia na identificação, captura e entrega das modificações realizadas nas fontes de dados corporativas.

Exemplo de como ativar o CDC no SQL Server 2008:

1- O Serviço Agent do SQL Server 2008 precisa estar ativo.

2- Código para habilitar o CDC.

/*Habilita o Banco para uso do CDC*/

USE DB_NAME

GO

exec sys.sp_cdc_enable_db

-- Mostra os BDs com CDC ativo

select name, is_cdc_enabled from sys.databases

/*Habilita a tabela para o CDC*/

exec sys.sp_cdc_enable_table

    @source_schema = 'dbo',

    @source_name = 'TABLE_NAME' ,

    @role_name = 'CDCRole',

    @supports_net_changes = 1

/*Esse exemplo habilita as colunas a serem rastreadas*/

EXEC sys.sp_cdc_enable_table

@source_schema = N'dbo',

@source_name   = N'TABLE_NAME',

@role_name     = NULL,

@captured_column_list = '[COLUMN_NAME1],[ COLUMN_NAME2]'

   

/*Lista Tabelas rastreadas pelo CDC*/

select name, type, type_desc, is_tracked_by_cdc from sys.tables

where is_tracked_by_cdc = 1

-- ou

EXEC sys.sp_cdc_help_change_data_capture

Real Time BI and Change Data Capture (English Version)

Real-time business intelligence (RTBI) is the process of delivering information about business operations as they occur.

Business operations as they occur are fed into the RTBI system in real time (Or Near real time) which shows the current state of the company; allowing not only the classical visions of the past of classical DW system. Providing real-time tactical support to boost shares of companies to immediately respond to events as they occur.

One of the technologies that best provides the ability to load data and Real Time CDC (Change Data Capture).

CDC is a set of software design patterns used to determine (and track) the data that has changed so that action can be taken using the changed data. Also, Change data capture (CDC) is an approach to data integration that is based on the identification, capture and delivery of the changes made to enterprise data sources.

Example of how to enable CDC in SQL Server 2008:

1 - The SQL Server Agent service needs to be active.

2 - Code to enable the CDC.

/* Enables the database to use the CDC*/

USE DB_NAME

GO

exec sys.sp_cdc_enable_db

-- Shows DBs with active CDC

select name, is_cdc_enabled from sys.databases

/* Enables the table for use CDC */

exec sys.sp_cdc_enable_table

    @source_schema = 'dbo',

    @source_name = 'TABLE_NAME' ,

    @role_name = 'CDCRole',

    @supports_net_changes = 1

/* This example enables the columns to be tracked*/

EXEC sys.sp_cdc_enable_table

@source_schema = N'dbo',

@source_name   = N'TABLE_NAME',

@role_name     = NULL,

@captured_column_list = '[COLUMN_NAME1],[ COLUMN_NAME2]'

   

/* Tables listed to be tracked by CDC*/

select name, type, type_desc, is_tracked_by_cdc from sys.tables

where is_tracked_by_cdc = 1

-- or

EXEC sys.sp_cdc_help_change_data_capture

Surrogate Key (English Version)

Surrogate Key

The Surrogate word can be interpreted as an artificial synthetic product that is used to replace a natural product; Surrogate = Substitute; Applying this definition to dimensional modeling can say that a synthetic key is an artificial key that is used to replace a natural key the transactional environment.

The Surrogate Key (numeric, incremental and meaningless) arises from a concern not to have an informational database, linked and dependent on a transactional database. That is, has the benefit of immunize the DW  of the environmental changes and operational changes. Having the key independent of all other columns insulates possible changes in relationships of values ​​from the database or database design (making the database faster) ensuring the singularities.

Usually generate the surrogate key column based on a numeric data type which varies storing bytes according to the value stored. That is, if a field NUMERIC (10) is used in the definition of a Surrogate Key value will not be stored ten positions indicated in the definition of the field, but the actual value stored with the limit of ten positions. In Oracle this characteristic can be observed using the function VSIZE.

ETL tools have several tasks for the generation of Surrogates Key's as SAS Data Integration Studio, SAP Data Services, IBM Data Stage and etc..

DBMS solutions can also provide the generation of these keys as the data type  IDENTITY of SQL Server and  Oracle SEQUENCE function.

Why use Surrogate Key:

•        Keys transactional can be reused;

•        Treatment of historic dimensions;

•        Saving space;

•        Enable the integration of databases that have not integrated codes matching in transactional databases;

•        Enable the creation of control values ​​without including in transactional environment. Example: Client not registered, open date, etc..;

•        Improved performance in joins between tables.

How should be a Surrogate Key:

•        Must be an integer;

•        Sequential numbering increasing;

•        Must start at 1 until the required number;

•        There must have implicit meaning;

•        Shouldn't be a composite of transactional key.

Surrogate Key

Surrogate Key

A palavra Surrogate pode ser vista como um produto artificial sintético que é utilizado para substituir um produto natural; Surrogate = Substituta; Aplicando essa definição à modelagem dimensional pode-se dizer que uma chave sintética é uma chave artificial que é utilizada para substituir uma chave natural do ambiente transacional.

A Surrogate Key (campo numérico, incremental e sem significado) nasce da preocupação de não se ter uma base de dados informacional, vinculada e dependente de uma base transacional. Ou seja, possui como benefício imunizar o DW de mudanças de ambiente e de alterações operacionais. Ter a chave independente de todas as outras colunas isola possíveis mudanças de valores nos relacionamentos do banco de dados ou projeto do banco de dados (tornando a base de dados mais ágil) garantindo as singularidades.

Costumamos gerar a Surrogate Key baseada em uma coluna do tipo de dados numérico o qual varia o armazenamento de bytes de acordo com o valor armazenado. Ou seja, se um campo NUMERIC(10) for utilizado na definição de uma Surrogate Key o valor armazenado não será das dez posições indicadas na definição do campo, mas sim a do valor real armazenado com o limite de dez posições. No Oracle essa característica pode ser observada utilizando-se a função VSIZE.

Várias ferramentas de ETL possuem tarefas para a geração de Surrogates Key's , como SAS Data Integration Studio, SAP Data Services, IBM Data Stage e etc.

Soluções de BD's também podem prover a geração destas chaves como o tipo de Dados IDENTITY do SQL Server e a função SEQUENCE do Oracle.

Porque utilizar as Surrogate Key's:

·         Chaves transacionais podem ser reutilizadas;

·         Tratamento de histórico nas dimensões;

·         Economia de espaço;

·         Possibilitar a integração de bases de dados não integradas que possuam códigos transacionais coincidentes;

·         Possibilitar a criação de valores de “controle” sem implicar na sua inclusão no ambiente transacional. Exemplo: Cliente não cadastrado, Data em aberto, etc.;

·         Melhoria de performance nos joins entre tabelas.

Como deve ser uma Surrogate Key:

·         Deve ser um número inteiro;

·         Numeração seqüencial crescente;

·         Deve iniciar em 1 até o número necessário;

·         Não deve ter Significado implícito;

·         Não deve ser uma composição de chaves do transacional.