@loaders.gl/parquet 4.5.3 → 5.0.0-alpha.10

package/src/parquetjs/parquet-thrift/EncryptionAlgorithm.ts

@@ -0,0 +1,127 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import * as thrift from '../utils/thrift-runtime';
+
+/** AES-GCM algorithm parameters from the Parquet modular-encryption spec. */
+export class AesGcmV1 {
+  public aad_prefix?: Uint8Array;
+  public aad_file_unique?: Uint8Array;
+  public supply_aad_prefix?: boolean;
+
+  constructor(args: Partial<AesGcmV1> = {}) {
+    Object.assign(this, args);
+  }
+}
+
+/** AES-GCM metadata algorithm with AES-CTR page encryption. */
+export class AesGcmCtrV1 extends AesGcmV1 {}
+
+/** Parquet modular-encryption algorithm union. */
+export class EncryptionAlgorithm {
+  public AES_GCM_V1?: AesGcmV1;
+  public AES_GCM_CTR_V1?: AesGcmCtrV1;
+
+  constructor(args: Partial<EncryptionAlgorithm> = {}) {
+    const fields = [args.AES_GCM_V1, args.AES_GCM_CTR_V1].filter(Boolean);
+    if (fields.length !== 1) {
+      throw new thrift.Thrift.TProtocolException(
+        thrift.Thrift.TProtocolExceptionType.INVALID_DATA,
+        'EncryptionAlgorithm must contain exactly one algorithm'
+      );
+    }
+    Object.assign(this, args);
+  }
+
+  /** Writes the selected encryption algorithm union. */
+  public write(output: thrift.TProtocol): void {
+    output.writeStructBegin('EncryptionAlgorithm');
+    if (this.AES_GCM_V1) {
+      writeAlgorithm(output, 'AES_GCM_V1', 1, this.AES_GCM_V1);
+    } else if (this.AES_GCM_CTR_V1) {
+      writeAlgorithm(output, 'AES_GCM_CTR_V1', 2, this.AES_GCM_CTR_V1);
+    }
+    output.writeFieldStop();
+    output.writeStructEnd();
+  }
+
+  /** Reads an encryption algorithm union. */
+  public static read(input: thrift.TProtocol): EncryptionAlgorithm {
+    input.readStructBegin();
+    let algorithm: EncryptionAlgorithm | undefined;
+    while (true) {
+      const field = input.readFieldBegin();
+      if (field.ftype === thrift.Thrift.Type.STOP) break;
+      if (field.fid === 1 && field.ftype === thrift.Thrift.Type.STRUCT) {
+        algorithm = new EncryptionAlgorithm({AES_GCM_V1: readAlgorithm(input)});
+      } else if (field.fid === 2 && field.ftype === thrift.Thrift.Type.STRUCT) {
+        algorithm = new EncryptionAlgorithm({AES_GCM_CTR_V1: readAlgorithm(input)});
+      } else {
+        input.skip(field.ftype);
+      }
+      input.readFieldEnd();
+    }
+    input.readStructEnd();
+    if (!algorithm) {
+      throw new thrift.Thrift.TProtocolException(
+        thrift.Thrift.TProtocolExceptionType.INVALID_DATA,
+        'EncryptionAlgorithm union has no selected algorithm'
+      );
+    }
+    return algorithm;
+  }
+}
+
+function writeAlgorithm(
+  output: thrift.TProtocol,
+  name: string,
+  fieldId: number,
+  algorithm: AesGcmV1
+): void {
+  output.writeFieldBegin(name, thrift.Thrift.Type.STRUCT, fieldId);
+  output.writeStructBegin(name);
+  if (algorithm.aad_prefix) writeBinary(output, 'aad_prefix', 1, algorithm.aad_prefix);
+  if (algorithm.aad_file_unique)
+    writeBinary(output, 'aad_file_unique', 2, algorithm.aad_file_unique);
+  if (algorithm.supply_aad_prefix !== undefined) {
+    output.writeFieldBegin('supply_aad_prefix', thrift.Thrift.Type.BOOL, 3);
+    output.writeBool(algorithm.supply_aad_prefix);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  output.writeFieldEnd();
+}
+
+function readAlgorithm(input: thrift.TProtocol): AesGcmV1 {
+  input.readStructBegin();
+  const result = new AesGcmV1();
+  while (true) {
+    const field = input.readFieldBegin();
+    if (field.ftype === thrift.Thrift.Type.STOP) break;
+    if (field.fid === 1 && field.ftype === thrift.Thrift.Type.STRING) {
+      result.aad_prefix = input.readBinary();
+    } else if (field.fid === 2 && field.ftype === thrift.Thrift.Type.STRING) {
+      result.aad_file_unique = input.readBinary();
+    } else if (field.fid === 3 && field.ftype === thrift.Thrift.Type.BOOL) {
+      result.supply_aad_prefix = input.readBool();
+    } else {
+      input.skip(field.ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return result;
+}
+
+function writeBinary(
+  output: thrift.TProtocol,
+  name: string,
+  fieldId: number,
+  value: Uint8Array
+): void {
+  output.writeFieldBegin(name, thrift.Thrift.Type.STRING, fieldId);
+  output.writeBinary(value);
+  output.writeFieldEnd();
+}

package/src/parquetjs/parquet-thrift/EnumType.ts

@@ -10,7 +10,7 @@
  * Autogenerated by @creditkarma/thrift-typescript v3.7.2
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  */
-import * as thrift from 'thrift';
+import * as thrift from '../utils/thrift-runtime';
 export interface IEnumTypeArgs {}
 export class EnumType {
   constructor() {}

package/src/parquetjs/parquet-thrift/FileCryptoMetaData.ts

@@ -0,0 +1,60 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import * as thrift from '../utils/thrift-runtime';
+import * as EncryptionAlgorithm from './EncryptionAlgorithm';
+
+/** File-level crypto metadata stored before an encrypted Parquet footer. */
+export class FileCryptoMetaData {
+  public encryption_algorithm: EncryptionAlgorithm.EncryptionAlgorithm;
+  public key_metadata?: Uint8Array;
+  constructor(args: {
+    encryption_algorithm: EncryptionAlgorithm.EncryptionAlgorithm;
+    key_metadata?: Uint8Array;
+  }) {
+    this.encryption_algorithm = args.encryption_algorithm;
+    this.key_metadata = args.key_metadata;
+  }
+
+  /** Writes file-level encryption metadata. */
+  public write(output: thrift.TProtocol): void {
+    output.writeStructBegin('FileCryptoMetaData');
+    output.writeFieldBegin('encryption_algorithm', thrift.Thrift.Type.STRUCT, 1);
+    this.encryption_algorithm.write(output);
+    output.writeFieldEnd();
+    if (this.key_metadata) {
+      output.writeFieldBegin('key_metadata', thrift.Thrift.Type.STRING, 2);
+      output.writeBinary(this.key_metadata);
+      output.writeFieldEnd();
+    }
+    output.writeFieldStop();
+    output.writeStructEnd();
+  }
+
+  /** Reads file-level encryption metadata. */
+  public static read(input: thrift.TProtocol): FileCryptoMetaData {
+    input.readStructBegin();
+    let encryptionAlgorithm: EncryptionAlgorithm.EncryptionAlgorithm | undefined;
+    let keyMetadata: Uint8Array | undefined;
+    while (true) {
+      const field = input.readFieldBegin();
+      if (field.ftype === thrift.Thrift.Type.STOP) break;
+      if (field.fid === 1 && field.ftype === thrift.Thrift.Type.STRUCT) {
+        encryptionAlgorithm = EncryptionAlgorithm.EncryptionAlgorithm.read(input);
+      } else if (field.fid === 2 && field.ftype === thrift.Thrift.Type.STRING) {
+        keyMetadata = input.readBinary();
+      } else {
+        input.skip(field.ftype);
+      }
+      input.readFieldEnd();
+    }
+    input.readStructEnd();
+    if (!encryptionAlgorithm)
+      throw new Error('FileCryptoMetaData encryption_algorithm is required');
+    return new FileCryptoMetaData({
+      encryption_algorithm: encryptionAlgorithm,
+      key_metadata: keyMetadata
+    });
+  }
+}

package/src/parquetjs/parquet-thrift/FileMetaData.ts

@@ -10,12 +10,13 @@
  * Autogenerated by @creditkarma/thrift-typescript v3.7.2
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  */
-import Int64 from 'node-int64';
-import * as thrift from 'thrift';
+import {CompactInt64 as Int64} from '../utils/uint8-array-compact-protocol';
+import * as thrift from '../utils/thrift-runtime';
 import * as ColumnOrder from './ColumnOrder';
 import * as KeyValue from './KeyValue';
 import * as RowGroup from './RowGroup';
 import * as SchemaElement from './SchemaElement';
+import * as EncryptionAlgorithm from './EncryptionAlgorithm';
 export interface IFileMetaDataArgs {
   version: number;
   schema: Array<SchemaElement.SchemaElement>;
@@ -24,6 +25,8 @@ export interface IFileMetaDataArgs {
   key_value_metadata?: Array<KeyValue.KeyValue>;
   created_by?: string;
   column_orders?: Array<ColumnOrder.ColumnOrder>;
+  encryption_algorithm?: EncryptionAlgorithm.EncryptionAlgorithm;
+  footer_signing_key_metadata?: Uint8Array;
 }
 export class FileMetaData {
   public version: number;
@@ -33,6 +36,8 @@ export class FileMetaData {
   public key_value_metadata?: Array<KeyValue.KeyValue>;
   public created_by?: string;
   public column_orders?: Array<ColumnOrder.ColumnOrder>;
+  public encryption_algorithm?: EncryptionAlgorithm.EncryptionAlgorithm;
+  public footer_signing_key_metadata?: Uint8Array;
   constructor(args: IFileMetaDataArgs | null = null) {
     if (args != null && args.version != null) {
       this.version = args.version;
@@ -79,6 +84,12 @@ export class FileMetaData {
     if (args != null && args.column_orders != null) {
       this.column_orders = args.column_orders;
     }
+    if (args != null && args.encryption_algorithm != null) {
+      this.encryption_algorithm = args.encryption_algorithm;
+    }
+    if (args != null && args.footer_signing_key_metadata != null) {
+      this.footer_signing_key_metadata = args.footer_signing_key_metadata;
+    }
   }
   public write(output: thrift.TProtocol): void {
     output.writeStructBegin('FileMetaData');
@@ -133,6 +144,16 @@ export class FileMetaData {
       output.writeListEnd();
       output.writeFieldEnd();
     }
+    if (this.encryption_algorithm != null) {
+      output.writeFieldBegin('encryption_algorithm', thrift.Thrift.Type.STRUCT, 8);
+      this.encryption_algorithm.write(output);
+      output.writeFieldEnd();
+    }
+    if (this.footer_signing_key_metadata != null) {
+      output.writeFieldBegin('footer_signing_key_metadata', thrift.Thrift.Type.STRING, 9);
+      output.writeBinary(this.footer_signing_key_metadata);
+      output.writeFieldEnd();
+    }
     output.writeFieldStop();
     output.writeStructEnd();
     return;
@@ -233,6 +254,20 @@ export class FileMetaData {
             input.skip(fieldType);
           }
           break;
+        case 8:
+          if (fieldType === thrift.Thrift.Type.STRUCT) {
+            _args.encryption_algorithm = EncryptionAlgorithm.EncryptionAlgorithm.read(input);
+          } else {
+            input.skip(fieldType);
+          }
+          break;
+        case 9:
+          if (fieldType === thrift.Thrift.Type.STRING) {
+            _args.footer_signing_key_metadata = input.readBinary();
+          } else {
+            input.skip(fieldType);
+          }
+          break;
         default: {
           input.skip(fieldType);
         }

package/src/parquetjs/parquet-thrift/Float16Type.ts

@@ -0,0 +1,28 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+/* tslint:disable */
+/* eslint-disable */
+import * as thrift from '../utils/thrift-runtime';
+
+export interface IFloat16TypeArgs {}
+export class Float16Type {
+  constructor() {}
+  public write(output: thrift.TProtocol): void {
+    output.writeStructBegin('Float16Type');
+    output.writeFieldStop();
+    output.writeStructEnd();
+  }
+  public static read(input: thrift.TProtocol): Float16Type {
+    input.readStructBegin();
+    while (true) {
+      const field = input.readFieldBegin();
+      if (field.ftype === thrift.Thrift.Type.STOP) break;
+      input.skip(field.ftype);
+      input.readFieldEnd();
+    }
+    input.readStructEnd();
+    return new Float16Type();
+  }
+}

package/src/parquetjs/parquet-thrift/GeographyType.ts

@@ -0,0 +1,54 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+/* tslint:disable */
+/* eslint-disable */
+import * as thrift from '../utils/thrift-runtime';
+import type {EdgeInterpolationAlgorithm} from './EdgeInterpolationAlgorithm';
+
+export interface IGeographyTypeArgs {
+  crs?: string;
+  algorithm?: EdgeInterpolationAlgorithm;
+}
+export class GeographyType {
+  public crs?: string;
+  public algorithm?: EdgeInterpolationAlgorithm;
+  constructor(args?: IGeographyTypeArgs) {
+    this.crs = args?.crs;
+    this.algorithm = args?.algorithm;
+  }
+  public write(output: thrift.TProtocol): void {
+    output.writeStructBegin('GeographyType');
+    if (this.crs != null) {
+      output.writeFieldBegin('crs', thrift.Thrift.Type.STRING, 1);
+      output.writeString(this.crs);
+      output.writeFieldEnd();
+    }
+    if (this.algorithm != null) {
+      output.writeFieldBegin('algorithm', thrift.Thrift.Type.I32, 2);
+      output.writeI32(this.algorithm);
+      output.writeFieldEnd();
+    }
+    output.writeFieldStop();
+    output.writeStructEnd();
+  }
+  public static read(input: thrift.TProtocol): GeographyType {
+    const args: IGeographyTypeArgs = {};
+    input.readStructBegin();
+    while (true) {
+      const field = input.readFieldBegin();
+      if (field.ftype === thrift.Thrift.Type.STOP) break;
+      if (field.fid === 1 && field.ftype === thrift.Thrift.Type.STRING) {
+        args.crs = input.readString();
+      } else if (field.fid === 2 && field.ftype === thrift.Thrift.Type.I32) {
+        args.algorithm = input.readI32();
+      } else {
+        input.skip(field.ftype);
+      }
+      input.readFieldEnd();
+    }
+    input.readStructEnd();
+    return new GeographyType(args);
+  }
+}

package/src/parquetjs/parquet-thrift/GeometryType.ts

@@ -0,0 +1,43 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+/* tslint:disable */
+/* eslint-disable */
+import * as thrift from '../utils/thrift-runtime';
+
+export interface IGeometryTypeArgs {
+  crs?: string;
+}
+export class GeometryType {
+  public crs?: string;
+  constructor(args?: IGeometryTypeArgs) {
+    this.crs = args?.crs;
+  }
+  public write(output: thrift.TProtocol): void {
+    output.writeStructBegin('GeometryType');
+    if (this.crs != null) {
+      output.writeFieldBegin('crs', thrift.Thrift.Type.STRING, 1);
+      output.writeString(this.crs);
+      output.writeFieldEnd();
+    }
+    output.writeFieldStop();
+    output.writeStructEnd();
+  }
+  public static read(input: thrift.TProtocol): GeometryType {
+    const args: IGeometryTypeArgs = {};
+    input.readStructBegin();
+    while (true) {
+      const field = input.readFieldBegin();
+      if (field.ftype === thrift.Thrift.Type.STOP) break;
+      if (field.fid === 1 && field.ftype === thrift.Thrift.Type.STRING) {
+        args.crs = input.readString();
+      } else {
+        input.skip(field.ftype);
+      }
+      input.readFieldEnd();
+    }
+    input.readStructEnd();
+    return new GeometryType(args);
+  }
+}

package/src/parquetjs/parquet-thrift/GeospatialStatistics.ts

@@ -0,0 +1,68 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+/* eslint-disable camelcase */
+import * as thrift from '../utils/thrift-runtime';
+import {BoundingBox} from './BoundingBox';
+
+/** Constructor arguments for Parquet geospatial column statistics. */
+export interface IGeospatialStatisticsArgs {
+  bbox?: BoundingBox;
+  geospatial_types?: number[];
+}
+
+/** Parquet geospatial column statistics stored on a column chunk. */
+export class GeospatialStatistics {
+  public bbox?: BoundingBox;
+  public geospatial_types?: number[];
+
+  constructor(args: IGeospatialStatisticsArgs = {}) {
+    this.bbox = args.bbox;
+    this.geospatial_types = args.geospatial_types;
+  }
+
+  /** Writes these geospatial statistics to a Thrift protocol. */
+  public write(output: thrift.TProtocol): void {
+    output.writeStructBegin('GeospatialStatistics');
+    if (this.bbox) {
+      output.writeFieldBegin('bbox', thrift.Thrift.Type.STRUCT, 1);
+      this.bbox.write(output);
+      output.writeFieldEnd();
+    }
+    if (this.geospatial_types) {
+      output.writeFieldBegin('geospatial_types', thrift.Thrift.Type.LIST, 2);
+      output.writeListBegin(thrift.Thrift.Type.I32, this.geospatial_types.length);
+      for (const geospatialType of this.geospatial_types) output.writeI32(geospatialType);
+      output.writeListEnd();
+      output.writeFieldEnd();
+    }
+    output.writeFieldStop();
+    output.writeStructEnd();
+  }
+
+  /** Reads geospatial statistics from a Thrift protocol. */
+  public static read(input: thrift.TProtocol): GeospatialStatistics {
+    input.readStructBegin();
+    const args: IGeospatialStatisticsArgs = {};
+    while (true) {
+      const field = input.readFieldBegin();
+      if (field.ftype === thrift.Thrift.Type.STOP) break;
+      if (field.fid === 1 && field.ftype === thrift.Thrift.Type.STRUCT) {
+        args.bbox = BoundingBox.read(input);
+      } else if (field.fid === 2 && field.ftype === thrift.Thrift.Type.LIST) {
+        const list = input.readListBegin();
+        args.geospatial_types = [];
+        for (let index = 0; index < list.size; index++) {
+          args.geospatial_types.push(input.readI32());
+        }
+        input.readListEnd();
+      } else {
+        input.skip(field.ftype);
+      }
+      input.readFieldEnd();
+    }
+    input.readStructEnd();
+    return new GeospatialStatistics(args);
+  }
+}

package/src/parquetjs/parquet-thrift/IndexPageHeader.ts

@@ -10,7 +10,7 @@
  * Autogenerated by @creditkarma/thrift-typescript v3.7.2
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  */
-import * as thrift from 'thrift';
+import * as thrift from '../utils/thrift-runtime';
 export interface IIndexPageHeaderArgs {}
 export class IndexPageHeader {
   constructor() {}

package/src/parquetjs/parquet-thrift/IntType.ts

@@ -10,7 +10,7 @@
  * Autogenerated by @creditkarma/thrift-typescript v3.7.2
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  */
-import * as thrift from 'thrift';
+import * as thrift from '../utils/thrift-runtime';
 export interface IIntTypeArgs {
   bitWidth: number;
   isSigned: boolean;

package/src/parquetjs/parquet-thrift/JsonType.ts

@@ -10,7 +10,7 @@
  * Autogenerated by @creditkarma/thrift-typescript v3.7.2
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  */
-import * as thrift from 'thrift';
+import * as thrift from '../utils/thrift-runtime';
 export interface IJsonTypeArgs {}
 export class JsonType {
   constructor() {}

package/src/parquetjs/parquet-thrift/KeyValue.ts

@@ -10,7 +10,7 @@
  * Autogenerated by @creditkarma/thrift-typescript v3.7.2
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  */
-import * as thrift from 'thrift';
+import * as thrift from '../utils/thrift-runtime';
 export interface IKeyValueArgs {
   key: string;
   value?: string;

package/src/parquetjs/parquet-thrift/ListType.ts

@@ -10,7 +10,7 @@
  * Autogenerated by @creditkarma/thrift-typescript v3.7.2
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  */
-import * as thrift from 'thrift';
+import * as thrift from '../utils/thrift-runtime';
 export interface IListTypeArgs {}
 export class ListType {
   constructor() {}

package/src/parquetjs/parquet-thrift/LogicalType.ts

@@ -10,11 +10,14 @@
  * Autogenerated by @creditkarma/thrift-typescript v3.7.2
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  */
-import * as thrift from 'thrift';
+import * as thrift from '../utils/thrift-runtime';
 import * as BsonType from './BsonType';
 import * as DateType from './DateType';
 import * as DecimalType from './DecimalType';
 import * as EnumType from './EnumType';
+import * as Float16Type from './Float16Type';
+import * as GeographyType from './GeographyType';
+import * as GeometryType from './GeometryType';
 import * as IntType from './IntType';
 import * as JsonType from './JsonType';
 import * as ListType from './ListType';
@@ -24,6 +27,7 @@ import * as StringType from './StringType';
 import * as TimestampType from './TimestampType';
 import * as TimeType from './TimeType';
 import * as UUIDType from './UUIDType';
+import * as VariantType from './VariantType';
 export interface ILogicalTypeArgs {
   STRING?: StringType.StringType;
   MAP?: MapType.MapType;
@@ -38,6 +42,10 @@ export interface ILogicalTypeArgs {
   JSON?: JsonType.JsonType;
   BSON?: BsonType.BsonType;
   UUID?: UUIDType.UUIDType;
+  FLOAT16?: Float16Type.Float16Type;
+  VARIANT?: VariantType.VariantType;
+  GEOMETRY?: GeometryType.GeometryType;
+  GEOGRAPHY?: GeographyType.GeographyType;
 }
 export class LogicalType {
   public STRING?: StringType.StringType;
@@ -53,6 +61,10 @@ export class LogicalType {
   public JSON?: JsonType.JsonType;
   public BSON?: BsonType.BsonType;
   public UUID?: UUIDType.UUIDType;
+  public FLOAT16?: Float16Type.Float16Type;
+  public VARIANT?: VariantType.VariantType;
+  public GEOMETRY?: GeometryType.GeometryType;
+  public GEOGRAPHY?: GeographyType.GeographyType;
   constructor(args?: ILogicalTypeArgs) {
     let _fieldsSet: number = 0;
     if (args != null) {
@@ -108,6 +120,22 @@ export class LogicalType {
         _fieldsSet++;
         this.UUID = args.UUID;
       }
+      if (args.FLOAT16 != null) {
+        _fieldsSet++;
+        this.FLOAT16 = args.FLOAT16;
+      }
+      if (args.VARIANT != null) {
+        _fieldsSet++;
+        this.VARIANT = args.VARIANT;
+      }
+      if (args.GEOMETRY != null) {
+        _fieldsSet++;
+        this.GEOMETRY = args.GEOMETRY;
+      }
+      if (args.GEOGRAPHY != null) {
+        _fieldsSet++;
+        this.GEOGRAPHY = args.GEOGRAPHY;
+      }
       if (_fieldsSet > 1) {
         throw new thrift.Thrift.TProtocolException(
           thrift.Thrift.TProtocolExceptionType.INVALID_DATA,
@@ -160,6 +188,18 @@ export class LogicalType {
   public static fromUUID(UUID: UUIDType.UUIDType): LogicalType {
     return new LogicalType({UUID});
   }
+  public static fromFLOAT16(FLOAT16: Float16Type.Float16Type): LogicalType {
+    return new LogicalType({FLOAT16});
+  }
+  public static fromVARIANT(VARIANT: VariantType.VariantType): LogicalType {
+    return new LogicalType({VARIANT});
+  }
+  public static fromGEOMETRY(GEOMETRY: GeometryType.GeometryType): LogicalType {
+    return new LogicalType({GEOMETRY});
+  }
+  public static fromGEOGRAPHY(GEOGRAPHY: GeographyType.GeographyType): LogicalType {
+    return new LogicalType({GEOGRAPHY});
+  }
   public write(output: thrift.TProtocol): void {
     output.writeStructBegin('LogicalType');
     if (this.STRING != null) {
@@ -227,6 +267,26 @@ export class LogicalType {
       this.UUID.write(output);
       output.writeFieldEnd();
     }
+    if (this.FLOAT16 != null) {
+      output.writeFieldBegin('FLOAT16', thrift.Thrift.Type.STRUCT, 15);
+      this.FLOAT16.write(output);
+      output.writeFieldEnd();
+    }
+    if (this.VARIANT != null) {
+      output.writeFieldBegin('VARIANT', thrift.Thrift.Type.STRUCT, 16);
+      this.VARIANT.write(output);
+      output.writeFieldEnd();
+    }
+    if (this.GEOMETRY != null) {
+      output.writeFieldBegin('GEOMETRY', thrift.Thrift.Type.STRUCT, 17);
+      this.GEOMETRY.write(output);
+      output.writeFieldEnd();
+    }
+    if (this.GEOGRAPHY != null) {
+      output.writeFieldBegin('GEOGRAPHY', thrift.Thrift.Type.STRUCT, 18);
+      this.GEOGRAPHY.write(output);
+      output.writeFieldEnd();
+    }
     output.writeFieldStop();
     output.writeStructEnd();
     return;
@@ -360,6 +420,42 @@ export class LogicalType {
             input.skip(fieldType);
           }
           break;
+        case 15:
+          if (fieldType === thrift.Thrift.Type.STRUCT) {
+            _fieldsSet++;
+            const value_14: Float16Type.Float16Type = Float16Type.Float16Type.read(input);
+            _returnValue = LogicalType.fromFLOAT16(value_14);
+          } else {
+            input.skip(fieldType);
+          }
+          break;
+        case 16:
+          if (fieldType === thrift.Thrift.Type.STRUCT) {
+            _fieldsSet++;
+            const value_15: VariantType.VariantType = VariantType.VariantType.read(input);
+            _returnValue = LogicalType.fromVARIANT(value_15);
+          } else {
+            input.skip(fieldType);
+          }
+          break;
+        case 17:
+          if (fieldType === thrift.Thrift.Type.STRUCT) {
+            _fieldsSet++;
+            const value_16: GeometryType.GeometryType = GeometryType.GeometryType.read(input);
+            _returnValue = LogicalType.fromGEOMETRY(value_16);
+          } else {
+            input.skip(fieldType);
+          }
+          break;
+        case 18:
+          if (fieldType === thrift.Thrift.Type.STRUCT) {
+            _fieldsSet++;
+            const value_17: GeographyType.GeographyType = GeographyType.GeographyType.read(input);
+            _returnValue = LogicalType.fromGEOGRAPHY(value_17);
+          } else {
+            input.skip(fieldType);
+          }
+          break;
         default: {
           input.skip(fieldType);
         }