# Carregando dados de tabelas inline
Digite os dados manualmente em um script para definir uma tabela inline.
Você cria tabelas inline digitando dados manualmente no script, em vez de conectar-se a arquivos e bancos de dados. Use a sintaxe necessária para indicar que o texto do script deve ser interpretado como dados inline.
Um carregamento inline básico cria uma tabela e insere os campos de dados e registros.
## Por que usar carregamentos inline?
Carregamentos inline podem ser úteis em vários casos de uso:
* Administração e edição de dados sem necessidade de conexão com fontes externas.
* Complementando os dados existentes no modelo de dados. Por exemplo, você poderia adicionar uma tabela adicional a um modelo de dados que provém principalmente de fontes de banco de dados.
* Adicionar dados que você gostaria de evitar o carregamento contínuo de fontes externas. Isso pode economizar tempo se você souber que a fonte de dados poderá mudar no futuro, mas os valores dos dados permanecerão os mesmos.
* Facilidade de uso para copiar e colar conteúdo de outros arquivos no script. Por exemplo, arquivos .csv ou tabelas de documentos de processadores de texto.
* Criação de scripts de teste que podem ser copiados e colados rapidamente.
## Exemplo de sintaxe básica
O script a seguir contém um carregamento inline simples.
```
MyTable:
Load * Inline [Country, Year, Sales
Argentina, 2014, 66295.03
Argentina, 2015, 140037.89
Austria, 2014, 54166.09
Austria, 2015, 182739.87
];
```
A seguinte sintaxe é usada para o carregamento inline acima:
* O Load \* Inline instrui o QlikView a carregar todos os campos da tabela embutida a seguir.
* MyTable: define o nome da tabela.
* Colchetes delimitam os dados.
* A primeira linha da instrução de LOAD define os campos de dados.
* Vírgulas separam campos de dados e registros.
* Um ponto e vírgula fecha a instrução de LOAD.
## Visão geral da sintaxe
### Nomeando a tabela
Você pode adicionar um nome para a tabela inline, como faria para outras tabelas carregadas. Definir o nome da tabela é opcional.
Após o nome da tabela, insira dois pontos.
### Instruções de LOAD e inline
Uma tabela inline é carregada com a cláusula inline quando você usa a instrução de script LOAD. A cláusula inline indica que o texto subsequente na tabela conterá dados digitados manualmente no editor. A menos que você indique o contrário, uma tabela inline usa o formato txt que segue a estrutura de um arquivo de texto delimitado.
Para obter mais informações sobre a instrução de LOAD, consulte [Load](https://help.qlik.com/pt-BR/qlikview/September2025/Subsystems/Client/Content/QV_QlikView/Scripting/ScriptRegularStatements/Load.htm).
### Anexos e entrada de dados
Os dados inseridos por meio de uma cláusula inline devem ser delimitados por caracteres específicos. As seguintes combinações de caracteres são aceitas para incluir os dados:
* Colchetes: `[` e `]`
* Aspas duplas: `"` e `"`
* Aspas simples: `'` e `'`
* Crases: `` ` `` e `` ` ``
O caractere escolhido como gabinete pode ajudá-lo a carregar dados inline que contenham caracteres conflitantes. Por exemplo, se seus dados contiverem registros entre colchetes, você poderá colocá-los entre aspas ou crases.
Para obter um exemplo de anexos alternativos, consulte [Exemplo – Anexos de dados alternativos](https://help.qlik.com/pt-BR/qlikview/September2025/Subsystems/Client/Content/QV_QlikView/Scripting/inline-loads-qv.htm#ExDataEnc).
A menos que você especifique um formato de tabela alternativo (o padrão é txt), o texto entre os anexos será interpretado da mesma maneira que o conteúdo de um arquivo. Portanto, no local em que uma nova linha for inserida em um arquivo de texto, você também deverá inseri-la no texto de uma cláusula inline, pressionando a tecla Enter ao digitar o script.
### Encerrando o carregamento inline
O final da instrução de LOAD inline é indicado com ponto e vírgula.
### Transformações de dados
Em um carregamento inline simples sem transformações, o número de colunas é definido pela primeira linha. Existem três colunas na tabela carregadas pelo exemplo a seguir: `Product_ID`, `Supplier_Name` e `Product_Category`.
```
Products:
Load * Inline [
Product_ID, Supplier_Name, Product_Category
1, Paracel, Home Decor
2, PageWave, Electronics
3, Talarian, Software
4, Userland, Appliances
];
```
Você também pode realizar transformações e criar novas colunas na mesma tabela inline. Você pode usar carregamentos anteriores e mais de uma instrução de LOAD pode ser usada para carregar a mesma tabela.
Para exemplos específicos, consulte [Exemplos – Carregamentos inline com transformações](https://help.qlik.com/pt-BR/qlikview/September2025/Subsystems/Client/Content/QV_QlikView/Scripting/inline-loads-qv.htm#ExTransform).
### Configurando a especificação de formato em um carregamento inline
Como acontece com outras tabelas carregadas, você pode modificar a especificação de formato da tabela inline usando itens de especificação de formato. A especificação do formato é adicionada entre colchetes. Deve ser adicionado após os delimitadores de dados, mas antes do ponto e vírgula que encerra a instrução de LOAD. Algumas das personalizações que você pode adicionar incluem:
* Alterando o delimitador de vírgula para outro caractere. Para obter exemplos, consulte [Exemplos – Delimitadores alternativos](https://help.qlik.com/pt-BR/qlikview/September2025/Subsystems/Client/Content/QV_QlikView/Scripting/inline-loads-qv.htm#ExDelimiter).
Consulte: [Delimiter](https://help.qlik.com/pt-BR/qlikview/September2025/Subsystems/Client/Content/QV_QlikView/Scripting/ScriptSpecifiers/delimiter.htm)
* Omitindo os cabeçalhos das colunas da tabela. Para obter um exemplo, consulte [Exemplo – omitindo cabeçalhos de coluna](https://help.qlik.com/pt-BR/qlikview/September2025/Subsystems/Client/Content/QV_QlikView/Scripting/inline-loads-qv.htm#ExOmitLabels).
Consulte: [Labels](https://help.qlik.com/pt-BR/qlikview/September2025/Subsystems/Client/Content/QV_QlikView/Scripting/ScriptSpecifiers/labels.htm)
* Usando outro formato de dados (por exemplo, formato de registro fixo). Para obter um exemplo, consulte [Exemplo – carregando outro tipo de dados](https://help.qlik.com/pt-BR/qlikview/September2025/Subsystems/Client/Content/QV_QlikView/Scripting/inline-loads-qv.htm#ExChangeFormat).
Consulte: [Formato da tabela](https://help.qlik.com/pt-BR/qlikview/September2025/Subsystems/Client/Content/QV_QlikView/Scripting/ScriptSpecifiers/table-format.htm)
Nota informativaNem todas as opções de Table format são compatíveis para carregamentos inline.
* Permitindo conteúdo multilinha. Para obter um exemplo, consulte [Exemplo – Conteúdo multilinha](https://help.qlik.com/pt-BR/qlikview/September2025/Subsystems/Client/Content/QV_QlikView/Scripting/inline-loads-qv.htm#ExMultLine).
Consulte: [Quotes](https://help.qlik.com/pt-BR/qlikview/September2025/Subsystems/Client/Content/QV_QlikView/Scripting/ScriptSpecifiers/quotes.htm)
Para usar vários itens de especificação de formato na mesma tabela, separe-os com vírgulas. Por exemplo:` (Delimiter is '|', no labels) `
Para obter detalhes completos sobre a especificação do formato, consulte [Itens de especificação de formato](https://help.qlik.com/pt-BR/qlikview/September2025/Subsystems/Client/Content/QV_QlikView/Scripting/ScriptSpecifiers/format-specification-items.htm).
### Operadores e outras cláusulas
Além disso, como um carregamento inline é uma instrução de LOAD, você pode combinar outros argumentos da instrução de LOAD no carregamento inline. Por exemplo, use a cláusula where ou while para definir se uma linha específica deve ser carregada ou não, com base no texto dentro dela.
Da mesma forma, você também pode usar operadores fora do próprio conteúdo do texto. Com os operadores, você pode personalizar a forma como transforma os dados inline e também definir quando carregar determinados dados ou não.
Para obter um exemplo específico, consulte [Exemplo – operadores para transformações e cláusulas](https://help.qlik.com/pt-BR/qlikview/September2025/Subsystems/Client/Content/QV_QlikView/Scripting/inline-loads-qv.htm#ExOpsAndClauses).
## Exemplo – Anexos de dados alternativos
Você pode usar colchetes, aspas ou crases para delimitar um carregamento inline. Esta seção ilustra isso com um exemplo. Para obter mais informações, consulte [Anexos e entrada de dados](https://help.qlik.com/pt-BR/qlikview/September2025/Subsystems/Client/Content/QV_QlikView/Scripting/inline-loads-qv.htm#Enclosure).
#### Script de carregamento e resultados
Visão geral
Este exemplo demonstra como você pode usar crases para delimitar os dados inline. Os dados no exemplo contêm caracteres de colchetes, o que torna os colchetes incompatíveis como delimitadores da instrução de LOAD.
Script de carregamento
```
DataTable:
Load * inline
`
custom_property, date, amount
[11402], 1/1/2024, 92.99
[11403], 1/2/2024, 102.34
[11404], 1/3/2024, 50.26
[11405], 1/4/2024, 153.69
[11406], 1/5/2024, 75.62
`;
```
Resultados
* `custom_property`
* `date`
* `amount`
Tabela de resultados
| custom\_property | date | amount |
| --- | --- | --- |
| [11402] | 1/1/2024 | 92.99 |
| [11403] | 1/2/2024 | 102.34 |
| [11404] | 1/3/2024 | 50.26 |
| [11405] | 1/4/2024 | 153.69 |
| [11406] | 1/5/2024 | 75.62 |
## Exemplos – Delimitadores alternativos
Você pode usar um caractere diferente de vírgula para delimitar os valores das colunas na tabela. Para obter mais informações, consulte [Configurando a especificação de formato em um carregamento inline](https://help.qlik.com/pt-BR/qlikview/September2025/Subsystems/Client/Content/QV_QlikView/Scripting/inline-loads-qv.htm#FormatSpec).
#### Script de carregamento e resultados
Visão geral
A troca do delimitador é útil quando os dados da tabela contêm vírgulas, o que de outra forma sinalizaria a mudança para a próxima coluna da tabela.
Este exemplo contém:
* Quatro tabelas a serem carregadas. Eles são os seguintes:
* Table1: o delimitador é uma barra vertical (barra). Os dados na coluna Phrase contêm vírgulas.
* Table2: o delimitador é um sinal de dois pontos.
* Table3: o delimitador é uma barra invertida.
* Table4: a tabela é delimitada pressionando a tecla Tab do teclado. Esta opção é útil quando você copia uma tabela de um processador de texto e a cola no script.
Table1 mostra um caso de uso prático para usar um delimitador alternativo. As outras tabelas mostram mais opções de delimitadores.
Script de carregamento
```
Table1:
LOAD * INLINE [
ID|Phrase
1 | 'The transaction was complete, but the order has not yet shipped.'
2 | 'We need to confirm the following details: sales rep number, order status, and shipping priority.'
] (Delimiter is '|');
Table2:
LOAD * INLINE [
Num1:Chr1
1:A
2:B ] (Delimiter is ':');
Table3:
LOAD * INLINE [
Num2\Chr2
1\A
2\B ] (Delimiter is \\);
Table4:
LOAD * INLINE [
Num3 Chr3
1 A
2 B ] (Delimiter is '\t');
```
Resultados
Tabela de resultados: Table1Table1
| ID | Phrase |
| --- | --- |
| 1 | The transaction was complete, but the order has not yet shipped. |
| 2 | We need to confirm the following details: sales rep number, order status, and shipping priority. |
Tabela de resultados: Table2Table2
| Num1 | Chr1 |
| --- | --- |
| 1 | A |
| 2 | B |
Tabela de resultados: Table3Table3
| Num2 | Chr2 |
| --- | --- |
| 1 | A |
| 2 | B |
Tabela de resultados: Table4Table4
| Num3 | Chr3 |
| --- | --- |
| 1 | A |
| 2 | B |
## Exemplo – omitindo cabeçalhos de coluna
Edite a especificação de formato para carregar uma tabela inline sem definir cabeçalhos de coluna. Isso é feito com a especificação labels (definindo-a com um valor de no labels). Para obter mais informações, consulte [Configurando a especificação de formato em um carregamento inline](https://help.qlik.com/pt-BR/qlikview/September2025/Subsystems/Client/Content/QV_QlikView/Scripting/inline-loads-qv.htm#FormatSpec).
Quando você carrega uma tabela sem definir nomes de colunas, os nomes de colunas definidos pelo sistema são usados automaticamente.
#### Script de carregamento e resultados
Visão geral
Este exemplo demonstra como você pode carregar uma tabela inline sem definir nomes de colunas.
Script de carregamento
```
Expenses:
Load * inline
[
1,Category1,40566.49
2,Category2,3504.54
3,Category3,593206.30
] (no labels);
```
Resultados
Tabela de resultados
| @1 | @2 | @3 |
| --- | --- | --- |
| 1 | Category1 | 40566.49 |
| 2 | Category2 | 3504.54 |
| 3 | Category3 | 593206.30 |
## Exemplo – carregando outro tipo de dados
Este exemplo demonstra como você pode carregar uma tabela inline em formato de registro fixo. Consulte [Configurando a especificação de formato em um carregamento inline](https://help.qlik.com/pt-BR/qlikview/September2025/Subsystems/Client/Content/QV_QlikView/Scripting/inline-loads-qv.htm#FormatSpec).
#### Script de carregamento e resultados
Visão geral
Este script de exemplo contém o seguinte:
* Uma instrução de LOAD inline que define a tabela DataTable.
* O uso de fix (como parte da especificação Table format) para indicar que os dados a serem carregados estão em formato de registro fixo.
Script de carregamento
```
DataTable:
LOAD
"@1:4",
"@5:8",
"@9:12",
"@13:16"
INLINE [
a b c d
1 2 3 4
x y z w
] (fix, utf8, embedded labels);
```
Resultados
Tabela de resultados
| a | b | c | d |
| --- | --- | --- | --- |
| 1 | 2 | 3 | 4 |
| x | y | z | w |
## Exemplo – Conteúdo multilinha
Este exemplo demonstra como você pode inserir conteúdo de campo multilinha em uma tabela inline. Consulte [Configurando a especificação de formato em um carregamento inline](https://help.qlik.com/pt-BR/qlikview/September2025/Subsystems/Client/Content/QV_QlikView/Scripting/inline-loads-qv.htm#FormatSpec).
#### Script de carregamento e resultados
Visão geral
Este script de exemplo contém o seguinte:
* Um carregamento embutido simples para definir a tabela T1.
* Uso do especificador Quotes (com o valor msq) para oferecer suporte a conteúdo multilinha.
* Valores de comprimento especificados em pés e polegadas.
* O símbolo de aspas duplas (") indica o final de uma entrada multilinha. Neste exemplo, o mesmo símbolo também é usado para denotar os valores em polegadas. Isso é feito para mostrar a sintaxe e o comportamento resultante se você precisar usar ambos na mesma instrução de LOAD. Essencialmente, inserir o símbolo " com dois caracteres consecutivos ("") indica que o código deve ser interpretado como uma única instância de texto do símbolo.
Script de carregamento
```
T1:
Load *, recno() as ID inline [
Length
"1' 2""
22' 10"""
14' 8" ] (msq);
```
Resultados
Para visualizar o conteúdo multilinha conforme pretendido, você precisará ajustar as Configurações Multilinha do gráfico na configuração Propriedades....
Tabela de resultados
| ID | Length |
| --- | --- |
| 1 | 1' 2"
22' 10" |
| 2 | 14' 8" |
Na tabela acima, o registro com valor de ID de 1 contém conteúdo multilinha.
## Exemplos – Carregamentos inline com transformações
Estes exemplos mostram como você pode realizar cálculos em campos carregados inline para criar novos campos no modelo de dados.
Para obter mais informações, consulte [Transformações de dados](https://help.qlik.com/pt-BR/qlikview/September2025/Subsystems/Client/Content/QV_QlikView/Scripting/inline-loads-qv.htm#Transform).
#### Exemplo: renomeação simples de um campo
Script de carregamento
```
ORDERS:
Load Original as Updated,
* Inline
[
Original
ProductA
ProductB
ProductC
];
```
Resultados
Tabela de resultados
| Original | Updated |
| --- | --- |
| ProductA | ProductA |
| ProductB | ProductB |
| ProductC | ProductC |
#### Exemplo: inserção simples de um campo ID
Visão geral
Este exemplo mostra como você pode definir um campo calculado para indicar o ID de cada linha de dados, sem digitar manualmente cada valor de ID.
Script de carregamento
```
ORDERS:
Load RowNo() as ID,
* Inline
[
ProductName
A
B
C
D
E
];
```
Resultados
Tabela de resultados
| ID | ProductName |
| --- | --- |
| 1 | A |
| 2 | B |
| 3 | C |
| 4 | D |
| 5 | E |
#### Exemplo: configurando instruções de LOAD para lidar com transformações
Visão geral
Este exemplo mostra diversas maneiras pelas quais uma transformação simples pode ser aplicada a dados inline. Você pode usar uma ou várias instruções de LOAD e configurar a sintaxe de maneiras diferentes para definir se uma transformação substitui ou não o campo original ou se os campos original e novo serão carregados.
Em particular, observe as variações a seguir e como elas afetam a saída:
* Número de instruções de LOAD dentro da tabela.
* Presença ou ausência de símbolo \* (carrega todos os campos subsequentes).
* Presença ou ausência de vírgulas (símbolo ,).
Este script de exemplo contém o seguinte:
* Quatro tabelas, todas referenciando os mesmos dados. Os nomes dos campos são diferentes.
* DerivedYears1: usa duas instruções de LOAD para carregar uma coluna inline e uma coluna contendo uma transformação da coluna inline.
* DerivedYears2: usa duas instruções de LOAD. O script carrega uma coluna inline e, em seguida, carrega um campo calculado transformado da coluna original. Com a segunda instrução de LOAD, a coluna original não é carregada na tabela, tornando efetivamente o novo campo uma substituição do campo original.
* DerivedYears3: usa uma única instrução de LOAD para carregar a coluna inline original e uma coluna transformada.
* DerivedYears4: usa uma única instrução de LOAD para definir um campo inline e uma transformação desse campo original. Somente o campo transformado é carregado na tabela.
Script de carregamento
```
DerivedYears1:
Load *,
Year(initial_date1) as derived_year1
;
Load
* inline [
initial_date1
'1/1/2022'
'1/1/2023'
'1/1/2024'
];
DerivedYears2:
Load
Year(initial_date2) as derived_year2
;
Load
* inline [
initial_date2
'1/1/2022'
'1/1/2023'
'1/1/2024'
];
DerivedYears3:
Load Year(initial_date3) as derived_year3,
* inline [
initial_date3
'1/1/2022'
'1/1/2023'
'1/1/2024'
];
DerivedYears4:
Load Year(initial_date4) as derived_year4
inline [
initial_date4
'1/1/2022'
'1/1/2023'
'1/1/2024'
];
```
Resultados
Tabela de resultados: DerivedYears1DerivedYears1
| initial\_date1 | derived\_year1 |
| --- | --- |
| 1/1/2022 | 2022 |
| 1/1/2023 | 2023 |
| 1/1/2024 | 2024 |
Tabela de resultados: DerivedYears2DerivedYears2
| derived\_year2 |
| --- |
| 2022 |
| 2023 |
| 2024 |
Tabela de resultados: DerivedYears3DerivedYears3
| initial\_date3 | derived\_year3 |
| --- | --- |
| 1/1/2022 | 2022 |
| 1/1/2023 | 2023 |
| 1/1/2024 | 2024 |
Tabela de resultados: DerivedYears4DerivedYears4
| derived\_year4 |
| --- |
| 2022 |
| 2023 |
| 2024 |
#### Exemplo: modificando o conteúdo do campo
Visão geral
Suponha que você esteja colando informações de um arquivo de texto grande no editor de script, mas queira realizar processamento adicional nos registros do conjunto de dados. Por exemplo, você deseja remover certos caracteres e prefixos e colocar cada palavra em maiúscula.
Este script de exemplo contém o seguinte:
* Uma tabela inline, Transformations, na qual uma transformação é definida para alterar o conteúdo de texto de um campo. O texto que está sendo transformado é adicionado depois disso.
* Duas instruções de LOAD. Com a configuração do exemplo, apenas o campo derivado ProductName\_Trimmed é carregado na tabela.
Script de carregamento
```
Transformations:
Load
Capitalize(TextBetween(OrigColumn, '{','}')) as ProductName_Trimmed;
Load * inline [
OrigColumn
Product: {soft drinks and other beverages}
Product: {snack food}
Product: {electronics and video games}
];
```
Resultados
Tabela de resultados
| ProductName\_Trimmed |
| --- |
| Soft Drinks And Other Beverages |
| Snack Food |
| Electronics And Video Games |
## Exemplo – operadores para transformações e cláusulas
Você pode usar operadores para definir transformações e cláusulas específicas na instrução de LOAD. Para obter mais informações, consulte [Operadores e outras cláusulas](https://help.qlik.com/pt-BR/qlikview/September2025/Subsystems/Client/Content/QV_QlikView/Scripting/inline-loads-qv.htm#OpsAndClauses).
[Operadores](https://help.qlik.com/pt-BR/qlikview/September2025/Subsystems/Client/Content/QV_QlikView/Scripting/Operators/operators.htm)
#### Script de carregamento e resultados
Visão geral
Este script de exemplo contém o seguinte:
* Um carregamento embutido simples para definir a tabela Purchases.
* A inserção de um campo calculado, OrderSize. Este campo é uma transformação do campo amount do conjunto de dados inline. Ele categoriza as compras como pequenas ou grandes, dependendo se o valor ultrapassa ou não US$ 2.000,00.
* Uma cláusula where que impede que os registros sejam carregados quando amount for inferior a US$ 0,05.
Script de carregamento
```
Purchases:
Load
If(amount<2000,'Small Purchase','Large Purchase') as OrderSize,
* inline
[
ID, amount
1,2660.39
2,100.01
3,500.42
4,5023.99
5,0.04
6,2002.39
7,31034.53
8,1643.58
9,3993.65
10,614.34
11,675.93
]
WHERE
amount>1
;
```
Resultados
Tabela de resultados
| ID | amount | OrderSize |
| --- | --- | --- |
| 1 | 2660.39 | Large Purchase |
| 2 | 100.01 | Small Purchase |
| 3 | 500.42 | Small Purchase |
| 4 | 5023.99 | Large Purchase |
| 6 | 2002.39 | Large Purchase |
| 7 | 31034.53 | Large Purchase |
| 8 | 1643.58 | Small Purchase |
| 9 | 3993.65 | Large Purchase |
| 10 | 614.34 | Small Purchase |
| 11 | 675.93 | Small Purchase |
Na tabela acima, a transação com um ID de 5 não foi carregada na tabela. Isso ocorre porque o valor amount é inferior a US$ 0,05.
## Exemplo – criando valores nulos em uma tabela inline
Este exemplo demonstra como você pode usar a variável NullInterpret para criar valores nulos em seus dados inline.
[NullInterpret](https://help.qlik.com/pt-BR/qlikview/September2025/Subsystems/Client/Content/QV_QlikView/Scripting/ValueHandlingVariables/NullInterpret.htm)
#### Script de carregamento e resultados
Visão geral
Este script de exemplo contém o seguinte:
* Um carregamento embutido simples para definir a tabela T2.
* A variável NullInterpret definida como duas aspas simples. Quando o script é carregado, os registros que contêm esse valor são processados como valores nulos.
Script de carregamento
```
set nullinterpret = '';
T2:
Load * inline [
Test
''
x ];
```
Resultados
Tabela de resultados
| Test |
| --- |
| x |
Na tabela acima, o primeiro registro é um valor nulo. Portanto, não está incluído na visualização. Valores nulos existentes em tabelas com dimensões adicionais seriam indicados com um símbolo -.
## Mais exemplos
Para mais exemplos, consulte [Load](https://help.qlik.com/pt-BR/qlikview/September2025/Subsystems/Client/Content/QV_QlikView/Scripting/ScriptRegularStatements/Load.htm).
## Saiba mais
* [Load](https://help.qlik.com/pt-BR/qlikview/September2025/Subsystems/Client/Content/QV_QlikView/Scripting/ScriptRegularStatements/Load.htm)
* [Itens de especificação de formato](https://help.qlik.com/pt-BR/qlikview/September2025/Subsystems/Client/Content/QV_QlikView/Scripting/ScriptSpecifiers/format-specification-items.htm)
* [Assistente para Dados Inline](https://help.qlik.com/pt-BR/qlikview/September2025/Subsystems/Client/Content/QV_QlikView/Inline_Data_Wizard.htm)