Class FlightSqlClient

Flight SQL client for executing queries and managing data with Arrow Flight SQL servers.

Example

const client = new FlightSqlClient({
  host: "localhost",
  port: 50051,
  tls: false,
  auth: { type: "bearer", token: "my-token" }
})

await client.connect()

const result = await client.query("SELECT * FROM my_table")
for await (const batch of result.stream()) {
  console.log(batch.numRows)
}

await client.close()

Constructors

constructor

new FlightSqlClient(options: FlightSqlClientOptions): FlightSqlClient
Parameters
- options: FlightSqlClientOptions
Returns FlightSqlClient
- Defined in client.ts:99

Methods

close

close(): void
Close the connection and release resources.

Returns void
- Defined in client.ts:166

connect

connect(): Promise<void>
Establish connection to the Flight SQL server and perform authentication.

Returns Promise<void>
Throws
If connection cannot be established

Throws
If authentication fails
- Defined in client.ts:124

doAction

doAction(action: Action): AsyncGenerator<ActionResult, void, unknown>
Execute an action on the server.
Parameters
- action: Action
  Action to execute
Returns AsyncGenerator<ActionResult, void, unknown>
Async iterator of results
- Defined in client.ts:1049

doExchange

doExchange(descriptor: FlightDescriptor): ExchangeStream
Open a bidirectional data exchange with the server.

This is the low-level API for DoExchange. For real-time subscriptions, use the higher-level subscribe() method instead.
Parameters
- descriptor: FlightDescriptor
  Flight descriptor for the exchange
Returns ExchangeStream
An exchange handle for sending and receiving FlightData
Example
```
const exchange = client.doExchange({
  type: DescriptorType.CMD,
  cmd: new TextEncoder().encode('SUBSCRIBE:my_topic')
})

// Send initial request
await exchange.send({ appMetadata: subscribeCommand })

// Receive responses
for await (const data of exchange) {
  if (data.dataHeader) {
    // Process record batch
  }
}

// Clean up
await exchange.end()
```
- Defined in client.ts:936

doGet

doGet(
    ticket: Ticket,
): AsyncGenerator<
    {
        dataBody?: Uint8Array<ArrayBufferLike>;
        dataHeader?: Uint8Array<ArrayBufferLike>;
    },
    void,
    unknown,
>
Retrieve data for a ticket as an async iterator of FlightData.
Parameters
- ticket: Ticket
  Ticket from FlightInfo endpoint
Returns AsyncGenerator<
    {
        dataBody?: Uint8Array<ArrayBufferLike>;
        dataHeader?: Uint8Array<ArrayBufferLike>;
    },
    void,
    unknown,
>
Yields
FlightData chunks containing dataHeader and dataBody
- Defined in client.ts:829

doPut

doPut(
    descriptor: FlightDescriptor,
    dataStream: AsyncIterable<
        {
            appMetadata?: Uint8Array<ArrayBufferLike>;
            dataBody: Uint8Array;
            dataHeader: Uint8Array;
        },
    >,
): AsyncGenerator<
    { appMetadata?: Uint8Array<ArrayBufferLike> },
    void,
    unknown,
>
Upload Arrow data to the server.
Parameters
- descriptor: FlightDescriptor
  Flight descriptor describing the data
- dataStream: AsyncIterable<
      {
          appMetadata?: Uint8Array<ArrayBufferLike>;
          dataBody: Uint8Array;
          dataHeader: Uint8Array;
      },
  >
  Async iterable of FlightData messages
Returns AsyncGenerator<{ appMetadata?: Uint8Array<ArrayBufferLike> }, void, unknown>
Async iterator of PutResult messages
- Defined in client.ts:858

executeUpdate

executeUpdate(query: string, options?: ExecuteOptions): Promise<bigint>
Execute a SQL update statement (INSERT, UPDATE, DELETE).
Parameters
- query: string
  SQL statement
- Optionaloptions: ExecuteOptions
  Optional execution options
Returns Promise<bigint>
Number of rows affected
- Defined in client.ts:226

getCatalogs

getCatalogs(): Promise<CatalogInfo[]>
Get the list of catalogs available on the server.

Returns Promise<CatalogInfo[]>
Array of catalog information
Example
```
const catalogs = await client.getCatalogs()
for (const catalog of catalogs) {
  console.log(catalog.catalogName)
}
```
- Defined in client.ts:329

getCrossReference

getCrossReference(
    options: {
        fkCatalog?: string;
        fkDbSchema?: string;
        fkTable: string;
        pkCatalog?: string;
        pkDbSchema?: string;
        pkTable: string;
    },
): Promise<ForeignKeyInfo[]>
Get the foreign key relationships between two tables.

This returns foreign keys in the foreign key table that reference the primary key of the primary key table.
Parameters
- options: {
      fkCatalog?: string;
      fkDbSchema?: string;
      fkTable: string;
      pkCatalog?: string;
      pkDbSchema?: string;
      pkTable: string;
  }
  Options specifying the primary key and foreign key tables
Returns Promise<ForeignKeyInfo[]>
Array of foreign key information
Example
```
// Find foreign keys from "orders" table that reference "users" table
const refs = await client.getCrossReference({
  pkTable: "users",
  fkTable: "orders"
})
```
- Defined in client.ts:677

getExportedKeys

getExportedKeys(
    table: string,
    catalog?: string,
    schema?: string,
): Promise<ForeignKeyInfo[]>
Get the foreign keys that reference a table's primary key (exported keys).
Parameters
- table: string
  Table name
- Optionalcatalog: string
  Optional catalog name
- Optionalschema: string
  Optional schema name
Returns Promise<ForeignKeyInfo[]>
Array of foreign key information
Example
```
// Find all tables that reference the "users" table
const exportedKeys = await client.getExportedKeys("users")
```
- Defined in client.ts:520

getFlightInfo

getFlightInfo(descriptor: FlightDescriptor): Promise<FlightInfo>
Get flight information for a descriptor.
Parameters
- descriptor: FlightDescriptor
  Flight descriptor
Returns Promise<FlightInfo>
FlightInfo with schema and endpoints
- Defined in client.ts:779

getImportedKeys

getImportedKeys(
    table: string,
    catalog?: string,
    schema?: string,
): Promise<ForeignKeyInfo[]>
Get the foreign keys in a table (imported keys).
Parameters
- table: string
  Table name
- Optionalcatalog: string
  Optional catalog name
- Optionalschema: string
  Optional schema name
Returns Promise<ForeignKeyInfo[]>
Array of foreign key information
Example
```
// Find all foreign keys in the "orders" table
const importedKeys = await client.getImportedKeys("orders")
```
- Defined in client.ts:551

getPrimaryKeys

getPrimaryKeys(
    table: string,
    catalog?: string,
    schema?: string,
): Promise<PrimaryKeyInfo[]>
Get the primary keys for a table.
Parameters
- table: string
  Table name
- Optionalcatalog: string
  Optional catalog name
- Optionalschema: string
  Optional schema name
Returns Promise<PrimaryKeyInfo[]>
Array of primary key information
Example
```
const primaryKeys = await client.getPrimaryKeys("users")
for (const pk of primaryKeys) {
  console.log(`${pk.columnName} (sequence: ${pk.keySequence})`)
}
```
- Defined in client.ts:482

getSchema

getSchema(descriptor: FlightDescriptor): Promise<SchemaResult>
Get the schema for a flight descriptor without fetching data.
Parameters
- descriptor: FlightDescriptor
  Flight descriptor
Returns Promise<SchemaResult>
Schema result
- Defined in client.ts:804

getSchemas

getSchemas(
catalog?: string,
schemaFilterPattern?: string,
): Promise<SchemaInfo[]>
Get the list of schemas available in a catalog.
Parameters
- Optionalcatalog: string
  Optional catalog name to filter by
- OptionalschemaFilterPattern: string
  Optional SQL LIKE pattern to filter schema names
Returns Promise<SchemaInfo[]>
Array of schema information
Example
```
// Get all schemas
const schemas = await client.getSchemas()

// Get schemas in specific catalog
const schemas = await client.getSchemas("my_catalog")

// Get schemas matching pattern
const schemas = await client.getSchemas(undefined, "public%")
```
- Defined in client.ts:363

getSqlInfo

getSqlInfo(infoCodes?: number[]): Promise<SqlInfo[]>
Get SQL server information and capabilities.
Parameters
- OptionalinfoCodes: number[]
  Optional array of specific info codes to retrieve. If omitted, all available info is retrieved.
Returns Promise<SqlInfo[]>
Array of SQL info name-value pairs
Example
```
// Get all server information
const allInfo = await client.getSqlInfo()

// Get specific info (server name and version)
const info = await client.getSqlInfo([0, 1])
for (const item of info) {
  console.log(`${item.infoName}: ${item.value}`)
}
```
- Defined in client.ts:587

getTables

getTables(
    options?: {
        catalog?: string;
        includeSchema?: boolean;
        schemaPattern?: string;
        tablePattern?: string;
        tableTypes?: string[];
    },
): Promise<TableInfo[]>
Get the list of tables available.
Parameters
- Optionaloptions: {
      catalog?: string;
      includeSchema?: boolean;
      schemaPattern?: string;
      tablePattern?: string;
      tableTypes?: string[];
  }
  Filter options
Returns Promise<TableInfo[]>
Array of table information
Example
```
// Get all tables
const tables = await client.getTables()

// Get tables in specific catalog/schema
const tables = await client.getTables({
  catalog: "my_catalog",
  schemaPattern: "public"
})

// Get only views
const views = await client.getTables({ tableTypes: ["VIEW"] })
```
- Defined in client.ts:400

getTableTypes

getTableTypes(): Promise<TableType[]>
Get the list of table types supported by the server.

Returns Promise<TableType[]>
Array of table type names (e.g., "TABLE", "VIEW", "SYSTEM TABLE")
Example
```
const tableTypes = await client.getTableTypes()
console.log(tableTypes) // [{ tableType: "TABLE" }, { tableType: "VIEW" }, ...]
```
- Defined in client.ts:451

getXdbcTypeInfo

getXdbcTypeInfo(dataType?: number): Promise<XdbcTypeInfo[]>
Get XDBC type information supported by the server.
Parameters
- OptionaldataType: number
  Optional specific data type code to retrieve info for. If omitted, all types are retrieved.
Returns Promise<XdbcTypeInfo[]>
Array of XDBC type info objects
Example
```
// Get all supported types
const types = await client.getXdbcTypeInfo()
for (const t of types) {
  console.log(`${t.typeName}: SQL type ${t.dataType}`)
}
```
- Defined in client.ts:626

isConnected

isConnected(): boolean
Check if the client is connected.

Returns boolean
- Defined in client.ts:173

listActions

listActions(): Promise<ActionType[]>
List available action types.

Returns Promise<ActionType[]>
Array of available action types
- Defined in client.ts:1071

prepare

prepare(query: string, options?: ExecuteOptions): Promise<PreparedStatement>
Create a prepared statement for repeated execution.
Parameters
- query: string
  SQL query with optional parameter placeholders
- Optionaloptions: ExecuteOptions
  Optional prepared statement options
Returns Promise<PreparedStatement>
PreparedStatement that can be executed multiple times
Example
```
const stmt = await client.prepare("SELECT * FROM users WHERE id = ?")
const result = await stmt.executeQuery()
await stmt.close()
```
- Defined in client.ts:259

query

query(query: string, options?: ExecuteOptions): Promise<QueryResult>
Execute a SQL query and return a QueryResult for retrieving results.
Parameters
- query: string
  SQL query string
- Optionaloptions: ExecuteOptions
  Optional execution options
Returns Promise<QueryResult>
QueryResult with stream() and collect() methods
Example
```
const result = await client.query("SELECT * FROM users")

// Stream record batches
for await (const batch of result.stream()) {
  console.log(batch.numRows)
}

// Or collect all into a table
const table = await result.collect()
```
- Defined in client.ts:201

Subscribe to real-time data updates from a query.

Returns a Subscription that yields RecordBatches as they arrive from the server. Automatically handles heartbeats and can reconnect on connection loss.

Parameters

query: string
SQL query to subscribe to
options: SubscribeOptions = {}
Subscription options

Returns Subscription

Subscription handle for receiving batches and control

Example

const subscription = await client.subscribe(
  "SELECT * FROM events WHERE status = 'pending'",
  { mode: 'CHANGES_ONLY', heartbeatMs: 30000 }
)

for await (const batch of subscription) {
  console.log(`Received ${batch.numRows} rows`)
}

// Or with AbortController
const controller = new AbortController()
const subscription = await client.subscribe(query, {
  signal: controller.signal
})

// Later: cancel the subscription
controller.abort()

Class FlightSqlClient

Example

Index

Constructors

Methods

Constructors

constructor

Parameters

Returns FlightSqlClient

Methods

close

Returns void

connect

Returns Promise<void>

Throws

Throws

doAction

Parameters

Returns AsyncGenerator<ActionResult, void, unknown>

doExchange

Parameters

Returns ExchangeStream

Example

doGet

Parameters

Returns AsyncGenerator< { dataBody?: Uint8Array<ArrayBufferLike>; dataHeader?: Uint8Array<ArrayBufferLike>; }, void, unknown,>

Yields

doPut

Parameters

Returns AsyncGenerator<{ appMetadata?: Uint8Array<ArrayBufferLike> }, void, unknown>

executeUpdate

Parameters

Returns Promise<bigint>

getCatalogs

Returns Promise<CatalogInfo[]>

Example

getCrossReference

Parameters

Returns Promise<ForeignKeyInfo[]>

Example

getExportedKeys

Parameters

Returns Promise<ForeignKeyInfo[]>

Example

getFlightInfo

Parameters

Returns Promise<FlightInfo>

getImportedKeys

Parameters

Returns Promise<ForeignKeyInfo[]>

Example

getPrimaryKeys

Parameters

Returns Promise<PrimaryKeyInfo[]>

Example

getSchema

Parameters

Returns Promise<SchemaResult>

getSchemas

Parameters

Returns Promise<SchemaInfo[]>

Example

getSqlInfo

Parameters

Returns Promise<SqlInfo[]>

Example

getTables

Parameters

Returns Promise<TableInfo[]>

Example

getTableTypes

Returns Promise<TableType[]>

Example

getXdbcTypeInfo

Parameters

Returns Promise<XdbcTypeInfo[]>

Example

isConnected

Returns boolean

listActions

Returns AsyncGenerator<
{
dataBody?: Uint8Array<ArrayBufferLike>;
dataHeader?: Uint8Array<ArrayBufferLike>;
},
void,
unknown,
>