Merge pull request #37 from duckdb/jray/data-type-to-string

jraymakers · web-flow · commit 6d34f4b11b06 · 2024-10-27T10:15:39.000-07:00
data type toString
diff --git a/api/pkgs/@duckdb/node-api/README.md b/api/pkgs/@duckdb/node-api/README.md
@@ -191,6 +191,12 @@ function typeToString(dataType) {
 }
 ```
 
+While the example above demonstrates how to access the properties of data type objects, there is a much simpler way to convert them to strings:
+
+```ts
+const dataTypeString = dataType.toString();
+```
+
 ### Inspect Data Values
 
 ```ts
diff --git a/api/src/DuckDBType.ts b/api/src/DuckDBType.ts
@@ -1,10 +1,14 @@
 import { DuckDBTypeId } from './DuckDBTypeId';
+import { quotedIdentifier, quotedString } from './sql';
 
 export abstract class BaseDuckDBType {
   public readonly typeId: DuckDBTypeId;
   protected constructor(typeId: DuckDBTypeId) {
     this.typeId = typeId;
   }
+  public toString(): string {
+    return DuckDBTypeId[this.typeId];
+  }
 }
 
 export class DuckDBBooleanType extends BaseDuckDBType {
@@ -150,6 +154,9 @@ export class DuckDBDecimalType extends BaseDuckDBType {
     this.width = width;
     this.scale = scale;
   }
+  public toString(): string {
+    return `DECIMAL(${this.width},${this.scale})`;
+  }
   public static readonly default = new DuckDBDecimalType(18, 3);
 }
 
@@ -182,6 +189,9 @@ export class DuckDBEnumType extends BaseDuckDBType {
     this.values = values;
     this.internalTypeId = internalTypeId;
   }
+  public toString(): string {
+    return `ENUM(${this.values.map(quotedString).join(', ')})`;
+  }
 }
 
 export class DuckDBListType extends BaseDuckDBType {
@@ -190,6 +200,9 @@ export class DuckDBListType extends BaseDuckDBType {
     super(DuckDBTypeId.LIST);
     this.valueType = valueType;
   }
+  public toString(): string {
+    return `${this.valueType}[]`;
+  }
 }
 
 export interface DuckDBStructEntryType {
@@ -203,6 +216,11 @@ export class DuckDBStructType extends BaseDuckDBType {
     super(DuckDBTypeId.STRUCT);
     this.entries = entries;
   }
+  public toString(): string {
+    return `STRUCT(${this.entries.map(
+      entry => `${quotedIdentifier(entry.name)} ${entry.valueType}`
+    ).join(', ')})`;
+  }
 }
 
 export class DuckDBMapType extends BaseDuckDBType {
@@ -213,6 +231,9 @@ export class DuckDBMapType extends BaseDuckDBType {
     this.keyType = keyType;
     this.valueType = valueType;
   }
+  public toString(): string {
+    return `MAP(${this.keyType}, ${this.valueType})`;
+  }
 }
 
 export class DuckDBArrayType extends BaseDuckDBType {
@@ -223,6 +244,9 @@ export class DuckDBArrayType extends BaseDuckDBType {
     this.valueType = valueType;
     this.length = length;
   }
+  public toString(): string {
+    return `${this.valueType}[${this.length}]`;
+  }
 }
 
 export class DuckDBUUIDType extends BaseDuckDBType {
@@ -243,6 +267,11 @@ export class DuckDBUnionType extends BaseDuckDBType {
     super(DuckDBTypeId.UNION);
     this.alternatives = alternatives;
   }
+  public toString(): string {
+    return `UNION(${this.alternatives.map(
+      entry => `${quotedIdentifier(entry.tag)} ${entry.valueType}`
+    ).join(', ')})`;
+  }
 }
 
 export class DuckDBBitType extends BaseDuckDBType {
@@ -256,13 +285,19 @@ export class DuckDBTimeTZType extends BaseDuckDBType {
   private constructor() {
     super(DuckDBTypeId.TIME_TZ);
   }
+  public toString(): string {
+    return "TIME WITH TIME ZONE";
+  }
   public static readonly instance = new DuckDBTimeTZType();
 }
 
 export class DuckDBTimestampTZType extends BaseDuckDBType {
   private constructor() {
     super(DuckDBTypeId.TIMESTAMP_TZ);
   }
+  public toString(): string {
+    return "TIMESTAMP WITH TIME ZONE";
+  }
   public static readonly instance = new DuckDBTimestampTZType();
 }
 
diff --git a/api/src/index.ts b/api/src/index.ts
@@ -13,4 +13,5 @@ export * from './DuckDBTypeId';
 export * from './DuckDBValue';
 export * from './DuckDBVector';
 export * from './enums';
+export * from './sql';
 export * from './version';
diff --git a/api/src/sql.ts b/api/src/sql.ts
@@ -0,0 +1,7 @@
+export function quotedString(input: string): string {
+  return `'${input.replace(`'`, `''`)}'`;
+}
+
+export function quotedIdentifier(input: string): string {
+  return `"${input.replace(`"`, `""`)}"`;
+}
diff --git a/api/test/api.test.ts b/api/test/api.test.ts
@@ -1,5 +1,6 @@
 import { assert, describe, test } from 'vitest';
 import {
+  DuckDBAnyType,
   DuckDBArrayType,
   DuckDBArrayVector,
   DuckDBBigIntType,
@@ -44,6 +45,7 @@ import {
   DuckDBMapVector,
   DuckDBPendingResultState,
   DuckDBResult,
+  DuckDBSQLNullType,
   DuckDBSmallDecimal,
   DuckDBSmallIntType,
   DuckDBSmallIntVector,
@@ -283,6 +285,10 @@ describe('api', () => {
     const ver = version();
     assert.ok(ver.startsWith('v'), `version starts with 'v'`);
   });
+  test('should expose configuration option descriptions', () => {
+    const descriptions = configurationOptionDescriptions();
+    assert.ok(descriptions['memory_limit'], `descriptions has 'memory_limit'`);
+  });
   test('ReturnResultType enum', () => {
     assert.equal(ResultReturnType.INVALID, 0);
     assert.equal(ResultReturnType.CHANGED_ROWS, 1);
@@ -353,9 +359,55 @@ describe('api', () => {
     assert.equal(StatementType[StatementType.DETACH], 'DETACH');
     assert.equal(StatementType[StatementType.MULTI], 'MULTI');
   });
-  test('should expose configuration option descriptions', () => {
-    const descriptions = configurationOptionDescriptions();
-    assert.ok(descriptions['memory_limit'], `descriptions has 'memory_limit'`);
+  test('DuckDBType toString', () => {
+    assert.equal(DuckDBBooleanType.instance.toString(), 'BOOLEAN');
+    assert.equal(DuckDBTinyIntType.instance.toString(), 'TINYINT');
+    assert.equal(DuckDBSmallIntType.instance.toString(), 'SMALLINT');
+    assert.equal(DuckDBIntegerType.instance.toString(), 'INTEGER');
+    assert.equal(DuckDBBigIntType.instance.toString(), 'BIGINT');
+    assert.equal(DuckDBUTinyIntType.instance.toString(), 'UTINYINT');
+    assert.equal(DuckDBUSmallIntType.instance.toString(), 'USMALLINT');
+    assert.equal(DuckDBUIntegerType.instance.toString(), 'UINTEGER');
+    assert.equal(DuckDBUBigIntType.instance.toString(), 'UBIGINT');
+    assert.equal(DuckDBFloatType.instance.toString(), 'FLOAT');
+    assert.equal(DuckDBDoubleType.instance.toString(), 'DOUBLE');
+    assert.equal(DuckDBTimestampType.instance.toString(), 'TIMESTAMP');
+    assert.equal(DuckDBDateType.instance.toString(), 'DATE');
+    assert.equal(DuckDBTimeType.instance.toString(), 'TIME');
+    assert.equal(DuckDBIntervalType.instance.toString(), 'INTERVAL');
+    assert.equal(DuckDBHugeIntType.instance.toString(), 'HUGEINT');
+    assert.equal(DuckDBUHugeIntType.instance.toString(), 'UHUGEINT');
+    assert.equal(DuckDBVarCharType.instance.toString(), 'VARCHAR');
+    assert.equal(DuckDBBlobType.instance.toString(), 'BLOB');
+    assert.equal((new DuckDBDecimalType(17, 5)).toString(), 'DECIMAL(17,5)');
+    assert.equal(DuckDBTimestampSecondsType.instance.toString(), 'TIMESTAMP_S');
+    assert.equal(DuckDBTimestampMillisecondsType.instance.toString(), 'TIMESTAMP_MS');
+    assert.equal(DuckDBTimestampNanosecondsType.instance.toString(), 'TIMESTAMP_NS');
+    assert.equal(
+      (new DuckDBEnumType(['fly', 'swim', 'walk'], DuckDBTypeId.UTINYINT)).toString(),
+      `ENUM('fly', 'swim', 'walk')`
+    );
+    assert.equal((new DuckDBListType(DuckDBIntegerType.instance)).toString(), 'INTEGER[]');
+    assert.equal((new DuckDBStructType([
+      { name: 'id', valueType: DuckDBVarCharType.instance },
+      { name: 'ts', valueType: DuckDBTimestampType.instance },
+    ])).toString(), 'STRUCT("id" VARCHAR, "ts" TIMESTAMP)');
+    assert.equal(
+      (new DuckDBMapType(DuckDBIntegerType.instance, DuckDBVarCharType.instance)).toString(),
+      'MAP(INTEGER, VARCHAR)'
+    );
+    assert.equal((new DuckDBArrayType(DuckDBIntegerType.instance, 3)).toString(), 'INTEGER[3]');
+    assert.equal(DuckDBUUIDType.instance.toString(), 'UUID');
+    assert.equal((new DuckDBUnionType([
+      { tag: 'str', valueType: DuckDBVarCharType.instance },
+      { tag: 'num', valueType: DuckDBIntegerType.instance },
+    ])).toString(), 'UNION("str" VARCHAR, "num" INTEGER)');
+    assert.equal(DuckDBBitType.instance.toString(), 'BIT');
+    assert.equal(DuckDBTimeTZType.instance.toString(), 'TIME WITH TIME ZONE');
+    assert.equal(DuckDBTimestampTZType.instance.toString(), 'TIMESTAMP WITH TIME ZONE');
+    assert.equal(DuckDBAnyType.instance.toString(), 'ANY');
+    assert.equal(DuckDBVarIntType.instance.toString(), 'VARINT');
+    assert.equal(DuckDBSQLNullType.instance.toString(), 'SQLNULL');
   });
   test('should support creating, connecting, running a basic query, and reading results', async () => {
     const instance = await DuckDBInstance.create();

Original file line number	Diff line number	Diff line change
`@@ -1,10 +1,14 @@`
`1`	`1`	`import { DuckDBTypeId } from './DuckDBTypeId';`
	`2`	`+import { quotedIdentifier, quotedString } from './sql';`
`2`	`3`
`3`	`4`	`export abstract class BaseDuckDBType {`
`4`	`5`	`public readonly typeId: DuckDBTypeId;`
`5`	`6`	`protected constructor(typeId: DuckDBTypeId) {`
`6`	`7`	`this.typeId = typeId;`
`7`	`8`	`}`
	`9`	`+ public toString(): string {`
	`10`	`+ return DuckDBTypeId[this.typeId];`
	`11`	`+ }`
`8`	`12`	`}`
`9`	`13`
`10`	`14`	`export class DuckDBBooleanType extends BaseDuckDBType {`
`@@ -150,6 +154,9 @@ export class DuckDBDecimalType extends BaseDuckDBType {`
`150`	`154`	`this.width = width;`
`151`	`155`	`this.scale = scale;`
`152`	`156`	`}`
	`157`	`+ public toString(): string {`
	`158`	+ return `DECIMAL(${this.width},${this.scale})`;
	`159`	`+ }`
`153`	`160`	`public static readonly default = new DuckDBDecimalType(18, 3);`
`154`	`161`	`}`
`155`	`162`
`@@ -182,6 +189,9 @@ export class DuckDBEnumType extends BaseDuckDBType {`
`182`	`189`	`this.values = values;`
`183`	`190`	`this.internalTypeId = internalTypeId;`
`184`	`191`	`}`
	`192`	`+ public toString(): string {`
	`193`	+ return `ENUM(${this.values.map(quotedString).join(', ')})`;
	`194`	`+ }`
`185`	`195`	`}`
`186`	`196`
`187`	`197`	`export class DuckDBListType extends BaseDuckDBType {`
`@@ -190,6 +200,9 @@ export class DuckDBListType extends BaseDuckDBType {`
`190`	`200`	`super(DuckDBTypeId.LIST);`
`191`	`201`	`this.valueType = valueType;`
`192`	`202`	`}`
	`203`	`+ public toString(): string {`
	`204`	+ return `${this.valueType}[]`;
	`205`	`+ }`
`193`	`206`	`}`
`194`	`207`
`195`	`208`	`export interface DuckDBStructEntryType {`
`@@ -203,6 +216,11 @@ export class DuckDBStructType extends BaseDuckDBType {`
`203`	`216`	`super(DuckDBTypeId.STRUCT);`
`204`	`217`	`this.entries = entries;`
`205`	`218`	`}`
	`219`	`+ public toString(): string {`
	`220`	+ return `STRUCT(${this.entries.map(
	`221`	+ entry => `${quotedIdentifier(entry.name)} ${entry.valueType}`
	`222`	+ ).join(', ')})`;
	`223`	`+ }`
`206`	`224`	`}`
`207`	`225`
`208`	`226`	`export class DuckDBMapType extends BaseDuckDBType {`
`@@ -213,6 +231,9 @@ export class DuckDBMapType extends BaseDuckDBType {`
`213`	`231`	`this.keyType = keyType;`
`214`	`232`	`this.valueType = valueType;`
`215`	`233`	`}`
	`234`	`+ public toString(): string {`
	`235`	+ return `MAP(${this.keyType}, ${this.valueType})`;
	`236`	`+ }`
`216`	`237`	`}`
`217`	`238`
`218`	`239`	`export class DuckDBArrayType extends BaseDuckDBType {`
`@@ -223,6 +244,9 @@ export class DuckDBArrayType extends BaseDuckDBType {`
`223`	`244`	`this.valueType = valueType;`
`224`	`245`	`this.length = length;`
`225`	`246`	`}`
	`247`	`+ public toString(): string {`
	`248`	+ return `${this.valueType}[${this.length}]`;
	`249`	`+ }`
`226`	`250`	`}`
`227`	`251`
`228`	`252`	`export class DuckDBUUIDType extends BaseDuckDBType {`
`@@ -243,6 +267,11 @@ export class DuckDBUnionType extends BaseDuckDBType {`
`243`	`267`	`super(DuckDBTypeId.UNION);`
`244`	`268`	`this.alternatives = alternatives;`
`245`	`269`	`}`
	`270`	`+ public toString(): string {`
	`271`	+ return `UNION(${this.alternatives.map(
	`272`	+ entry => `${quotedIdentifier(entry.tag)} ${entry.valueType}`
	`273`	+ ).join(', ')})`;
	`274`	`+ }`
`246`	`275`	`}`
`247`	`276`
`248`	`277`	`export class DuckDBBitType extends BaseDuckDBType {`
`@@ -256,13 +285,19 @@ export class DuckDBTimeTZType extends BaseDuckDBType {`
`256`	`285`	`private constructor() {`
`257`	`286`	`super(DuckDBTypeId.TIME_TZ);`
`258`	`287`	`}`
	`288`	`+ public toString(): string {`
	`289`	`+ return "TIME WITH TIME ZONE";`
	`290`	`+ }`
`259`	`291`	`public static readonly instance = new DuckDBTimeTZType();`
`260`	`292`	`}`
`261`	`293`
`262`	`294`	`export class DuckDBTimestampTZType extends BaseDuckDBType {`
`263`	`295`	`private constructor() {`
`264`	`296`	`super(DuckDBTypeId.TIMESTAMP_TZ);`
`265`	`297`	`}`
	`298`	`+ public toString(): string {`
	`299`	`+ return "TIMESTAMP WITH TIME ZONE";`
	`300`	`+ }`
`266`	`301`	`public static readonly instance = new DuckDBTimestampTZType();`
`267`	`302`	`}`
`268`	`303`