# Load A declaração LOAD carrega campos de um arquivo, de dados definidos no script, de uma tabela de entrada carregada anteriormente, de uma página da Web, do resultado de um comando SELECT subsequente ou gerando dados automaticamente. Também é possível carregar dados de conexões analíticas. LOAD [ distinct ] fieldlist [( from file [ format-spec ] | from\_field fieldassource [format-spec]| inline data [ format-spec ] | resident table-label | autogenerate size ) |extension pluginname.functionname([script] tabledescription)] [ where criterion | while criterion ] [](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm)[ group by groupbyfieldlist ] [order by orderbyfieldlist ] Argumentos | Argumento | Descrição | | --- | --- | | distinct[](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm)[](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm) | Você pode usar distinct como predicado se deseja carregar apenas registros exclusivos. Se houver registros duplicados, a primeira instância será carregada.

Se você estiver usando cargas anteriores, precisará colocar distinct na primeira instrução de carga, pois distinct afeta apenas a tabela de destino.

[Carregamento precedente](https://help.qlik.com/pt-BR/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/load-data-from-previously-loaded-table.htm#Precedin) | | [](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm)fieldlist | fieldlist ::= ( \* \| field{, \* \| field } )

Uma lista dos campos a serem carregados. O uso de \* como lista de campos indica todos os campos da tabela.

field ::= ( fieldref \| expression ) [as aliasname ]

A definição de campo deve conter sempre um literal, uma referência a um campo existente ou a uma expressão.

fieldref ::= ( fieldname \|@fieldnumber
\|@startpos:endpos
[ I \| U \| R \| B \| T] )

fieldname é um texto idêntico a um nome de campo da tabela. Observe que o nome do campo deverá estar entre aspas duplas ou colchetes se contiver espaços, por exemplo.
Às vezes, os nomes de campo não estão explicitamente disponíveis. Assim, uma notação diferente será usada:


@fieldnumber representa o número de campo em um arquivo de tabela delimitado. Deve ser um inteiro positivo, precedido de “@”. A numeração sempre inicia no número 1 até o número de campos.


@startpos:endpos representa as posições inicial e final de um campo em um arquivo com registros de comprimento fixo. As posições devem ser inteiros positivos. Os dois números devem ser precedidos de "@" e separados por dois-pontos. A numeração sempre inicia no número 1 até o número de posições. No último campo, n é usado como posição final do campo.



expression pode ser uma função numérica ou uma função de string baseada em um ou vários outros campos da mesma tabela. Para obter mais informações, consulte a sintaxe das expressões.

[](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm)[](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm)as é usado para atribuir um novo nome ao campo. | | [](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm)[](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm)[](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm)
from | from é usado se os dados precisam ser carregados a partir de um arquivo usando uma pasta ou uma conexão de dados de um arquivo da web

file ::= [ path ] filename

Exemplo: 'lib://Table Files/'

Quando o caminho for omitido, o Qlik Sense procura o arquivo no diretório especificado pelo comando Directory. Se não houver um comando Directory, o Qlik Sense pesquisa no diretório de trabalho, C:\Users\{user}\Documents\Qlik\Sense\Apps.

[Directory](https://help.qlik.com/pt-BR/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Directory.htm)

Nota informativaEm uma instalação de servidor do Qlik Sense, o diretório de trabalho é especificado no Qlik Sense Repository Service; por padrão é C:\ProgramData\Qlik\Sense\Apps. Consulte a ajuda do Qlik Management Console para obter mais informações.

O filename pode conter os caracteres curingas padrão do DOS ( \* e ? ). Isso carregará todos os arquivos correspondentes no diretório especificado.

format-spec ::= ( fspec-item { , fspec-item
} )

A especificação do formato consiste em uma lista de vários itens de especificação de formato, entre colchetes.

[Itens de especificação de formato](https://help.qlik.com/pt-BR/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptSpecifiers/format-specification-items.htm)

Nota de dicaVocê pode usar a especificação de formato [URL is](https://help.qlik.com/pt-BR/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptSpecifiers/url.htm) para substituir a URL de uma conexão de dados de arquivo da Web, por exemplo, se precisar criar uma URL dinâmica com base em outros dados que foram carregados.

Modo de script legado

No modo legado de uso de scripts, os seguintes formatos de caminho também são suportados:

| | [](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm)
from\_field | from\_field é usado se for necessário carregar dados de um campo anteriormente carregado.

fieldassource::=(tablename, fieldname)

O campo é o nome de tablename e fieldname carregados anteriormente.

format-spec ::= ( fspec-item
{, fspec-item } )

A especificação do formato consiste em uma lista de vários itens de especificação de formato, entre colchetes. Para obter mais informações, consulte [Itens de especificação de formato](https://help.qlik.com/pt-BR/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptSpecifiers/format-specification-items.htm).

Nota informativafrom\_field oferece suporte apenas a vírgulas como delimitador de lista ao separar campos em tabelas. | | [](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm)[](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm)
inline | inline será usado se os dados precisarem ser digitados no script, e não carregados de um arquivo.

data ::= [ text ]

Os dados inseridos por meio de uma cláusula inline devem ser colocados entre caracteres específicos – colchetes, aspas ou crases. O texto entre esses elementos 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.

Em um carregamento inline simples, o número de colunas é definido pela primeira linha.

format-spec ::= ( fspec-item
{, fspec-item } )

Você pode personalizar o carregamento inline com muitos dos mesmos itens de especificação de formato que estão disponíveis para outras tabelas carregadas. Esses itens estão listados entre colchetes. Para obter mais informações, consulte [Itens de especificação de formato](https://help.qlik.com/pt-BR/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptSpecifiers/format-specification-items.htm).

Para obter mais informações sobre carregamentos inline, consulte [Usando carregamentos inline para carregar dados](https://help.qlik.com/pt-BR/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm). | | [](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm)[](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm)
resident | resident é usado se for necessário carregar dados de uma tabela anteriormente carregada.

table label é um rótulo que precede o comando LOAD ou SELECT que criou a tabela original. O rótulo deve ter dois-pontos no final.

[Carregando dados de uma tabela carregada anteriormente](https://help.qlik.com/pt-BR/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/load-data-from-previously-loaded-table.htm)

[Rótulos da tabela](https://help.qlik.com/pt-BR/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/table-labels.htm) | | [](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm)[](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm)
autogenerate | autogenerate será usado se for necessário gerar os dados automaticamente pelo Qlik Sense.

size ::= number

Number é um inteiro que indica o número de registros a serem gerados.

A lista de campos não deve conter expressões que precisem de dados de uma fonte de dados externa ou de uma tabela carregada anteriormente, a menos que você faça referência a um único valor de campo em uma tabela carregada anteriormente com a função Peek. | | [](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm)extension | É possível carregar dados de conexões analíticas. Você precisa usar a cláusula extension para chamar uma função definida no plug-in SSE (Server-Side Extension) ou avaliar um script.

Você pode enviar uma única tabela ao plug-in SSE, e uma única tabela de dados é retornada. Se o plug-in não especificar os nomes dos campos que são retornados, os campos serão nomeados como Field1, Field2, e assim por diante.

Extension pluginname.functionname( tabledescription );



Manipulação de tipos de dados na definição de campo de tabela

Tipos de dados são detectados automaticamente em conexões analíticas. Se os dados não tiverem valores numéricos e pelo menos uma string de texto não NULL, o campo será considerado texto. Em qualquer outro caso, ele será considerado numérico.

Você pode forçar o tipo de dados envolvendo um nome de campo com String() ou Mixed().



String() ou Mixed() não podem ser usados fora de definições de campo de tabela extension, e você não pode usar outras funções Qlik Sense em uma definição de campo de tabela.

Mais sobre conexões analíticas

Você precisa configurar conexões analíticas antes de poder usá-las.

Qlik Sense Enterprise: [Criando uma conexão analítica](https://help.qlik.com/en-US/sense-admin/May2026/Subsystems/DeployAdministerQSE/Content/Sense_DeployAdminister/QSEoW/Administer_QSEoW/Managing_QSEoW/create-analytic-connection.htm) (somente em inglês)

Qlik Sense Desktop: [Configurando conexões analíticas no Qlik Sense Desktop](https://help.qlik.com/pt-BR/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Introduction/configure-analytic-connection-desktop.htm)

Você pode ler mais sobre conexões analíticas no repositório GitHub. [qlik-oss/server-side-extension](https://github.com/qlik-oss/server-side-extension) | | [](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm)[](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm)
where | where é uma cláusula utilizada para declarar se um registro deve ou não ser incluído na seleção. A seleção será incluída se criterion for True.

criterion é uma expressão lógica. | | [](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm)[](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm)
while | while é uma cláusula usada para declarar que um registro deve ser lido repetidamente. O mesmo registro será lido se criterion forTrue. Para que possa ser útil, a cláusula while normalmente deve incluir a função IterNo( ).

criterion é uma expressão lógica. | | [](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm)[](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm)
group by | group by é uma cláusula usada para definir os campos de agregação (agrupamento) dos dados. Os campos de agregação devem ser incluídos de alguma maneira nas expressões carregadas. Nenhum outro campo diferente desses poderá ser usado fora das funções de agregação nas expressões carregadas.

groupbyfieldlist ::= (fieldname { ,fieldname } ) | | [](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm)[](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm)
order by | order by é uma cláusula usada para classificar os registros de uma tabela residente antes de seu processamento pela declaração load. A tabela residente pode ser classificada por um ou mais campos, em ordem ascendente ou descendente. A classificação é feita, principalmente, pelo valor numérico e, em seguida, pela ordem nacional de colação. Essa cláusula somente poderá ser usada quando a fonte de dados for uma tabela residente.

Os campos de classificação especificam por qual campo a tabela residente é classificada. O campo pode ser especificado por seu nome ou número na tabela residente (o primeiro campo é o número 1).

orderbyfieldlist ::= fieldname [ sortorder ] { , fieldname [ sortorder ] }

sortorder é asc para ascendente ou desc para descendente. Se nenhuma sortorder for especificada, asc será assumido.

fieldname, path, filename e aliasname são strings de texto que indicam o que seus respectivos nomes implicitamente representam. Qualquer campo na tabela de origem pode ser usado como fieldname. No entanto, campos criados por meio da cláusula (aliasname) estão fora de escopo e não podem ser usados dentro de uma mesma declaração load. | Se nenhuma fonte de dados for fornecida por meio de uma cláusula from, inline, resident, from\_field, extension ou autogenerate, os dados serão carregados a partir do resultado imediatamente após a instrução SELECT ou LOAD. O comando sucessivo não deverá ter prefixo. [Carregando dados de uma tabela carregada anteriormente](https://help.qlik.com/pt-BR/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/load-data-from-previously-loaded-table.htm) [](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm) #### Carregando diferentes formatos de arquivo Carregue um arquivo de dados delimitados com opções padrão: `LOAD * from data1.csv; ` Carregar um arquivo de dados delimitados a partir de uma conexão da biblioteca (DataFiles): `LOAD * from 'lib://DataFiles/data1.csv'; ` Carregar todos os arquivos de dados delimitados a partir de uma conexão da biblioteca (DataFiles): `LOAD * from 'lib://DataFiles/*.csv'; ` Carregue um arquivo delimitado, especificando vírgula como separador e com rótulos embutidos: `LOAD * from 'c:\userfiles\data1.csv' (ansi, txt, delimiter is ',', embedded labels); ` Carregue um arquivo delimitado, especificando a guia como separador e com rótulos embutidos: `LOAD * from 'c:\userfiles\data2.txt' (ansi, txt, delimiter is '\t', embedded labels);` Carregue um arquivo dif com cabeçalhos integrados: `LOAD * from file2.dif (ansi, dif, embedded labels);` Carregue três campos de um arquivo de registro fixo sem cabeçalhos: `LOAD @1:2 as ID, @3:25 as Name, @57:80 as City from data4.fix (ansi, fix, no labels, header is 0, record is 80); ` Carregue um arquivo QVX, especificando um caminho absoluto: `LOAD * from C:\qdssamples\xyz.qvx (qvx);` [](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm) #### Carregando arquivo da Web Carregue a partir da URL padrão definida na conexão de dados do arquivo da Web: `LOAD * from [lib://MyWebFile]; ` Carregue a partir de uma URL específica e substitua a URL definida na conexão de dados do arquivo da Web: `LOAD * from [lib://MyWebFile] (URL is 'http://localhost:8000/foo.bar'); ` Carregue a partir de uma URL específica definida em uma variável usando a expansão de sinal de dólar: `SET dynamicURL = 'http://localhost/foo.bar';` `LOAD * from [lib://MyWebFile] (URL is '$(dynamicURL)');` [](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm) #### Selecionando campos específicos, renomeando e calculando campos Carregue somente três campos específicos de um arquivo delimitado: `LOAD FirstName, LastName, Number from data1.csv; ` Renomeie o primeiro campo como A e o segundo campo como B ao carregar um arquivo sem rótulos: `LOAD @1 as A, @2 as B from data3.txt (ansi, txt, delimiter is '\t', no labels); ` Carregue Name como uma concatenação de FirstName, um caractere de espaço e LastName: `LOAD FirstName&' '&LastName as Name from data1.csv; ` Carregue Quantity, Price e Value (o produto de Quantity e Price): `LOAD Quantity, Price, Quantity*Price as Value from data1.csv;` [](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm) #### Selecionando registros específicos Carregue somente registros exclusivos, e os registros duplicados serão descarregados: `LOAD distinct FirstName, LastName, Number from data1.csv; ` Carregue somente registros onde o campo Litres tiver um valor acima de zero: `LOAD * from Consumption.csv where Litres>0; ` [](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm) #### Carregando dados que não estão no arquivo e dados gerados automaticamente Carregue uma tabela com dados inline, dois campos nomeados CatID e Category: `LOAD * Inline ` `[CatID, Category ` `0,Regular ` `1,Occasional ` `2,Permanent]; ` Carregue uma tabela com dados inline, três campos nomeados UserID, Password e Access: `LOAD * Inline [UserID, Password, Access ` `A, ABC456, User ` `B, VIP789, Admin]; ` Carregue uma tabela com 10 mil linhas. O campo A irá conter o número do registro de leitura (1,2,3,4,5...) e o campo B irá conter um número aleatório entre 0 e 1: `LOAD RecNo( ) as A, rand( ) as B autogenerate(10000);` Nota informativaOs parênteses após autogenerate são permitidos, mas não obrigatórios. [](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm) #### Carregando dados de uma tabela carregada anteriormente Primeiro nós carregamos um arquivo de tabela delimitado e o nomeamos tab1: `tab1: ` `SELECT A,B,C,D from 'lib://DataFiles/data1.csv'; ` Carregue campos da tabela já carregada tab1 como tab2: `tab2:` `LOAD A,B,month(C),A*B+D as E resident tab1;` Carregue campos da tabela já carregada tab1, mas somente registros onde A seja maior que B: `tab3:` `LOAD A,A+B+C resident tab1 where A>B;` Carregue campos da tabela já carregada tab1 ordenada por A: `LOAD A,B*C as E resident tab1 order by A;` Carregue campos da tabela já carregada tab1, ordenada pelo primeiro campo e, em seguida, o segundo campo: `LOAD A,B*C as E resident tab1 order by 1,2;` Carregue campos da tabela já carregada tab1 ordenada por C decrescente e B em ordem crescente e, em seguida, o primeiro campo em ordem decrescente: `LOAD A,B*C as E resident tab1 order by C desc, B asc, 1 desc;` [](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm) #### Carregando dados de campos carregados anteriormente Carregue o campo Types da tabela carregada anteriormente Characters como A: `LOAD A from_field (Characters, Types);` [](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm) #### Carregando dados de uma tabela posterior (carga anterior) Carregue A, B e os campos calculados X e Y do Table1 que é carregado na instrução SELECT seguinte: `LOAD A, B, if(C>0,'positive','negative') as X, weekday(D) as Y; ` `SELECT A,B,C,D from Table1;` [](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm) #### Agrupamento de dados Campos de carga agrupados (agregados) por ArtNo: `LOAD ArtNo, round(Sum(TransAmount),0.05) as ArtNoTotal from table.csv group by ArtNo; ` Campos de carga agrupados (agregados) por Week e ArtNo: `LOAD Week, ArtNo, round(Avg(TransAmount),0.05) as WeekArtNoAverages from table.csv group by Week, ArtNo;` [](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm) #### Lendo um registro repetidamente Nesse exemplo temos um arquivo de entrada Grades.csv que contém as notas para cada aluno condensadas em um campo: `Student,Grades` `Mike,5234` `John,3345` `Pete,1234` `Paul,3352` As notas, em uma escala de 1-5, representam as matérias Math, English, Science e History. Podemos separar as notas em valores separados, lendo cada registro várias vezes com uma cláusula while, utilizando a função IterNo( ) como um contador. Em cada leitura, a nota é extraída com a função Mid e armazenada em Grade. A matéria é selecionada usando a função pick e armazenada em Subject. A cláusula final while contém o teste para verificar se todas as notas foram lidas (quatro por aluno, neste caso), o que significa que o registro do próximo aluno deve ser lido. `MyTab: ` `LOAD Student, ` `mid(Grades,IterNo( ),1) as Grade, ` `pick(IterNo( ), 'Math', 'English', 'Science', 'History') as Subject from Grades.csv` `while IsNum(mid(Grades,IterNo(),1));` O resultado é uma tabela que contém estes dados: ![Resulting table data](https://help.qlik.com/pt-BR/sense/May2026/Subsystems/Hub/Content/Resources/Images/ex_gen_LoadRepeated.png) [](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm) #### Carregando de conexões analíticas Os seguintes dados de amostra são usados. ``` Values: Load Rand() as A, Rand() as B, Rand() as C AutoGenerate(50); ``` Carregando dados usando uma função Nestes exemplos, partimos do princípio de que temos um plug-in de conexão analítica P que contém uma função Calculate(Parameter1, Parameter2). A função retorna a tabela Resultados, que contém os campos Field1 e Field2. ``` Load * Extension P.Calculate( Values{A, C} ); ``` Carregue todos os campos retornados ao enviar os campos A e C para a função. ``` Load Field1 Extension P.Calculate( Values{A, C} ); ``` Carregue apenas o campo Field1 ao enviar os campos A e C para a função. ``` Load * Extension P.Calculate( Values ); ``` Carregue todos os campos retornados ao enviar os campos A e B para a função. Como campos não estão especificados, A e B são usados, pois são os primeiros na ordem da tabela. ``` Load * Extension P.Calculate( Values {C, C}); ``` Carregue todos os campos que são retornados ao enviar o campo C a ambos os parâmetros da função. Load \* Extension P.Calculate( Values {String(A), Mixed(B)}); Carregue todos os campos que são retornados ao enviar o campo A forçado como uma string e B forçado como um número para a função. Carregando dados ao avaliar um script Load A as A\_echo, B as B\_echo Extension R.ScriptEval( 'q;', Values{A, B} ); Carregue a tabela retornada pelo script q ao enviar os valores de A e B. Load \* Extension R.ScriptEval( '$(My\_R\_Script)', Values{A, B} ); Carregue a tabela retornada pelo script armazenado na variável My\_R\_Script ao enviar os valores de A e B. Load \* Extension R.ScriptEval( '$(My\_R\_Script)', Values{B as D, \*} ); Carregue a tabela retornada pelo script armazenado na variável My\_R\_Script ao enviar os valores de B renomeados como D, A e C. Usar \* envia os campos restantes não referenciados. Nota informativaA extensão do arquivo de conexões DataFiles faz distinção entre maiúsculas e minúsculas. Por exemplo: .qvd.