Allow exporting .parquet files without geometry

Author: mbloch

src/geoparquet/mapshaper-geoparquet-export.mjs

@@ -2,7 +2,7 @@ import { exportLayerAsGeoJSON } from '../geojson/geojson-export';
 import { parseCrsString, parsePrj } from '../crs/mapshaper-projections';
 import { runningInBrowser } from '../mapshaper-env';
 import { getFileExtension } from '../utils/mapshaper-filename-utils';
-import { stop } from '../utils/mapshaper-logging';
+import { stop, warn } from '../utils/mapshaper-logging';
 import utils from '../utils/mapshaper-utils';
 import require from '../mapshaper-require';
 
@@ -19,22 +19,26 @@ export async function exportGeoParquet(dataset, opts, filenameOverride) {
     extension = getFileExtension(opts.file) || extension;
   }
   dataset.layers.forEach(function(lyr) {
-    if (!lyr.geometry_type) {
-      stop('GeoParquet export requires a geometry layer');
-    }
     var features = exportLayerAsGeoJSON(lyr, dataset, opts, true, null);
-    var output = buildGeoParquetColumns(features, writer);
-    var geoMetadata = buildGeoMetadata(features, dataset);
-    var content = writer.parquetWriteBuffer({
+    var hasGeometry = features.some(function(feat) {
+      return !!feat.geometry;
+    });
+    var output = buildGeoParquetColumns(features, hasGeometry);
+    var writeOptions = {
       columnData: output.columnData,
       codec: compression.codec,
       compressors: compression.compressors,
-      pageSize: compression.pageSize,
-      kvMetadata: [{
+      pageSize: compression.pageSize
+    };
+    if (hasGeometry) {
+      writeOptions.kvMetadata = [{
         key: 'geo',
-        value: JSON.stringify(geoMetadata)
-      }]
-    });
+        value: JSON.stringify(buildGeoMetadata(features, dataset))
+      }];
+    } else {
+      warn('GeoParquet export: layer has no geometry; writing attribute data only.');
+    }
+    var content = writer.parquetWriteBuffer(writeOptions);
     files.push({
       filename: filenameOverride || (lyr.name + '.' + extension),
       content: content
@@ -43,23 +47,31 @@ export async function exportGeoParquet(dataset, opts, filenameOverride) {
   return files;
 }
 
-function buildGeoParquetColumns(features, writer) {
+function buildGeoParquetColumns(features, includeGeometry) {
   var geometryName = 'geometry';
   var names = getPropertyNames(features);
   var columnData = [];
-  columnData.push({
-    name: geometryName,
-    data: features.map(function(feat) {
-      return feat.geometry || null;
-    }),
-    type: 'GEOMETRY'
-  });
+  if (features.length === 0) {
+    stop('GeoParquet export requires at least one record');
+  }
+  if (includeGeometry) {
+    columnData.push({
+      name: geometryName,
+      data: features.map(function(feat) {
+        return feat.geometry || null;
+      }),
+      type: 'GEOMETRY'
+    });
+  }
   names.forEach(function(name) {
     var values = features.map(function(feat) {
       return feat.properties ? feat.properties[name] : null;
     });
     columnData.push(buildAttributeColumn(name, values));
   });
+  if (columnData.length === 0) {
+    stop('GeoParquet export requires geometry or attribute data');
+  }
   return {columnData: columnData, geometryColumn: geometryName};
 }
 

test/geoparquet-export-test.mjs

@@ -1,7 +1,7 @@
 import api from '../mapshaper.js';
 import assert from 'assert';
 import { parquetMetadataAsync } from 'hyparquet';
-import { fixPath } from './helpers';
+import { fixPath, captureLogCallsAsync } from './helpers';
 
 describe('geoparquet export', function() {
   it('exports GeoParquet and round-trips via async import', async function() {
@@ -52,6 +52,74 @@ describe('geoparquet export', function() {
     assert(/\.parquet$/i.test(names[0]));
   });
 
+  it('exports tabular layers as Parquet without a geometry column', async function() {
+    var input = [{
+      name: 'alpha',
+      value: 3
+    }, {
+      name: 'beta',
+      value: 7
+    }];
+    var out = await captureLogCallsAsync(function() {
+      return api.applyCommands('-i in.json -o format=geoparquet', {'in.json': input});
+    });
+    var output = out.result;
+    var fileName = Object.keys(output)[0];
+    var metadata = await parquetMetadataAsync(toArrayBuffer(output[fileName]));
+    var fields = getParquetFieldNames(metadata);
+    assert(!fields.includes('geometry'));
+    assert(/writing attribute data only/.test(out.log.join('\n')));
+
+    var dataset = await api.internal.importContentAsync({
+      parquet: {
+        filename: fileName,
+        content: output[fileName]
+      }
+    }, {});
+    assert.equal(dataset.layers[0].geometry_type, null);
+    assert.deepEqual(dataset.layers[0].data.getRecords(), input);
+  });
+
+  it('exports null-geometry features with attributes as Parquet tables', async function() {
+    var input = {
+      type: 'FeatureCollection',
+      features: [{
+        type: 'Feature',
+        properties: {name: 'alpha'},
+        geometry: null
+      }]
+    };
+    var out = await captureLogCallsAsync(function() {
+      return api.applyCommands('-i in.json -o format=geoparquet', {'in.json': input});
+    });
+    var output = out.result;
+    var fileName = Object.keys(output)[0];
+    var metadata = await parquetMetadataAsync(toArrayBuffer(output[fileName]));
+    assert(!getParquetFieldNames(metadata).includes('geometry'));
+    assert(/writing attribute data only/.test(out.log.join('\n')));
+  });
+
+  it('rejects empty GeoParquet output layers', async function() {
+    var emptyInput = {
+      type: 'FeatureCollection',
+      features: []
+    };
+    var nullOnlyInput = {
+      type: 'FeatureCollection',
+      features: [{
+        type: 'Feature',
+        properties: null,
+        geometry: null
+      }]
+    };
+    await assert.rejects(function() {
+      return api.applyCommands('-i in.json -o format=geoparquet', {'in.json': emptyInput});
+    }, /requires at least one record/);
+    await assert.rejects(function() {
+      return api.applyCommands('-i in.json -o format=geoparquet', {'in.json': nullOnlyInput});
+    }, /requires at least one record|requires geometry or attribute data/);
+  });
+
   it('exports ZSTD-compressed GeoParquet when requested', async function() {
     var text = 'abcdefghijklmnopqrstuvwxyz'.repeat(40);
     var input = {
@@ -137,6 +205,12 @@ function getParquetCodecs(metadata) {
   return Object.keys(index).sort();
 }
 
+function getParquetFieldNames(metadata) {
+  return metadata.schema.map(function(field) {
+    return field.name;
+  });
+}
+
 function toArrayBuffer(content) {
   if (content instanceof ArrayBuffer) return content;
   if (content instanceof Uint8Array) {