# Usando carregamentos inline para carregar dados Digite os dados manualmente em um script para definir uma tabela inline, que pode ser carregada em um aplicativo. Você pode trabalhar com carregamentos inline no Editor de carregamento de dados. 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. Os dados adicionados com carregamentos inline estarão contidos no aplicativo se ele for exportado. As tabelas inline podem ser lidas e editadas no script de carregamento. Um carregamento inline básico cria uma tabela e insere os campos de dados e registros. Carregamento inline no editor de carregamento de dados Carregamento inline no editor de carregamento de dados Carregamento inline no editor de carregamento de dados ![Carregamento inline no editor de carregamento de dados.](https://help.qlik.com/pt-BR/sense/November2025/Subsystems/Hub/Content/Resources/Images/ui_gen_inline_load_client-managed-rev.png) ## 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 Qlik Sense a carregar todos os campos da tabela inline a seguir. * MyTable: define o nome da tabela. A lista de tabelas no aplicativo pode ser acessada em Visualizador do modelo de dados e outras áreas. * 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. ## Carregando uma tabela inline Faça o seguinte: 1. Em um aplicativo, abra Editor de carregamento de dados. 2. Em uma nova linha, defina a tabela usando a sintaxe necessária. [Exemplo de sintaxe básica](https://help.qlik.com/pt-BR/sense/November2025/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm#BasicSyntax) 3. Quando terminar, clique em Carregar dados. ## 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. ## 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. ### Comandos LOAD e inline Uma tabela inline é carregada com a cláusula inline quando você usa a instrução de LOAD do script. 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 o comando LOAD, consulte [Carregar](https://help.qlik.com/pt-BR/sense/November2025/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm). ### Anexos e entrada de dados Os dados inseridos por meio de uma cláusula inline devem ser colocados entre 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 anexo 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/sense/November2025/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.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. ### Finalizando 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 obter exemplos específicos, consulte [Exemplos – Carregamentos inline com transformações](https://help.qlik.com/pt-BR/sense/November2025/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.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 ver exemplos, consulte [Exemplos – Delimitadores alternativos](https://help.qlik.com/pt-BR/sense/November2025/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm#ExDelimiter). Consulte: [Delimiter is](https://help.qlik.com/pt-BR/sense/November2025/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptSpecifiers/delimiter.htm) * Omitindo os cabeçalhos das colunas da tabela. Para ver um exemplo, consulte [Exemplo – Omitindo cabeçalhos de coluna](https://help.qlik.com/pt-BR/sense/November2025/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm#ExOmitLabels). Consulte: [Labels](https://help.qlik.com/pt-BR/sense/November2025/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptSpecifiers/labels.htm) * Usando outro formato de dados (por exemplo, formato de registro fixo). Para ver um exemplo, consulte [Exemplo – Carregando outro tipo de dados](https://help.qlik.com/pt-BR/sense/November2025/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm#ExChangeFormat). Consulte: [Table format](https://help.qlik.com/pt-BR/sense/November2025/Subsystems/Hub/Content/Sense_Hub/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 ver um exemplo, consulte [Exemplo – Conteúdo multilinha](https://help.qlik.com/pt-BR/sense/November2025/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm#ExMultLine). Consulte: [Quotes](https://help.qlik.com/pt-BR/sense/November2025/Subsystems/Hub/Content/Sense_Hub/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/sense/November2025/Subsystems/Hub/Content/Sense_Hub/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 ver um exemplo específico, consulte [Exemplo – Operadores para transformações e cláusulas](https://help.qlik.com/pt-BR/sense/November2025/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.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/sense/November2025/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm#Enclosure). #### Script de carregamento e resultados Este exemplo demonstra como você pode usar crases para incluir 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. Visão geral Abra o Editor de carregamento de dados e adicione o script de carregamento a seguir a uma nova seção. 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 Carregue os dados e abra uma pasta. Crie uma nova tabela e adicione esses campos como dimensões: * `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/sense/November2025/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.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. Abra o editor da carga de dados e adicione o script de carregamento abaixo em uma nova seção. O script de carregamento contém: * Quatro tabelas a serem carregadas. Elas são as seguintes: * Table1: o delimitador é uma barra vertical (barra). Os dados na coluna Phrase contêm vírgulas. * Table2: o delimitador é o símbolo 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 delimitador. 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 Carregue os dados e abra uma pasta. Crie quatro tabelas e adicione as dimensões a elas da seguinte forma: * Table1: ID, Phrase * Table2: Num1, Chr1 * Table3: Num2, Chr2 * Table4: Num3, Chr3 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 – Combinação de carregamentos inline e carregamentos de outras fontes de dados #### Script de carregamento e resultados Visão geral O script a seguir carrega primeiro uma série de campos de um conector e, em seguida, carrega uma tabela inline com um campo comum e um campo adicional. Este novo campo fornece outra propriedade sobre o item de linha que não foi carregado por meio da conexão de dados. Observe que isso só funciona perfeitamente quando há um único nome de campo em comum entre as duas tabelas. Se houver mais de um nome de campo comum, uma chave sintética será produzida. Neste exemplo truncado, carregamos uma tabela de detalhes do pedido a partir de uma conexão de dados. Em seguida, usamos uma tabela inline para adicionar um campo adicional, Supplemental Info. Isso pode, por exemplo, conter detalhes sobre comentários especiais sobre IDs de pedidos específicos. Script de carregamento ``` SET DateFormat='MM/DD/YYYY'; Orders: LIB CONNECT TO 'My_Generic_Connection'; LOAD PRODUCT_DIVISION_A_ORDER_ID as Order ID, PRODUCT_DIVISION_A_ORDER_DATE as ISSUE_KEY as Order Date, PRODUCT_DIVISION_A_TYPE as Product Type, PRODUCT_DIVISION_A_SALES_MANAGER as Manager, PRODUCT_DIVISION_A_SHIPPED_STATUS as Shipped Status; SELECT PRODUCT_DIVISION_A_ORDER_ID, PRODUCT_DIVISION_A_ORDER_DATE, PRODUCT_DIVISION_A_TYPE, PRODUCT_DIVISION_A_SALES_MANAGER, PRODUCT_DIVISION_A_SHIPPED_STATUS FROM SourceTable WITH PROPERTIES ( [...] ); Orders_Inline_Info: load * inline [ Order ID,Supplemental Info PSF-001014,'Bulk order, pending deal with Paracel.' PSF-001625,'NOTE: Product damaged. Investigation required.' ]; ``` Resultados Depois de carregar os dados, digamos que adicionamos as seguintes dimensões a uma tabela: * Order ID * Order Date * Product Type * Manager * Shipped Status * Supplemental Info O gráfico resultante poderia ser assim. Tabela de resultados: OrdersOrders | Order ID | Order Date | Product Type | Manager | Shipped Status | Supplemental Info | | --- | --- | --- | --- | --- | --- | | PSF-000998 | 1/13/2024 | Electronics | Amanda Honda | Shipped | - | | PSF-000999 | 1/15/2024 | Automotive | Molly McKenzie | Not Shipped | - | | PSF-001014 | 1/17/2024 | Home Appliances | Amalia Craig | Undefined | Bulk order, pending deal with Paracel. | | PSF-001625 | 1/21/2024 | Electronics | Amanda Honda | Undefined | Product damaged. Investigation required. | Observe como todos os campos de ambas as tabelas podem ser adicionados à mesma visualização. As tabelas estão associadas entre si no modelo de dados. ## 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/sense/November2025/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.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. Abra o Editor de carregamento de dados e adicione o script de carregamento a seguir a uma nova seção. Script de carregamento ``` Expenses: Load * inline [ 1,Category1,40566.49 2,Category2,3504.54 3,Category3,593206.30 ] (no labels); ``` Resultados Carregue os dados e abra uma pasta. Crie uma nova tabela e adicione esses campos como dimensões: * @1 * @2 * @3 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/sense/November2025/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm#FormatSpec). #### Script de carregamento e resultados Visão geral Abra o editor da carga de dados e adicione o script de carregamento abaixo em uma nova seção. O script de carregamento contém: * 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 Carregue os dados e abra uma pasta. Crie uma nova tabela e adicione esses campos como dimensões: * a * b * c * d 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/sense/November2025/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm#FormatSpec). #### Script de carregamento e resultados Visão geral Abra o editor da carga de dados e adicione o script de carregamento abaixo em uma nova seção. O script de carregamento contém: * Um carregamento inline 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 Carregue os dados e abra uma pasta. Crie uma nova tabela e adicione esses campos como dimensões: * ID * Length Para visualizar o conteúdo multilinha conforme pretendido, a configuração Quebrar texto nas células deve estar ativada no painel de propriedades. Além disso, o tema do aplicativo (ou configurações de visualização) deve permitir Altura de linha (em linhas) suficiente. Tabela de resultados | ID | Length | | --- | --- | | 1 | 1' 2"

22' 10" | | 2 | 14' 8" | Na tabela acima, o registro com um valor 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/sense/November2025/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm#Transform). #### Exemplo: renomeação simples de um campo Visão geral Abra o Editor de carregamento de dados e adicione o script de carregamento a seguir a uma nova seção. Script de carregamento ``` ORDERS: Load Original as Updated, * Inline [ Original ProductA ProductB ProductC ]; ``` Resultados Carregue os dados e abra uma pasta. Crie uma nova tabela e adicione esses campos como dimensões: * Original * Updated 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. Abra o Editor de carregamento de dados e adicione o script de carregamento a seguir a uma nova seção. Script de carregamento ``` ORDERS: Load RowNo() as ID, * Inline [ ProductName A B C D E ]; ``` Resultados Carregue os dados e abra uma pasta. Crie uma nova tabela e adicione esses campos como dimensões: * ID * ProductName 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 ,). Abra o editor da carga de dados e adicione o script de carregamento abaixo em uma nova seção. O script de carregamento contém: * 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 Carregue os dados e abra uma pasta. Crie três tabelas e adicione as dimensões a elas da seguinte forma: * DerivedYears1: initial\_date1, derived\_year1 * DerivedYears2: initial\_date2 * DerivedYears3: initial\_date3, derived\_year3 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. Abra o editor da carga de dados e adicione o script de carregamento abaixo em uma nova seção. O script de carregamento contém: * 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 Carregue os dados e abra uma pasta. Crie uma nova tabela e adicione esse campo como uma dimensão: ProductName\_Trimmed. 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/sense/November2025/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm#OpsAndClauses). [Operadores](https://help.qlik.com/pt-BR/sense/November2025/Subsystems/Hub/Content/Sense_Hub/Scripting/Operators/operators.htm) #### Script de carregamento e resultados Visão geral Abra o editor da carga de dados e adicione o script de carregamento abaixo em uma nova seção. O script de carregamento contém: * Um carregamento inline 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>0.05 ; ``` Resultados Carregue os dados e abra uma pasta. Crie uma nova tabela e adicione esses campos como dimensões: * ID * amount * OrderSize 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/sense/November2025/Subsystems/Hub/Content/Sense_Hub/Scripting/ValueHandlingVariables/NullInterpret.htm) #### Script de carregamento e resultados Visão geral Abra o editor da carga de dados e adicione o script de carregamento abaixo em uma nova seção. O script de carregamento contém: * Um carregamento inline 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 Carregue os dados e abra uma pasta. Crie uma nova tabela e adicione esse campo como uma dimensão: Test. 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 obter exemplos adicionais, consulte [Carregar](https://help.qlik.com/pt-BR/sense/November2025/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm). APRENDIZADO RELACIONADO: * [Introdução ao editor de carregamento de dados](https://help.qlik.com/lnk/Intro_Data_Load_Editor_QS) ## Saiba mais * [Load](https://help.qlik.com/pt-BR/sense/November2025/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm) * [Itens de especificação de formato](https://help.qlik.com/pt-BR/sense/November2025/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptSpecifiers/format-specification-items.htm) * [Introdução ao editor de carregamento de dados](https://help.qlik.com/lnk/Intro_Data_Load_Editor_QS)