Pular para o conteúdo principal

Databricks SQL Driver para Node.js

O driverDatabricks SQL para Node.js é uma Node.js biblioteca que permite que o senhor use o código JavaScript para executar SQL comando em Databricks compute recurso.

Requisitos​

  • Uma máquina de desenvolvimento com Node.js, versão 14 ou superior. Para imprimir a versão instalada do site Node.js, execute o comando node -v. Para instalar e usar diferentes versões do Node.js, o senhor pode usar ferramentas como o Node Version Manager (nvm).

  • Node pacote Manager (npm). As versões posteriores do Node.js já incluem npm. Para verificar se o site npm está instalado, execute o comando npm -v. Para instalar o npm, se necessário, o senhor pode seguir instruções como as de download e instalação do npm.

  • O pacote @databricks/sql do npm. Para instalar o pacote @databricks/sql em seu projeto Node.js como uma dependência, use npm para executar o seguinte comando no mesmo diretório do projeto:

    Bash
    npm i @databricks/sql

  • Se quiser instalar e usar o TypeScript em seu projeto Node.js como devDependencies, use npm para executar o seguinte comando no mesmo diretório do projeto:

    Bash
    npm i -D typescript
    npm i -D @types/node

  • Um clustering existente ou SQL warehouse.

  • O valor do Server Hostname e do HTTP Path para o clustering existente ou SQL warehouse.

Autenticação​

O Databricks SQL Driver for Node.js é compatível com os seguintes tipos de autenticação do Databricks:

nota

A autenticação básica usando um nome de usuário e senha da Databricks chegou ao fim da vida útil em 10 de julho de 2024. Consulte End of life para Databricks-gerenciar senhas.

nota

Como prática recomendada de segurança, você não deve codificar valores de variáveis de conexão em seu código. Em vez disso, você deve recuperar esses valores de variáveis de conexão de um local seguro. Por exemplo, os trechos de código e exemplos neste artigo usam variável de ambiente.

Databricks autenticação de tokens de acesso pessoal​

Para usar o driver Databricks SQL para Node.js com autenticação, o senhor deve primeiro criar um token de acesso pessoal Databricks. Para obter detalhes sobre essa etapa, consulte Databricks personal access tokens for workspace users.

Para autenticar o Databricks SQL Driver for Node.js, use o seguinte trecho de código. Esse snippet pressupõe que o senhor tenha definido a seguinte variável de ambiente:

  • DATABRICKS_SERVER_HOSTNAMEdefinido como o valor do Server Hostname para seu clustering ou SQL warehouse.
  • DATABRICKS_HTTP_PATHDefina o valor do caminho HTTP para seu clustering ou SQL warehouse.
  • DATABRICKS_TOKEN, definido como os tokens de acesso pessoal Databricks.

Para definir variáveis de ambiente, consulte a documentação do sistema operacional.

JavaScript
const { DBSQLClient } = require('@databricks/sql');

const serverHostname = process.env.DATABRICKS_SERVER_HOSTNAME;
const httpPath = process.env.DATABRICKS_HTTP_PATH;
const token = process.env.DATABRICKS_TOKEN;

if (!token || !serverHostname || !httpPath) {
  throw new Error(
    'Cannot find Server Hostname, HTTP Path, or ' +
      'personal access token. ' +
      'Check the environment variables DATABRICKS_SERVER_HOSTNAME, ' +
      'DATABRICKS_HTTP_PATH, and DATABRICKS_TOKEN.',
  );
}

const client = new DBSQLClient();
const connectOptions = {
  token: token,
  host: serverHostname,
  path: httpPath,
};

client.connect(connectOptions);
// ...

Autenticação OAuth de usuário para máquina (U2M)​

Databricks SQL Driver para Node.js versões 1.3.0 e acima suportam autenticaçãoOAuth user-to-machine (U2M).

Para autenticar o Databricks SQL Driver for Node.js com a autenticação OAuth U2M, use o seguinte trecho de código. Esse snippet pressupõe que o senhor tenha definido a seguinte variável de ambiente:

  • DATABRICKS_SERVER_HOSTNAMEdefinido como o valor do Server Hostname para seu clustering ou SQL warehouse.
  • DATABRICKS_HTTP_PATHDefina o valor do caminho HTTP para seu clustering ou SQL warehouse.

Para definir variáveis de ambiente, consulte a documentação do sistema operacional.

JavaScript
const { DBSQLClient } = require('@databricks/sql');

const serverHostname = process.env.DATABRICKS_SERVER_HOSTNAME;
const httpPath = process.env.DATABRICKS_HTTP_PATH;

if (!serverHostname || !httpPath) {
  throw new Error(
    'Cannot find Server Hostname or HTTP Path. ' +
      'Check the environment variables DATABRICKS_SERVER_HOSTNAME ' +
      'and DATABRICKS_HTTP_PATH.',
  );
}

const client = new DBSQLClient();
const connectOptions = {
  authType: 'databricks-oauth',
  host: serverHostname,
  path: httpPath,
};

client.connect(connectOptions);
// ...

Autenticação OAuth máquina a máquina (M2M)​

Databricks SQL Driver para Node.js versões 1.5.0 e acima suportam autenticação máquina a máquina (M2M)OAuth.

Para usar o Databricks SQL Driver for Node.js com a autenticação OAuth M2M, o senhor deve fazer o seguinte:

  1. Crie uma Databricks entidade de serviço em seu Databricks workspace e crie um OAuth secret para essa entidade de serviço.

    Para criar a entidade de serviço e seu segredo OAuth, consulte Autorizar o acesso autônomo a Databricks recurso com uma entidade de serviço usando OAuth. Anote o valor do UUID da entidade de serviço ou do ID do aplicativo e o valor do segredo do OAuth da entidade de serviço.

  2. Conceda à entidade de serviço acesso ao seu clustering ou depósito. Consulte computar permissões ou gerenciar SQL warehouse a.

Para autenticar o Databricks SQL Driver for Node.js, use o seguinte trecho de código. Esse snippet pressupõe que o senhor tenha definido a seguinte variável de ambiente:

  • DATABRICKS_SERVER_HOSTNAMEdefinido como o valor do Server Hostname para seu clustering ou SQL warehouse.
  • DATABRICKS_HTTP_PATHDefina o valor do caminho HTTP para seu clustering ou SQL warehouse.
  • DATABRICKS_CLIENT_IDdefinido como o valor do UUID da entidade de serviço ou do ID do aplicativo .
  • DATABRICKS_CLIENT_SECRETdefinido como o valor Secret do segredo OAuth da entidade de serviço.

Para definir variáveis de ambiente, consulte a documentação do sistema operacional.

JavaScript
const { DBSQLClient } = require('@databricks/sql');

const serverHostname = process.env.DATABRICKS_SERVER_HOSTNAME;
const httpPath = process.env.DATABRICKS_HTTP_PATH;
const clientId = process.env.DATABRICKS_CLIENT_ID;
const clientSecret = process.env.DATABRICKS_CLIENT_SECRET;

if (!serverHostname || !httpPath || !clientId || !clientSecret) {
  throw new Error(
    'Cannot find Server Hostname, HTTP Path, or ' +
      'service principal ID or secret. ' +
      'Check the environment variables DATABRICKS_SERVER_HOSTNAME, ' +
      'DATABRICKS_HTTP_PATH, DATABRICKS_CLIENT_ID, and ' +
      'DATABRICKS_CLIENT_SECRET.',
  );
}

const client = new DBSQLClient();
const connectOptions = {
  authType: 'databricks-oauth',
  host: serverHostname,
  path: httpPath,
  oauthClientId: clientId,
  oauthClientSecret: clientSecret,
};

client.connect(connectOptions);
// ...

Dados de consulta​

O exemplo de código a seguir demonstra como chamar o driver Databricks SQL para Node.js para executar uma consulta básica SQL em um recurso Databricks compute . Esse comando retorna as duas primeiras linhas da tabela trips no esquema nyctaxi do catálogo samples.

nota

O exemplo de código a seguir demonstra como usar tokens de acesso pessoal Databricks para autenticação. Para usar outros tipos de autenticação disponíveis no Databricks, consulte Autenticação.

Este exemplo de código recupera os valores das variáveis de conexão token, server_hostname e http_path de um conjunto de Databricks variáveis de ambiente. Essas variáveis de ambiente têm os seguintes nomes: variável de ambiente:

  • DATABRICKS_TOKENque representa seus Databricks tokens de acesso pessoal dos requisitos.
  • DATABRICKS_SERVER_HOSTNAME, que representa o valor do nome do host do servidor a partir dos requisitos.
  • DATABRICKS_HTTP_PATH, que representa o valor do caminho HTTP dos requisitos.

Você pode usar outras abordagens para recuperar esses valores de variáveis de conexão. O uso da variável de ambiente é apenas uma abordagem entre muitas outras.

O exemplo de código a seguir demonstra como chamar o conector Databricks SQL para Node.js para executar um comando básico SQL em um clustering ou SQL warehouse. Esse comando retorna as duas primeiras linhas da tabela trips.

JavaScript
const { DBSQLClient } = require('@databricks/sql');

const token = process.env.DATABRICKS_TOKEN;
const serverHostname = process.env.DATABRICKS_SERVER_HOSTNAME;
const httpPath = process.env.DATABRICKS_HTTP_PATH;

if (!token || !serverHostname || !httpPath) {
  throw new Error(
    'Cannot find Server Hostname, HTTP Path, or personal access token. ' +
      'Check the environment variables DATABRICKS_TOKEN, ' +
      'DATABRICKS_SERVER_HOSTNAME, and DATABRICKS_HTTP_PATH.',
  );
}

const client = new DBSQLClient();
const connectOptions = {
  token: token,
  host: serverHostname,
  path: httpPath,
};

client
  .connect(connectOptions)
  .then(async (client) => {
    const session = await client.openSession();
    const queryOperation = await session.executeStatement('SELECT * FROM samples.nyctaxi.trips LIMIT 2', {
      runAsync: true,
      maxRows: 10000, // This option enables the direct results feature.
    });

    const result = await queryOperation.fetchAll();

    await queryOperation.close();

    console.table(result);

    await session.close();
    await client.close();
  })
  .catch((error) => {
    console.error(error);
  });

Saída:

┌─────────┬─────┬────────┬───────────┬───────┬─────────┬────────┬───────┬───────┬────────┬────────┬────────┐
│ (index) │ _c0 │ carat  │    cut    │ color │ clarity │ depth  │ table │ price │   x    │   y    │   z    │
├─────────┼─────┼────────┼───────────┼───────┼─────────┼────────┼───────┼───────┼────────┼────────┼────────┤
│    0    │ '1' │ '0.23' │  'Ideal'  │  'E'  │  'SI2'  │ '61.5' │ '55'  │ '326' │ '3.95' │ '3.98' │ '2.43' │
│    1    │ '2' │ '0.21' │ 'Premium' │  'E'  │  'SI1'  │ '59.8' │ '61'  │ '326' │ '3.89' │ '3.84' │ '2.31' │
└─────────┴─────┴────────┴───────────┴───────┴─────────┴────────┴───────┴───────┴────────┴────────┴────────┘

Sessões​

Todos os métodos IDBSQLSession que retornam objetos IOperation na Referência da API têm os seguintes parâmetros comuns que afetam seu comportamento:

  • Definir runAsync para true começar o modo assíncrono. IDBSQLSession colocam as operações na fila e retornam o mais rápido possível. O estado atual do objeto IOperation retornado pode variar, e o cliente é responsável por verificar seu status antes de usar o IOperation retornado. Ver operações. Definir runAsync como false significa que os métodos IDBSQLSession aguardam a conclusão das operações. A Databricks recomenda sempre definir runAsync como true.
  • Definir maxRows como um valor não nulo permite resultados diretos. Com resultados diretos, o servidor tenta aguardar a conclusão das operações e, em seguida, busca uma parte dos dados. Dependendo da quantidade de trabalho que o servidor conseguiu concluir dentro do tempo definido, os objetos IOperation retornam em algum estado intermediário em vez de em algum estado pendente. Muitas vezes, todos os metadados e resultados da consulta são retornados em uma única solicitação ao servidor. O servidor usa maxRows para determinar quantos registros ele pode retornar imediatamente. No entanto, o pedaço real pode ter um tamanho diferente; veja IDBSQLSession.fetchChunk. Os resultados diretos são possibilitados pelo site default. A Databricks não recomenda a desativação dos resultados diretos.

operações​

Conforme descrito em Sessões, os objetos IOperation que são retornados pelos métodos de sessão IDBSQLSession na Referência da API não são totalmente preenchidos. As operações de servidor relacionadas podem ainda estar em andamento, como aguardar o warehouse Databricks SQL começar, executar a consulta ou buscar os dados. A classe IOperation oculta esses detalhes dos usuários. Por exemplo, métodos como fetchAll, fetchChunk e getSchema aguardam internamente a conclusão das operações e, em seguida, retornam os resultados. O senhor pode usar o método IOperation.finished() para aguardar explicitamente a conclusão das operações. Esses métodos recebem um retorno de chamada que é chamado periodicamente enquanto se aguarda a conclusão das operações. Definir a opção progress como true tenta solicitar dados de progresso extras do servidor e passá-los para esse retorno de chamada.

Os métodos close e cancel podem ser chamados a qualquer momento. Quando chamadas, elas invalidam imediatamente o objeto IOperation; todas as chamadas pendentes, como fetchAll, fetchChunk e getSchema, são imediatamente canceladas e um erro é retornado. Em alguns casos, as operações do servidor podem já ter sido concluídas e o método cancel afeta apenas o cliente.

O método fetchAll chama fetchChunk internamente e coleta todos os dados em uma matriz. Embora isso seja conveniente, pode causar erros de falta de memória quando usado em grandes conjuntos de dados. As opções fetchAll normalmente são passadas para fetchChunk.

Busque pedaços de dados​

A busca de blocos de dados usa o seguinte padrão de código:

JavaScript
do {
  const chunk = await operation.fetchChunk();
  // Process the data chunk.
} while (await operation.hasMoreRows());

O método fetchChunk na Referência da API processa dados em pequenas porções para reduzir o consumo de memória. fetchChunk primeiro aguarda a conclusão das operações, caso ainda não tenham sido concluídas, depois chama um retorno de chamada durante o ciclo de espera e, em seguida, busca o próximo bloco de dados.

Você pode usar a opção maxRows para especificar o tamanho do bloco desejado. No entanto, o pedaço devolvido pode ter um tamanho diferente, menor ou até mesmo maior. fetchChunk não tenta pré-buscar dados internamente, a fim de dividi-los nas partes solicitadas. Ele envia a opção maxRows para o servidor e retorna tudo o que o servidor retorna. Não confunda essa opção maxRows com a de IDBSQLSession. maxRows passado para fetchChunk define o tamanho de cada pedaço e não faz mais nada.

Gerenciar arquivos em Unity Catalog volumes​

O Databricks SQL driver permite que o senhor grave arquivos locais em Unity Catalog volumes, download arquivos de volumes e exclua arquivos de volumes, conforme mostrado no exemplo a seguir:

JavaScript
const { DBSQLClient } = require('@databricks/sql');

const serverHostname = process.env.DATABRICKS_SERVER_HOSTNAME;
const httpPath = process.env.DATABRICKS_HTTP_PATH;
const token = process.env.DATABRICKS_TOKEN;

if (!token || !serverHostname || !httpPath) {
  throw new Error(
    'Cannot find Server Hostname, HTTP Path, or ' +
      'personal access token. ' +
      'Check the environment variables DATABRICKS_SERVER_HOSTNAME, ' +
      'DATABRICKS_HTTP_PATH, and DATABRICKS_TOKEN.',
  );
}

const client = new DBSQLClient();
const connectOptions = {
  token: token,
  host: serverHostname,
  path: httpPath,
};

client
  .connect(connectOptions)
  .then(async (client) => {
    const session = await client.openSession();

    // Write a local file to a volume in the specified path.
    // For writing local files to volumes, you must first specify the path to the
    // local folder that contains the file to be written.
    // Specify OVERWRITE to overwrite any existing file in that path.
    await session.executeStatement("PUT 'my-data.csv' INTO '/Volumes/main/default/my-volume/my-data.csv' OVERWRITE", {
      stagingAllowedLocalPath: ['/tmp/'],
    });

    // Download a file from a volume in the specified path.
    // For downloading files in volumes, you must first specify the path to the
    // local folder that will contain the downloaded file.
    await session.executeStatement("GET '/Volumes/main/default/my-volume/my-data.csv' TO 'my-downloaded-data.csv'", {
      stagingAllowedLocalPath: ['/Users/paul.cornell/samples/nodejs-sql-driver/'],
    });

    // Delete a file in a volume from the specified path.
    // For deleting files from volumes, you must add stagingAllowedLocalPath,
    // but its value will be ignored. As such, in this example, an empty string is
    // specified.
    await session.executeStatement("REMOVE '/Volumes/main/default/my-volume/my-data.csv'", {
      stagingAllowedLocalPath: [''],
    });

    await session.close();
    await client.close();
  })
  .catch((error) => {
    console.error(error);
  });

Configurar o registro​

O registrador fornece informações para problemas de depuração com o conector. Todos os objetos DBSQLClient são instanciados com um logger que imprime no console, mas ao passar um logger personalizado, o senhor pode enviar essas informações para um arquivo. O exemplo a seguir mostra como configurar um registrador e alterar seu nível.

JavaScript
const { DBSQLLogger, LogLevel } = require('@databricks/sql');
const logger = new DBSQLLogger({
  filepath: 'log.txt',
  level: LogLevel.info,
});

// Set logger to different level.
logger.setLevel(LogLevel.debug);

Para obter exemplos adicionais, consulte a pasta de exemplos no repositório databricks/databricks-sql-nodejs no GitHub.

Testando​

Para testar seu código, você pode usar estruturas de teste de JavaScript, como o Jest. Para testar seu código em condições simuladas sem chamar o endpoint Databricks REST API ou alterar o estado da sua conta ou espaço de trabalho Databricks, o senhor pode usar os frameworks de simulação integrados do Jest.

Por exemplo, dado o seguinte arquivo denominado helpers.js contendo uma função getDBSQLClientWithPAT que usa um Databricks tokens de acesso pessoal para retornar uma conexão a um Databricks workspace, uma função getAllColumnsFromTable que usa a conexão para obter o número especificado de linhas de dados da tabela especificada (por exemplo, a tabela trips no esquema nyctaxi do catálogo samples) e uma função printResults para imprimir o conteúdo das linhas de dados:

JavaScript
// helpers.js

const { DBSQLClient } = require('@databricks/sql');

async function getDBSQLClientWithPAT(token, serverHostname, httpPath) {
  const client = new DBSQLClient();
  const connectOptions = {
    token: token,
    host: serverHostname,
    path: httpPath,
  };
  try {
    return await client.connect(connectOptions);
  } catch (error) {
    console.error(error);
    throw error;
  }
}

async function getAllColumnsFromTable(client, tableSpec, rowCount) {
  let session;
  let queryOperation;
  try {
    session = await client.openSession();
    queryOperation = await session.executeStatement(`SELECT * FROM ${tableSpec} LIMIT ${rowCount}`, {
      runAsync: true,
      maxRows: 10000, // This option enables the direct results feature.
    });
  } catch (error) {
    console.error(error);
    throw error;
  }
  let result;
  try {
    result = await queryOperation.fetchAll();
  } catch (error) {
    console.error(error);
    throw error;
  } finally {
    if (queryOperation) {
      await queryOperation.close();
    }
    if (session) {
      await session.close();
    }
  }
  return result;
}

function printResult(result) {
  console.table(result);
}

module.exports = {
  getDBSQLClientWithPAT,
  getAllColumnsFromTable,
  printResult,
};

E dado o seguinte arquivo chamado main.js que chama as funções getDBSQLClientWithPAT, getAllColumnsFromTable e printResults:

JavaScript
// main.js

const { getDBSQLClientWithPAT, getAllColumnsFromTable, printResult } = require('./helpers');

const token = process.env.DATABRICKS_TOKEN;
const serverHostname = process.env.DATABRICKS_SERVER_HOSTNAME;
const httpPath = process.env.DATABRICKS_HTTP_PATH;
const tableSpec = process.env.DATABRICKS_TABLE_SPEC;

if (!token || !serverHostname || !httpPath) {
  throw new Error(
    'Cannot find Server Hostname, HTTP Path, or personal access token. ' +
      'Check the environment variables DATABRICKS_TOKEN, ' +
      'DATABRICKS_SERVER_HOSTNAME, and DATABRICKS_HTTP_PATH.',
  );
}

if (!tableSpec) {
  throw new Error(
    'Cannot find table spec in the format catalog.schema.table. ' +
      'Check the environment variable DATABRICKS_TABLE_SPEC.',
  );
}

getDBSQLClientWithPAT(token, serverHostname, httpPath)
  .then(async (client) => {
    const result = await getAllColumnsFromTable(client, tableSpec, 2);
    printResult(result);
    await client.close();
  })
  .catch((error) => {
    console.error(error);
  });

O arquivo a seguir chamado helpers.test.js testa se a função getAllColumnsFromTable retorna a resposta esperada. Em vez de criar uma conexão real com o destino workspace, esse teste simula um objeto DBSQLClient. O teste também simula alguns dados que estão em conformidade com o esquema e os valores que estão nos dados reais. O teste retorna os dados simulados por meio da conexão simulada e, em seguida, verifica se um dos valores das linhas de dados simuladas corresponde ao valor esperado.

JavaScript
// helpers.test.js

const { getDBSQLClientWithPAT, getAllColumnsFromTable, printResult } = require('./helpers');

jest.mock('@databricks/sql', () => {
  return {
    DBSQLClient: jest.fn(() => {
      return {
        connect: jest.fn().mockResolvedValue({ mock: 'DBSQLClient' }),
      };
    }),
  };
});

test('getDBSQLClientWithPAT returns mocked Promise<DBSQLClient> object', async () => {
  const result = await getDBSQLClientWithPAT(
    (token = 'my-token'),
    (serverHostname = 'mock-server-hostname'),
    (httpPath = 'mock-http-path'),
  );

  expect(result).toEqual({ mock: 'DBSQLClient' });
});

const data = [
  {
    tpep_pickup_datetime: new Date(2016, 1, 13, 15, 51, 12),
    tpep_dropoff_datetime: new Date(2016, 1, 13, 16, 15, 3),
    trip_distance: 4.94,
    fare_amount: 19.0,
    pickup_zip: 10282,
    dropoff_zip: 10171,
  },
  {
    tpep_pickup_datetime: new Date(2016, 1, 3, 17, 43, 18),
    tpep_dropoff_datetime: new Date(2016, 1, 3, 17, 45),
    trip_distance: 0.28,
    fare_amount: 3.5,
    pickup_zip: 10110,
    dropoff_zip: 10110,
  },
];

const mockDBSQLClientForSession = {
  openSession: jest.fn().mockResolvedValue({
    executeStatement: jest.fn().mockResolvedValue({
      fetchAll: jest.fn().mockResolvedValue(data),
      close: jest.fn().mockResolvedValue(null),
    }),
    close: jest.fn().mockResolvedValue(null),
  }),
};

test('getAllColumnsFromTable returns the correct fare_amount for the second mocked data row', async () => {
  const result = await getAllColumnsFromTable(
    (client = mockDBSQLClientForSession),
    (tableSpec = 'mock-table-spec'),
    (rowCount = 2),
  );
  expect(result[1].fare_amount).toEqual(3.5);
});

global.console.table = jest.fn();

test('printResult mock prints the correct fare_amount for the second mocked data row', () => {
  printResult(data);
  expect(console.table).toHaveBeenCalledWith(data);
  expect(data[1].fare_amount).toBe(3.5);
});

Para o TypeScript, o código anterior é semelhante. Para testar o Jest com o TypeScript, use ts-jest.

Recurso adicional​

Referência da API​

Aulas​

ClasseDBSQLClient​

Principal ponto de entrada para interagir com um banco de dados.

Métodos​
Métodoconnect​

Abre uma conexão com o banco de dados.

Parâmetros

opções Tipo: ConnectionOptions O conjunto de opções usado para se conectar ao banco de dados. Os campos host, path e outros campos obrigatórios devem ser preenchidos. Consulte Autenticação. Exemplo: const client: DBSQLClient = new DBSQLClient(); client.connect( { host: serverHostname, path: httpPath, // ... } )

Devoluções: Promise<IDBSQLClient>

MétodoopenSession​

Abre a sessão entre o DbSqlClient e o banco de dados.

Parâmetros

solicitação Tipo: OpenSessionRequest Um conjunto de parâmetros opcionais para especificar o esquema inicial e o catálogo inicial Exemplo: const session = await client.openSession( {initialCatalog: 'catalog'} );

Devoluções: Promise<IDBSQLSession>

MétodogetClient​

Retorna o objeto Thrift TCLiservice.client interno. Deve ser chamado após a conexão do DbSqlClient.

Sem parâmetros

Devolve TCLIService.Client

Métodoclose​

Fecha a conexão com o banco de dados e libera todos os recursos associados no servidor. Qualquer chamada adicional para esse cliente gerará um erro.

Sem parâmetros.

Sem valor de retorno.

ClasseDBSQLSession​

As DBSQLSessions são usadas principalmente para a execução de instruções no banco de dados, bem como para várias operações de busca de metadados.

Métodos​
MétodoexecuteStatement​

Executa uma instrução com as opções fornecidas.

Parâmetros

extrato Tipo: str A instrução a ser executada.

opções Tipo: ExecuteStatementOptions Um conjunto de parâmetros opcionais para determinar o tempo limite da consulta, o número máximo de linhas para resultados diretos e se a consulta deve ser executada de forma assíncrona. Em default maxRows é definido como 10000. Se maxRows for definido como nulo, as operações serão executadas com o recurso de resultados diretos desativado. Exemplo: const session = await client.openSession( {initialCatalog: 'catalog'} ); queryOperation = await session.executeStatement( 'SELECT "Hello, World!"', { runAsync: true } );

Devoluções: Promise<IOperation>

Métodoclose​

Encerra a sessão. Deve ser feito após o uso da sessão.

Sem parâmetros.

Sem valor de retorno.

MétodogetId​

Retorna o GUID da sessão.

Sem parâmetros.

Devoluções: str

MétodogetTypeInfo​

Retorna informações sobre os tipos de dados suportados.

Parâmetros

solicitação Tipo: TypeInfoRequest Parâmetros de solicitação.

Devoluções: Promise<IOperation>

MétodogetCatalogs​

Obtém uma lista de catálogos.

Parâmetros

solicitação Tipo: CatalogsRequest Parâmetros de solicitação.

Devoluções: Promise<IOperation>

MétodogetSchemas​

Obtém a lista de esquemas.

Parâmetros

solicitação Tipo: SchemasRequest Parâmetros de solicitação. Os campos catalogName e schemaName podem ser usados para fins de filtragem.

Devoluções: Promise<IOperation>

MétodogetTables​

Obtém a lista de tabelas.

Parâmetros

solicitação Tipo: TablesRequest Parâmetros de solicitação. Campos catalogName e schemaName e tableName pode ser usado para filtrar.

Devoluções: Promise<IOperation>

MétodogetFunctions​

Obtém a lista de tabelas.

Parâmetros

solicitação Tipo: FunctionsRequest Parâmetros de solicitação. O campo functionName é obrigatório.

Devoluções: Promise<IOperation>

MétodogetPrimaryKeys​

Obtém a lista da chave primária.

Parâmetros

solicitação Tipo: PrimaryKeysRequest Parâmetros de solicitação. Os campos schemaName e tableName são obrigatórios.

Devoluções: Promise<IOperation>

MétodogetCrossReference​

Obtém informações sobre a chave estrangeira entre duas tabelas.

Parâmetros

solicitação Tipo: CrossReferenceRequest Parâmetros de solicitação. O nome do esquema, do pai e do catálogo devem ser especificados para ambas as tabelas.

Devoluções: Promise<IOperation>

ClasseDBSQLOperation​

DBSQLOperations são criadas por DBSQLSessions e podem ser usadas para buscar os resultados das instruções e verificar sua execução. Os dados são obtidos por meio das funções fetchChunk e fetchAll.

Métodos​
MétodogetId​

Retorna o GUID das operações.

Sem parâmetros.

Devoluções: str

MétodofetchAll​

Aguarda a conclusão das operações e, em seguida, busca todas as linhas das operações.

Parâmetros: Nenhum

Devoluções: Promise<Array<object>>

MétodofetchChunk​

Aguarda a conclusão das operações e, em seguida, busca até um número especificado de linhas de uma operação.

Parâmetros

opções Tipo: FetchOptions Opções usadas para buscar. Atualmente, a única opção é maxRows, que corresponde ao número máximo de objetos de dados a serem retornados em qualquer matriz.

Devoluções: Promise<Array<object>>

Métodoclose​

Fecha as operações e libera todos os recursos associados. Deve ser feito depois que o senhor não estiver mais usando as operações.

Sem parâmetros.

Sem valor de retorno.

Última atualização em