@hpcc-js/comms 3.22.1 → 3.23.0

package/src/services/wsdl/WsSQL2/current/WsSQL2.ts

@@ -0,0 +1,222 @@
+import { IConnection, IOptions } from "../../../../connection.ts";
+import { Service } from "../../../../espConnection.ts";
+
+export namespace WsSQL2 {
+
+    export type double = number;
+    export type unsignedInt = number;
+    export type long = number;
+    export type uint64 = number;
+
+    export interface CloseResultSetRequest {
+        CursorId?: string;
+    }
+
+    export interface Exception {
+        Code?: string;
+        Audience?: string;
+        Source?: string;
+        Message?: string;
+    }
+
+    export interface Exceptions {
+        Source?: string;
+        Exception?: Exception[];
+    }
+
+    export interface CloseResultSetResponse {
+        Exceptions?: Exceptions;
+        Closed?: boolean;
+    }
+
+    export interface ExecuteQueryRequest {
+        SqlText?: string;
+        IncludeRuntimeGraph?: boolean;
+        IncludeResultSetMetadata?: boolean;
+        IncludeDebug?: boolean;
+    }
+
+    export interface Column {
+        ColumnLabel?: string;
+        ColumnTypeName?: string;
+        Precision?: unsignedInt;
+        Scale?: unsignedInt;
+    }
+
+    export interface ResultSetMetadata {
+        Column?: Column[];
+    }
+
+    export interface ExecuteQueryResponse {
+        Exceptions?: Exceptions;
+        CursorId?: string;
+        InitMs?: double;
+        PrepareMs?: double;
+        ResultSetMetadata?: ResultSetMetadata;
+    }
+
+    export interface ExplainQueryRequest {
+        SqlText?: string;
+    }
+
+    export interface ExplainQueryResponse {
+        Exceptions?: Exceptions;
+        Plan?: string;
+        PlanJson?: string;
+        ResultSetMetadata?: ResultSetMetadata;
+    }
+
+    export interface FetchResultSetRequest {
+        CursorId?: string;
+        FetchSize?: unsignedInt;
+    }
+
+    export interface Start {
+        DuckDBUsedBytes?: long;
+        DuckDBTempBytes?: long;
+        HeapInUseBytes?: long;
+        ResidentBytes?: long;
+        PeakResidentBytes?: long;
+    }
+
+    export interface Current {
+        DuckDBUsedBytes?: long;
+        DuckDBTempBytes?: long;
+        HeapInUseBytes?: long;
+        ResidentBytes?: long;
+        PeakResidentBytes?: long;
+    }
+
+    export interface Released {
+        DuckDBUsedBytes?: long;
+        DuckDBTempBytes?: long;
+        HeapInUseBytes?: long;
+        ResidentBytes?: long;
+        PeakResidentBytes?: long;
+    }
+
+    export interface Retained {
+        DuckDBUsedBytes?: long;
+        DuckDBTempBytes?: long;
+        HeapInUseBytes?: long;
+        ResidentBytes?: long;
+        PeakResidentBytes?: long;
+    }
+
+    export interface ScanObjectsCreated {
+        BindData?: long;
+        GlobalStates?: long;
+        LocalStates?: long;
+    }
+
+    export interface ScanObjectsLive {
+        BindData?: long;
+        GlobalStates?: long;
+        LocalStates?: long;
+    }
+
+    export interface DebugInfo {
+        Start?: Start;
+        Current?: Current;
+        Released?: Released;
+        Retained?: Retained;
+        ScanObjectsCreated?: ScanObjectsCreated;
+        ScanObjectsLive?: ScanObjectsLive;
+        LeakCheck?: string;
+        LeakCheckDetail?: string;
+    }
+
+    export interface FetchResultSetResponse {
+        Exceptions?: Exceptions;
+        Rows?: string;
+        Complete?: boolean;
+        ExecuteMs?: double;
+        RuntimeGraph?: string;
+        RuntimeGraphJson?: string;
+        DebugInfo?: DebugInfo;
+    }
+
+    export interface LogicalFileMetaRequest {
+        LogicalName?: string;
+    }
+
+    export interface LogicalFileMeta {
+        Version?: unsignedInt;
+        LogicalName?: string;
+        Kind?: string;
+        Format?: string;
+        Grouped?: boolean;
+        FormatCrc?: unsignedInt;
+        RecordTranslationMode?: unsignedInt;
+        Modified?: long;
+        RecordCount?: uint64;
+        FormatOptions?: string;
+        ProviderOptions?: string;
+        EclRecord?: string;
+        FileParts?: string;
+        SampleSQL?: string;
+    }
+
+    export interface LogicalFileMetaResponse {
+        Exceptions?: Exceptions;
+        LogicalFileMeta?: LogicalFileMeta;
+    }
+
+    export interface WsSQL2PingRequest {
+
+    }
+
+    export interface WsSQL2PingResponse {
+
+    }
+
+    export interface SplitQueryRequest {
+        SqlText?: string;
+    }
+
+    export interface Statements {
+        Statement?: string[];
+    }
+
+    export interface SplitQueryResponse {
+        Exceptions?: Exceptions;
+        Statements?: Statements;
+    }
+
+}
+
+export class SQL2ServiceBase extends Service {
+
+    constructor(optsConnection: IOptions | IConnection) {
+        super(optsConnection, "WsSQL2", "1.00");
+    }
+
+    CloseResultSet(request: WsSQL2.CloseResultSetRequest, abortSignal?: AbortSignal): Promise<WsSQL2.CloseResultSetResponse> {
+        return this._connection.send("CloseResultSet", request, "json", false, abortSignal, "CloseResultSetResponse");
+    }
+
+    ExecuteQuery(request: WsSQL2.ExecuteQueryRequest, abortSignal?: AbortSignal): Promise<WsSQL2.ExecuteQueryResponse> {
+        return this._connection.send("ExecuteQuery", request, "json", false, abortSignal, "ExecuteQueryResponse");
+    }
+
+    ExplainQuery(request: WsSQL2.ExplainQueryRequest, abortSignal?: AbortSignal): Promise<WsSQL2.ExplainQueryResponse> {
+        return this._connection.send("ExplainQuery", request, "json", false, abortSignal, "ExplainQueryResponse");
+    }
+
+    FetchResultSet(request: WsSQL2.FetchResultSetRequest, abortSignal?: AbortSignal): Promise<WsSQL2.FetchResultSetResponse> {
+        return this._connection.send("FetchResultSet", request, "json", false, abortSignal, "FetchResultSetResponse");
+    }
+
+    LogicalFileMeta(request: WsSQL2.LogicalFileMetaRequest, abortSignal?: AbortSignal): Promise<WsSQL2.LogicalFileMetaResponse> {
+        return this._connection.send("LogicalFileMeta", request, "json", false, abortSignal, "LogicalFileMetaResponse");
+    }
+
+    Ping(request: WsSQL2.WsSQL2PingRequest, abortSignal?: AbortSignal): Promise<WsSQL2.WsSQL2PingResponse> {
+        return this._connection.send("Ping", request, "json", false, abortSignal, "WsSQL2PingResponse");
+    }
+
+    SplitQuery(request: WsSQL2.SplitQueryRequest, abortSignal?: AbortSignal): Promise<WsSQL2.SplitQueryResponse> {
+        return this._connection.send("SplitQuery", request, "json", false, abortSignal, "SplitQueryResponse");
+    }
+
+}

package/src/services/wsdl/WsSQL2/v1.00/WsSQL2.ts

@@ -0,0 +1,222 @@
+import { IConnection, IOptions } from "../../../../connection.ts";
+import { Service } from "../../../../espConnection.ts";
+
+export namespace WsSQL2 {
+
+    export type double = number;
+    export type unsignedInt = number;
+    export type long = number;
+    export type uint64 = number;
+
+    export interface CloseResultSetRequest {
+        CursorId?: string;
+    }
+
+    export interface Exception {
+        Code?: string;
+        Audience?: string;
+        Source?: string;
+        Message?: string;
+    }
+
+    export interface Exceptions {
+        Source?: string;
+        Exception?: Exception[];
+    }
+
+    export interface CloseResultSetResponse {
+        Exceptions?: Exceptions;
+        Closed?: boolean;
+    }
+
+    export interface ExecuteQueryRequest {
+        SqlText?: string;
+        IncludeRuntimeGraph?: boolean;
+        IncludeResultSetMetadata?: boolean;
+        IncludeDebug?: boolean;
+    }
+
+    export interface Column {
+        ColumnLabel?: string;
+        ColumnTypeName?: string;
+        Precision?: unsignedInt;
+        Scale?: unsignedInt;
+    }
+
+    export interface ResultSetMetadata {
+        Column?: Column[];
+    }
+
+    export interface ExecuteQueryResponse {
+        Exceptions?: Exceptions;
+        CursorId?: string;
+        InitMs?: double;
+        PrepareMs?: double;
+        ResultSetMetadata?: ResultSetMetadata;
+    }
+
+    export interface ExplainQueryRequest {
+        SqlText?: string;
+    }
+
+    export interface ExplainQueryResponse {
+        Exceptions?: Exceptions;
+        Plan?: string;
+        PlanJson?: string;
+        ResultSetMetadata?: ResultSetMetadata;
+    }
+
+    export interface FetchResultSetRequest {
+        CursorId?: string;
+        FetchSize?: unsignedInt;
+    }
+
+    export interface Start {
+        DuckDBUsedBytes?: long;
+        DuckDBTempBytes?: long;
+        HeapInUseBytes?: long;
+        ResidentBytes?: long;
+        PeakResidentBytes?: long;
+    }
+
+    export interface Current {
+        DuckDBUsedBytes?: long;
+        DuckDBTempBytes?: long;
+        HeapInUseBytes?: long;
+        ResidentBytes?: long;
+        PeakResidentBytes?: long;
+    }
+
+    export interface Released {
+        DuckDBUsedBytes?: long;
+        DuckDBTempBytes?: long;
+        HeapInUseBytes?: long;
+        ResidentBytes?: long;
+        PeakResidentBytes?: long;
+    }
+
+    export interface Retained {
+        DuckDBUsedBytes?: long;
+        DuckDBTempBytes?: long;
+        HeapInUseBytes?: long;
+        ResidentBytes?: long;
+        PeakResidentBytes?: long;
+    }
+
+    export interface ScanObjectsCreated {
+        BindData?: long;
+        GlobalStates?: long;
+        LocalStates?: long;
+    }
+
+    export interface ScanObjectsLive {
+        BindData?: long;
+        GlobalStates?: long;
+        LocalStates?: long;
+    }
+
+    export interface DebugInfo {
+        Start?: Start;
+        Current?: Current;
+        Released?: Released;
+        Retained?: Retained;
+        ScanObjectsCreated?: ScanObjectsCreated;
+        ScanObjectsLive?: ScanObjectsLive;
+        LeakCheck?: string;
+        LeakCheckDetail?: string;
+    }
+
+    export interface FetchResultSetResponse {
+        Exceptions?: Exceptions;
+        Rows?: string;
+        Complete?: boolean;
+        ExecuteMs?: double;
+        RuntimeGraph?: string;
+        RuntimeGraphJson?: string;
+        DebugInfo?: DebugInfo;
+    }
+
+    export interface LogicalFileMetaRequest {
+        LogicalName?: string;
+    }
+
+    export interface LogicalFileMeta {
+        Version?: unsignedInt;
+        LogicalName?: string;
+        Kind?: string;
+        Format?: string;
+        Grouped?: boolean;
+        FormatCrc?: unsignedInt;
+        RecordTranslationMode?: unsignedInt;
+        Modified?: long;
+        RecordCount?: uint64;
+        FormatOptions?: string;
+        ProviderOptions?: string;
+        EclRecord?: string;
+        FileParts?: string;
+        SampleSQL?: string;
+    }
+
+    export interface LogicalFileMetaResponse {
+        Exceptions?: Exceptions;
+        LogicalFileMeta?: LogicalFileMeta;
+    }
+
+    export interface WsSQL2PingRequest {
+
+    }
+
+    export interface WsSQL2PingResponse {
+
+    }
+
+    export interface SplitQueryRequest {
+        SqlText?: string;
+    }
+
+    export interface Statements {
+        Statement?: string[];
+    }
+
+    export interface SplitQueryResponse {
+        Exceptions?: Exceptions;
+        Statements?: Statements;
+    }
+
+}
+
+export class SQL2ServiceBase extends Service {
+
+    constructor(optsConnection: IOptions | IConnection) {
+        super(optsConnection, "WsSQL2", "1.00");
+    }
+
+    CloseResultSet(request: WsSQL2.CloseResultSetRequest, abortSignal?: AbortSignal): Promise<WsSQL2.CloseResultSetResponse> {
+        return this._connection.send("CloseResultSet", request, "json", false, abortSignal, "CloseResultSetResponse");
+    }
+
+    ExecuteQuery(request: WsSQL2.ExecuteQueryRequest, abortSignal?: AbortSignal): Promise<WsSQL2.ExecuteQueryResponse> {
+        return this._connection.send("ExecuteQuery", request, "json", false, abortSignal, "ExecuteQueryResponse");
+    }
+
+    ExplainQuery(request: WsSQL2.ExplainQueryRequest, abortSignal?: AbortSignal): Promise<WsSQL2.ExplainQueryResponse> {
+        return this._connection.send("ExplainQuery", request, "json", false, abortSignal, "ExplainQueryResponse");
+    }
+
+    FetchResultSet(request: WsSQL2.FetchResultSetRequest, abortSignal?: AbortSignal): Promise<WsSQL2.FetchResultSetResponse> {
+        return this._connection.send("FetchResultSet", request, "json", false, abortSignal, "FetchResultSetResponse");
+    }
+
+    LogicalFileMeta(request: WsSQL2.LogicalFileMetaRequest, abortSignal?: AbortSignal): Promise<WsSQL2.LogicalFileMetaResponse> {
+        return this._connection.send("LogicalFileMeta", request, "json", false, abortSignal, "LogicalFileMetaResponse");
+    }
+
+    Ping(request: WsSQL2.WsSQL2PingRequest, abortSignal?: AbortSignal): Promise<WsSQL2.WsSQL2PingResponse> {
+        return this._connection.send("Ping", request, "json", false, abortSignal, "WsSQL2PingResponse");
+    }
+
+    SplitQuery(request: WsSQL2.SplitQueryRequest, abortSignal?: AbortSignal): Promise<WsSQL2.SplitQueryResponse> {
+        return this._connection.send("SplitQuery", request, "json", false, abortSignal, "SplitQueryResponse");
+    }
+
+}

package/types/ecl/dfuWorkunit.d.ts

@@ -76,6 +76,9 @@ export declare class DFUWorkunit extends StateObject<UDFUWorkunitState, IDFUWork
     get FileAccessCost(): number;
     get KbPerSecAve(): number;
     get KbPerSec(): number;
+    get SubTaskCount(): number;
+    get SubTasksFinished(): number;
+    get SubTasksFailed(): number;
     static create(optsConnection: IOptions | IConnection, dfuServerQueue: string): Promise<DFUWorkunit>;
     static attach(optsConnection: IOptions | IConnection, wuid: string, state?: IDFUWorkunitState): DFUWorkunit;
     static sprayFixed(server: IOptions | IConnection, request: Partial<FileSpray.SprayFixed>): Promise<DFUWorkunit>;

package/types/ecl/sql2.d.ts

@@ -0,0 +1,74 @@
+import { IConnection, IOptions } from "../connection.ts";
+import { SQL2Service, WsSQL2 } from "../services/wsSQL2.ts";
+export type SQLValue = string | number | boolean | null | SQLValue[] | {
+    [key: string]: SQLValue;
+};
+export type SQLRow = Record<string, SQLValue>;
+export declare class SQLCleanupError extends Error {
+    readonly cause: unknown;
+    readonly cleanupErrors: unknown[];
+    constructor(message: string, cause: unknown, cleanupErrors: unknown[]);
+}
+export declare class SQLConnection {
+    protected readonly service: SQL2Service;
+    protected readonly statements: Set<SQLStatement>;
+    protected closed: boolean;
+    protected closing?: Promise<void>;
+    constructor(options: IOptions | IConnection | SQL2Service);
+    createStatement(): SQLStatement;
+    queryRows(sql: string, fetchSize?: number): Promise<SQLRow[]>;
+    explainQuery(sql: string): Promise<WsSQL2.ExplainQueryResponse>;
+    logicalFileMeta(logicalName: string): Promise<WsSQL2.LogicalFileMeta | undefined>;
+    ping(): Promise<boolean>;
+    splitQuery(sql: string): Promise<string[]>;
+    close(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+    checkOpen(): void;
+}
+export declare class SQLStatement {
+    protected readonly service: SQL2Service;
+    protected readonly onClose: () => void;
+    protected result?: SQLResultSet;
+    protected closed: boolean;
+    protected fetchSize: number;
+    protected executing?: Promise<SQLResultSet>;
+    protected closing?: Promise<void>;
+    constructor(service: SQL2Service, onClose: () => void);
+    setFetchSize(size: number): void;
+    cancel(): Promise<void>;
+    executeQuery(sql: string): Promise<SQLResultSet>;
+    protected execute(sql: string): Promise<SQLResultSet>;
+    protected runQuery(sql: string): Promise<SQLResultSet>;
+    close(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+    protected checkOpen(): void;
+}
+export declare class SQLResultSet {
+    protected readonly service: SQL2Service;
+    protected readonly columns: WsSQL2.Column[];
+    protected cursor: string | undefined;
+    protected readonly fetchSize: number;
+    protected index: number;
+    protected row?: SQLValue[];
+    protected wasNullValue: boolean;
+    protected closed: boolean;
+    protected advancing?: Promise<boolean>;
+    protected closing?: Promise<void>;
+    constructor(service: SQL2Service, columns: WsSQL2.Column[], cursor: string | undefined, fetchSize: number);
+    protected rows: SQLValue[][];
+    protected complete: boolean;
+    getMetaData(): readonly WsSQL2.Column[];
+    findColumn(label: string): number;
+    next(): Promise<boolean>;
+    private advance;
+    private advancePage;
+    getObject(column: number | string): SQLValue;
+    getString(column: number | string): string | null;
+    getRow(): SQLRow;
+    wasNull(): boolean;
+    close(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+    cancel(): Promise<void>;
+    protected closeCursor(): Promise<void>;
+    protected checkOpen(): void;
+}

package/types/index.common.d.ts

@@ -15,6 +15,7 @@ export * from "./services/wsPackageProcess.ts";
 export * from "./services/wsResources.ts";
 export * from "./services/wsSasha.ts";
 export * from "./services/wsSMC.ts";
+export * from "./services/wsSQL2.ts";
 export * from "./services/wsStore.ts";
 export * from "./services/wsTopology.ts";
 export * from "./services/wsWorkunits.ts";
@@ -26,6 +27,7 @@ export * from "./ecl/query.ts";
 export * from "./ecl/resource.ts";
 export * from "./ecl/result.ts";
 export * from "./ecl/scope.ts";
+export * from "./ecl/sql2.ts";
 export * from "./ecl/sourceFile.ts";
 export * from "./ecl/store.ts";
 export * from "./ecl/timer.ts";

package/types/services/fileSpray.d.ts

@@ -1,4 +1,4 @@
-import { FileSprayServiceBase, FileSpray } from "./wsdl/FileSpray/v1.29/FileSpray.ts";
+import { FileSprayServiceBase, FileSpray } from "./wsdl/FileSpray/v1.30/FileSpray.ts";
 export { FileSpray };
 type UpdateDFUWorkunitMinusWU = Omit<FileSpray.UpdateDFUWorkunit, "wu">;
 type UpdateDFUWorkunitWU = FileSpray.UpdateDFUWorkunit["wu"];

package/types/services/wsSQL2.d.ts

@@ -0,0 +1,4 @@
+import { SQL2ServiceBase, WsSQL2 } from "./wsdl/WsSQL2/v1.00/WsSQL2.ts";
+export { type WsSQL2 };
+export declare class SQL2Service extends SQL2ServiceBase {
+}

package/types/services/wsdl/FileSpray/{v1.29 → v1.30}/FileSpray.d.ts

@@ -145,6 +145,9 @@ export declare namespace FileSpray {
         FileAccessCost?: double;
         KbPerSecAve?: int;
         KbPerSec?: int;
+        SubTaskCount?: int;
+        SubTasksFinished?: int;
+        SubTasksFailed?: int;
     }
     interface CreateDFUPublisherWorkunitResponse {
         Exceptions?: Exceptions;
@@ -459,6 +462,9 @@ export declare namespace FileSpray {
         FileAccessCost?: double;
         KbPerSecAve?: int;
         KbPerSec?: int;
+        SubTaskCount?: int;
+        SubTasksFinished?: int;
+        SubTasksFailed?: int;
     }
     interface results {
         DFUWorkunit?: DFUWorkunit[];
@@ -467,6 +473,7 @@ export declare namespace FileSpray {
         Exceptions?: Exceptions;
         results?: results;
         Command?: DFUCommand;
+        Archived?: boolean;
         Owner?: string;
         Cluster?: string;
         StateReq?: string;
@@ -705,6 +712,9 @@ export declare namespace FileSpray {
         FileAccessCost?: double;
         KbPerSecAve?: int;
         KbPerSec?: int;
+        SubTaskCount?: int;
+        SubTasksFinished?: int;
+        SubTasksFailed?: int;
     }
     interface UpdateDFUWorkunit {
         wu?: wu;