@hpcc-js/comms 3.22.1 → 3.23.1

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.LogicalFileMetadata | 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.01/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;

package/types/services/wsdl/WsSQL2/v1.01/WsSQL2.d.ts

@@ -0,0 +1,165 @@
+import { IConnection, IOptions } from "../../../../connection.ts";
+import { Service } from "../../../../espConnection.ts";
+export declare namespace WsSQL2 {
+    type double = number;
+    type unsignedInt = number;
+    type long = number;
+    type uint64 = number;
+    interface CloseResultSetRequest {
+        CursorId?: string;
+    }
+    interface Exception {
+        Code?: string;
+        Audience?: string;
+        Source?: string;
+        Message?: string;
+    }
+    interface Exceptions {
+        Source?: string;
+        Exception?: Exception[];
+    }
+    interface CloseResultSetResponse {
+        Exceptions?: Exceptions;
+        Closed?: boolean;
+    }
+    interface ExecuteQueryRequest {
+        SQLText?: string;
+        IncludeRuntimeGraph?: boolean;
+        IncludeResultSetMetadata?: boolean;
+        IncludeDebug?: boolean;
+    }
+    interface Column {
+        ColumnLabel?: string;
+        ColumnTypeName?: string;
+        Precision?: unsignedInt;
+        Scale?: unsignedInt;
+    }
+    interface ResultSetMetadata {
+        Column?: Column[];
+    }
+    interface ExecuteQueryResponse {
+        Exceptions?: Exceptions;
+        CursorId?: string;
+        InitMs?: double;
+        PrepareMs?: double;
+        ResultSetMetadata?: ResultSetMetadata;
+    }
+    interface ExplainQueryRequest {
+        SQLText?: string;
+    }
+    interface ExplainQueryResponse {
+        Exceptions?: Exceptions;
+        Plan?: string;
+        PlanJSON?: string;
+        ResultSetMetadata?: ResultSetMetadata;
+    }
+    interface FetchResultSetRequest {
+        CursorId?: string;
+        RowCount?: unsignedInt;
+    }
+    interface Start {
+        DuckDBUsedBytes?: long;
+        DuckDBTempBytes?: long;
+        HeapInUseBytes?: long;
+        ResidentBytes?: long;
+        PeakResidentBytes?: long;
+    }
+    interface Current {
+        DuckDBUsedBytes?: long;
+        DuckDBTempBytes?: long;
+        HeapInUseBytes?: long;
+        ResidentBytes?: long;
+        PeakResidentBytes?: long;
+    }
+    interface Released {
+        DuckDBUsedBytes?: long;
+        DuckDBTempBytes?: long;
+        HeapInUseBytes?: long;
+        ResidentBytes?: long;
+        PeakResidentBytes?: long;
+    }
+    interface Retained {
+        DuckDBUsedBytes?: long;
+        DuckDBTempBytes?: long;
+        HeapInUseBytes?: long;
+        ResidentBytes?: long;
+        PeakResidentBytes?: long;
+    }
+    interface ScanObjectsCreated {
+        BindData?: long;
+        GlobalStates?: long;
+        LocalStates?: long;
+    }
+    interface ScanObjectsLive {
+        BindData?: long;
+        GlobalStates?: long;
+        LocalStates?: long;
+    }
+    interface DebugInfo {
+        Start?: Start;
+        Current?: Current;
+        Released?: Released;
+        Retained?: Retained;
+        ScanObjectsCreated?: ScanObjectsCreated;
+        ScanObjectsLive?: ScanObjectsLive;
+        LeakCheck?: string;
+        LeakCheckDetail?: string;
+    }
+    interface FetchResultSetResponse {
+        Exceptions?: Exceptions;
+        RowsJSON?: string;
+        RowCount?: unsignedInt;
+        Complete?: boolean;
+        ExecuteMs?: double;
+        RuntimeGraph?: string;
+        RuntimeGraphJSON?: string;
+        DebugInfo?: DebugInfo;
+    }
+    interface LogicalFileMetadataRequest {
+        LogicalName?: string;
+    }
+    interface LogicalFileMetadata {
+        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;
+    }
+    interface LogicalFileMetadataResponse {
+        Exceptions?: Exceptions;
+        LogicalFileMetadata?: LogicalFileMetadata;
+    }
+    interface WsSQL2PingRequest {
+    }
+    interface WsSQL2PingResponse {
+    }
+    interface SplitQueryRequest {
+        SQLText?: string;
+    }
+    interface Statements {
+        Statement?: string[];
+    }
+    interface SplitQueryResponse {
+        Exceptions?: Exceptions;
+        Statements?: Statements;
+    }
+}
+export declare class SQL2ServiceBase extends Service {
+    constructor(optsConnection: IOptions | IConnection);
+    CloseResultSet(request: WsSQL2.CloseResultSetRequest, abortSignal?: AbortSignal): Promise<WsSQL2.CloseResultSetResponse>;
+    ExecuteQuery(request: WsSQL2.ExecuteQueryRequest, abortSignal?: AbortSignal): Promise<WsSQL2.ExecuteQueryResponse>;
+    ExplainQuery(request: WsSQL2.ExplainQueryRequest, abortSignal?: AbortSignal): Promise<WsSQL2.ExplainQueryResponse>;
+    FetchResultSet(request: WsSQL2.FetchResultSetRequest, abortSignal?: AbortSignal): Promise<WsSQL2.FetchResultSetResponse>;
+    LogicalFileMetadata(request: WsSQL2.LogicalFileMetadataRequest, abortSignal?: AbortSignal): Promise<WsSQL2.LogicalFileMetadataResponse>;
+    Ping(request: WsSQL2.WsSQL2PingRequest, abortSignal?: AbortSignal): Promise<WsSQL2.WsSQL2PingResponse>;
+    SplitQuery(request: WsSQL2.SplitQueryRequest, abortSignal?: AbortSignal): Promise<WsSQL2.SplitQueryResponse>;
+}