feat(transwarp): add Inceptor data source with table operations

This commit is contained in:
Hand Sonic authored and GitHub committed 2026-09-29 02:05:07 +08:00
1 parent 597b134d21
commit 6fdc338348
101 files changed
+2300 -66

No files matched your search

@@ -0,0 +1,25 @@
import { describe, expect, it } from "vitest";
import { parseConnectionUrl } from "@/lib/connection/connectionUrl";
describe("Transwarp JDBC URL parsing", () => {
it("keeps the selected product when the SDK uses its other compatible URL", () => {
const inceptor = parseConnectionUrl("jdbc:inceptor2://quark:10000/default;fetchSize=200", "transwarp-inceptor");
expect(inceptor).toMatchObject({
dbType: "transwarp",
driverProfile: "transwarp-inceptor",
host: "quark",
port: 10000,
database: "default",
urlParams: "fetchSize=200",
});
expect(parseConnectionUrl("jdbc:transwarp2://quark:10000/default").driverProfile).toBe("transwarp-inceptor");
});
it("detects Inceptor URLs without an existing product selection", () => {
expect(parseConnectionUrl("jdbc:inceptor2://quark:10000/default")).toMatchObject({
dbType: "transwarp",
driverProfile: "transwarp-inceptor",
});
expect(parseConnectionUrl("jdbc:hive2://quark:10000/default").dbType).toBe("hive");
});
});
@@ -59,6 +59,11 @@ describe("connectionUrlCopyFormats", () => {
const formats = connectionUrlCopyFormats(config({ db_type: "hive", host: "hive.example.com", port: 10000, database: "dw" }));
expect(formats).toEqual(["jdbcUrl", "jdbcUrlWithCredentials", "hostPort"]);
});
it("uses semicolon options when copying an Inceptor JDBC URL", () => {
const transwarp = config({ db_type: "transwarp", host: "quark.example.com", port: 10000, database: "default", username: "", password: "", url_params: "fetchSize=500" });
expect(buildConnectionUrlCopy(transwarp, "jdbcUrl")).toBe("jdbc:inceptor2://quark.example.com:10000/default;fetchSize=500");
});
});
describe("buildConnectionUrlCopy standard URL", () => {
@@ -33,4 +33,11 @@ describe("database namespace creation targets", () => {
expect(connectionNamespaceCreationTarget(postgres)).toBe("database");
expect(databaseNodeNamespaceCreationTarget(postgres, databaseNode)).toBe("schema");
});
it("offers top-level database creation for Inceptor without nested schemas", () => {
const transwarp = { db_type: "transwarp", driver_profile: "transwarp-inceptor" } as Conn;
expect(connectionNamespaceCreationTarget(transwarp)).toBe("database");
expect(databaseNodeNamespaceCreationTarget(transwarp, databaseNode)).toBeNull();
});
});
@@ -667,6 +667,7 @@ describe("splitSqlStatementRanges", () => {
expect(rangeSqlTexts(splitSqlStatementRanges(argoProcedureFixture, "argo"))).toEqual([argoProcedureFixture]);
expect(hasMultipleExecutionTargets(argoProcedureFixture, "argo")).toBe(false);
expect(rangeSqlTexts(executableStatementRanges(argoProcedureFixture, "argo"))).toEqual([argoProcedureFixture]);
expect(rangeSqlTexts(splitSqlStatementRanges(argoProcedureFixture, "transwarp"))).toEqual([argoProcedureFixture]);
});
it("statement at cursor inside an ArgoDB procedure body returns the whole definition", () => {
@@ -1,6 +1,16 @@
import { describe, expect, it } from "vitest";
import { databaseRenameMaintenanceDatabase, supportsDatabaseRename } from "@/lib/table/objectRenameSql";
import { databaseRenameMaintenanceDatabase, supportsDatabaseRename, supportsObjectRename } from "@/lib/table/objectRenameSql";
describe("Inceptor object rename", () => {
it("exposes table rename without enabling unsupported object or database renames", () => {
expect(supportsObjectRename("transwarp", "TABLE")).toBe(true);
expect(supportsObjectRename("transwarp", "VIEW")).toBe(false);
expect(supportsObjectRename("transwarp", "PROCEDURE")).toBe(false);
expect(supportsObjectRename("transwarp", "FUNCTION")).toBe(false);
expect(supportsDatabaseRename("transwarp")).toBe(false);
});
});
describe("database rename", () => {
it("chooses a maintenance database outside the rename target", () => {
@@ -10,6 +10,7 @@ import {
editablePrimaryKeys,
editableRowIdentifierColumns,
hasCompleteTdengineRowIdentity,
hiveTablePropertiesIndicateTransactional,
isClickHouseExistingRowReadonlyColumn,
isHiddenGridColumn,
isSalesforceExistingRowReadonlyColumn,
@@ -45,6 +46,17 @@ function index(columns: string[], isUnique = true, filter: string | null = null)
}
describe("tableEditing", () => {
it("allows Inceptor inserts but only edits existing rows in transactional tables", () => {
expect(isTableDataEditable("transwarp", [], "TABLE")).toBe(true);
expect(isTableDataEditable("transwarp", [], "VIEW")).toBe(false);
expect(canInsertTableRows("transwarp")).toBe(true);
expect(canEditExistingTableRows("transwarp", false)).toBe(false);
expect(canEditExistingTableRows("transwarp", true)).toBe(true);
expect(supportsDataGridTransaction("transwarp")).toBe(true);
expect(hiveTablePropertiesIndicateTransactional({ rows: [["transactional", "true"]] })).toBe(true);
expect(hiveTablePropertiesIndicateTransactional({ rows: [["true"]] })).toBe(true);
expect(hiveTablePropertiesIndicateTransactional({ rows: [["false"]] })).toBe(false);
});
it("synthesizes ROWID only for Oracle-compatible base tables", () => {
expect(editablePrimaryKeys("oracle", [column("ID"), column("NAME")])).toEqual([]);
expect(editablePrimaryKeys("oracle", [column("ID"), column("NAME")], "VIEW")).toEqual([]);
@@ -0,0 +1,39 @@
import { describe, expect, it } from "vitest";
import { buildInceptorCreateOptions, emptyTablePhysicalOptions, hasTablePhysicalOptions, pruneTablePhysicalOptions, restoreTablePhysicalOptions } from "@/lib/table/tablePhysicalOptions";
const columns = [
{ id: "first", name: "id" },
{ id: "second", name: "day" },
{ id: "third", name: "label" },
];
describe("table physical options", () => {
it("restores a saved draft without sharing its column selections", () => {
const saved = { physicalOptions: { partitionColumnIds: ["second"], distributionColumnIds: ["first"], bucketCount: "2", storageFormat: "ORC", transactional: true } };
const restored = restoreTablePhysicalOptions(saved);
expect(restored).toMatchObject({ partitionColumnIds: ["second"], distributionColumnIds: ["first"], bucketCount: "2", storageFormat: "ORC", transactional: true });
expect(restored.partitionColumnIds).not.toBe(saved.physicalOptions.partitionColumnIds);
expect(restored.distributionColumnIds).not.toBe(saved.physicalOptions.distributionColumnIds);
expect(restoreTablePhysicalOptions({})).toEqual(emptyTablePhysicalOptions());
expect(hasTablePhysicalOptions(restored)).toBe(true);
expect(hasTablePhysicalOptions(emptyTablePhysicalOptions())).toBe(false);
});
it("uses the current column name after a selected column is renamed", () => {
const draft = { ...emptyTablePhysicalOptions(), partitionColumnIds: ["second"], distributionColumnIds: ["first"], bucketCount: "2", storageFormat: "ORC", transactional: true };
const renamed = columns.map((column) => (column.id === "second" ? { ...column, name: "event_day" } : column));
expect(buildInceptorCreateOptions(draft, renamed)).toEqual({
partitionColumns: ["event_day"],
bucketColumns: ["id"],
bucketCount: 2,
storageFormat: "ORC",
transactional: true,
});
expect(pruneTablePhysicalOptions(draft, new Set(["first", "third"]))).toMatchObject({ partitionColumnIds: [], distributionColumnIds: ["first"] });
});
it("keeps an invalid bucket count in the SQL builder's validation path", () => {
const draft = { ...emptyTablePhysicalOptions(), distributionColumnIds: ["first"], bucketCount: "1.5" };
expect(buildInceptorCreateOptions(draft, columns).bucketCount).toBe(0);
});
});
@@ -110,6 +110,21 @@ describe("tableStructureCapabilities", () => {
}
});
it("enables only the verified Inceptor column structure operations", () => {
expect(getTableStructureCapabilities("transwarp", "transwarp")).toMatchObject({
dialect: "mysql",
alterStrategy: "direct",
createTable: true,
addColumn: true,
dropColumn: false,
renameColumn: true,
alterExistingColumn: true,
comment: true,
createIndex: false,
foreignKey: false,
});
});
it("uses local-only column reordering for editable databases without physical reorder support", () => {
for (const databaseType of ["sqlserver", "postgres", "sqlite", "oracle", "dameng", "duckdb", "informix"] as const) {
expect(supportsLocalTableColumnReorder(databaseType, databaseType)).toBe(true);