@loaders.gl/parquet 3.0.13 → 3.0.14

package/dist/es5/parquetjs/reader.js

@@ -2,11 +2,21 @@
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 
+var _typeof = require("@babel/runtime/helpers/typeof");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.ParquetEnvelopeReader = exports.ParquetReader = exports.ParquetCursor = void 0;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
 var _codecs = require("./codecs");
@@ -21,20 +31,27 @@ var _parquetThrift = require("./parquet-thrift");
 
 var Util = _interopRequireWildcard(require("./util"));
 
-let _Symbol$asyncIterator, _Symbol$asyncIterator2;
+var _Symbol$asyncIterator, _Symbol$asyncIterator2;
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
 
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 
-const PARQUET_MAGIC = 'PAR1';
-const PARQUET_VERSION = 1;
-const PARQUET_RDLVL_TYPE = 'INT32';
-const PARQUET_RDLVL_ENCODING = 'RLE';
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+var PARQUET_MAGIC = 'PAR1';
+var PARQUET_VERSION = 1;
+var PARQUET_RDLVL_TYPE = 'INT32';
+var PARQUET_RDLVL_ENCODING = 'RLE';
 _Symbol$asyncIterator = Symbol.asyncIterator;
 
-class ParquetCursor {
-  constructor(metadata, envelopeReader, schema, columnList) {
+var ParquetCursor = function () {
+  function ParquetCursor(metadata, envelopeReader, schema, columnList) {
+    (0, _classCallCheck2.default)(this, ParquetCursor);
     (0, _defineProperty2.default)(this, "metadata", void 0);
     (0, _defineProperty2.default)(this, "envelopeReader", void 0);
     (0, _defineProperty2.default)(this, "schema", void 0);
@@ -49,118 +66,184 @@ class ParquetCursor {
     this.rowGroupIndex = 0;
   }
 
-  async next() {
-    if (this.rowGroup.length === 0) {
-      if (this.rowGroupIndex >= this.metadata.row_groups.length) {
-        return null;
+  (0, _createClass2.default)(ParquetCursor, [{
+    key: "next",
+    value: function () {
+      var _next = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee() {
+        var rowBuffer;
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                if (!(this.rowGroup.length === 0)) {
+                  _context.next = 8;
+                  break;
+                }
+
+                if (!(this.rowGroupIndex >= this.metadata.row_groups.length)) {
+                  _context.next = 3;
+                  break;
+                }
+
+                return _context.abrupt("return", null);
+
+              case 3:
+                _context.next = 5;
+                return this.envelopeReader.readRowGroup(this.schema, this.metadata.row_groups[this.rowGroupIndex], this.columnList);
+
+              case 5:
+                rowBuffer = _context.sent;
+                this.rowGroup = Shred.materializeRecords(this.schema, rowBuffer);
+                this.rowGroupIndex++;
+
+              case 8:
+                return _context.abrupt("return", this.rowGroup.shift());
+
+              case 9:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function next() {
+        return _next.apply(this, arguments);
       }
 
-      const rowBuffer = await this.envelopeReader.readRowGroup(this.schema, this.metadata.row_groups[this.rowGroupIndex], this.columnList);
-      this.rowGroup = Shred.materializeRecords(this.schema, rowBuffer);
-      this.rowGroupIndex++;
+      return next;
+    }()
+  }, {
+    key: "rewind",
+    value: function rewind() {
+      this.rowGroup = [];
+      this.rowGroupIndex = 0;
     }
-
-    return this.rowGroup.shift();
-  }
-
-  rewind() {
-    this.rowGroup = [];
-    this.rowGroupIndex = 0;
-  }
-
-  [_Symbol$asyncIterator]() {
-    let done = false;
-    return {
-      next: async () => {
-        if (done) {
-          return {
-            done,
-            value: null
-          };
-        }
-
-        const value = await this.next();
-
-        if (value === null) {
-          return {
-            done: true,
-            value
-          };
-        }
-
-        return {
-          done: false,
-          value
-        };
-      },
-      return: async () => {
-        done = true;
-        return {
-          done,
-          value: null
-        };
-      },
-      throw: async () => {
-        done = true;
-        return {
-          done: true,
-          value: null
-        };
-      }
-    };
-  }
-
-}
+  }, {
+    key: _Symbol$asyncIterator,
+    value: function value() {
+      var _this = this;
+
+      var done = false;
+      return {
+        next: function () {
+          var _next2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee2() {
+            var value;
+            return _regenerator.default.wrap(function _callee2$(_context2) {
+              while (1) {
+                switch (_context2.prev = _context2.next) {
+                  case 0:
+                    if (!done) {
+                      _context2.next = 2;
+                      break;
+                    }
+
+                    return _context2.abrupt("return", {
+                      done: done,
+                      value: null
+                    });
+
+                  case 2:
+                    _context2.next = 4;
+                    return _this.next();
+
+                  case 4:
+                    value = _context2.sent;
+
+                    if (!(value === null)) {
+                      _context2.next = 7;
+                      break;
+                    }
+
+                    return _context2.abrupt("return", {
+                      done: true,
+                      value: value
+                    });
+
+                  case 7:
+                    return _context2.abrupt("return", {
+                      done: false,
+                      value: value
+                    });
+
+                  case 8:
+                  case "end":
+                    return _context2.stop();
+                }
+              }
+            }, _callee2);
+          }));
+
+          function next() {
+            return _next2.apply(this, arguments);
+          }
+
+          return next;
+        }(),
+        return: function () {
+          var _return2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee3() {
+            return _regenerator.default.wrap(function _callee3$(_context3) {
+              while (1) {
+                switch (_context3.prev = _context3.next) {
+                  case 0:
+                    done = true;
+                    return _context3.abrupt("return", {
+                      done: done,
+                      value: null
+                    });
+
+                  case 2:
+                  case "end":
+                    return _context3.stop();
+                }
+              }
+            }, _callee3);
+          }));
+
+          function _return() {
+            return _return2.apply(this, arguments);
+          }
+
+          return _return;
+        }(),
+        throw: function () {
+          var _throw2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee4() {
+            return _regenerator.default.wrap(function _callee4$(_context4) {
+              while (1) {
+                switch (_context4.prev = _context4.next) {
+                  case 0:
+                    done = true;
+                    return _context4.abrupt("return", {
+                      done: true,
+                      value: null
+                    });
+
+                  case 2:
+                  case "end":
+                    return _context4.stop();
+                }
+              }
+            }, _callee4);
+          }));
+
+          function _throw() {
+            return _throw2.apply(this, arguments);
+          }
+
+          return _throw;
+        }()
+      };
+    }
+  }]);
+  return ParquetCursor;
+}();
 
 exports.ParquetCursor = ParquetCursor;
 _Symbol$asyncIterator2 = Symbol.asyncIterator;
 
-class ParquetReader {
-  static async openFile(filePath) {
-    const envelopeReader = await ParquetEnvelopeReader.openFile(filePath);
-
-    try {
-      await envelopeReader.readHeader();
-      const metadata = await envelopeReader.readFooter();
-      return new ParquetReader(metadata, envelopeReader);
-    } catch (err) {
-      await envelopeReader.close();
-      throw err;
-    }
-  }
-
-  static async openBuffer(buffer) {
-    const envelopeReader = await ParquetEnvelopeReader.openBuffer(buffer);
-
-    try {
-      await envelopeReader.readHeader();
-      const metadata = await envelopeReader.readFooter();
-      return new ParquetReader(metadata, envelopeReader);
-    } catch (err) {
-      await envelopeReader.close();
-      throw err;
-    }
-  }
-
-  static async openArrayBuffer(arrayBuffer) {
-    const readFn = async (start, length) => Buffer.from(arrayBuffer, start, length);
-
-    const closeFn = async () => {};
-
-    const size = arrayBuffer.byteLength;
-    const envelopeReader = new ParquetEnvelopeReader(readFn, closeFn, size);
-
-    try {
-      await envelopeReader.readHeader();
-      const metadata = await envelopeReader.readFooter();
-      return new ParquetReader(metadata, envelopeReader);
-    } catch (err) {
-      await envelopeReader.close();
-      throw err;
-    }
-  }
-
-  constructor(metadata, envelopeReader) {
+var ParquetReader = function () {
+  function ParquetReader(metadata, envelopeReader) {
+    (0, _classCallCheck2.default)(this, ParquetReader);
     (0, _defineProperty2.default)(this, "metadata", void 0);
     (0, _defineProperty2.default)(this, "envelopeReader", void 0);
     (0, _defineProperty2.default)(this, "schema", void 0);
@@ -171,70 +254,279 @@ class ParquetReader {
 
     this.metadata = metadata;
     this.envelopeReader = envelopeReader;
-    const root = this.metadata.schema[0];
-    const {
-      schema
-    } = decodeSchema(this.metadata.schema, 1, root.num_children);
-    this.schema = new _schema.ParquetSchema(schema);
-  }
-
-  async close() {
-    await this.envelopeReader.close();
-  }
+    var root = this.metadata.schema[0];
 
-  getCursor(columnList) {
-    if (!columnList) {
-      columnList = [];
-    }
+    var _decodeSchema = decodeSchema(this.metadata.schema, 1, root.num_children),
+        schema = _decodeSchema.schema;
 
-    columnList = columnList.map(x => Array.isArray(x) ? x : [x]);
-    return new ParquetCursor(this.metadata, this.envelopeReader, this.schema, columnList);
+    this.schema = new _schema.ParquetSchema(schema);
   }
 
-  getRowCount() {
-    return Number(this.metadata.num_rows);
-  }
+  (0, _createClass2.default)(ParquetReader, [{
+    key: "close",
+    value: function () {
+      var _close = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee5() {
+        return _regenerator.default.wrap(function _callee5$(_context5) {
+          while (1) {
+            switch (_context5.prev = _context5.next) {
+              case 0:
+                _context5.next = 2;
+                return this.envelopeReader.close();
+
+              case 2:
+              case "end":
+                return _context5.stop();
+            }
+          }
+        }, _callee5, this);
+      }));
+
+      function close() {
+        return _close.apply(this, arguments);
+      }
 
-  getSchema() {
-    return this.schema;
-  }
+      return close;
+    }()
+  }, {
+    key: "getCursor",
+    value: function getCursor(columnList) {
+      if (!columnList) {
+        columnList = [];
+      }
 
-  getMetadata() {
-    const md = {};
+      columnList = columnList.map(function (x) {
+        return Array.isArray(x) ? x : [x];
+      });
+      return new ParquetCursor(this.metadata, this.envelopeReader, this.schema, columnList);
+    }
+  }, {
+    key: "getRowCount",
+    value: function getRowCount() {
+      return Number(this.metadata.num_rows);
+    }
+  }, {
+    key: "getSchema",
+    value: function getSchema() {
+      return this.schema;
+    }
+  }, {
+    key: "getMetadata",
+    value: function getMetadata() {
+      var md = {};
+
+      var _iterator = _createForOfIteratorHelper(this.metadata.key_value_metadata),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var kv = _step.value;
+          md[kv.key] = kv.value;
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
 
-    for (const kv of this.metadata.key_value_metadata) {
-      md[kv.key] = kv.value;
+      return md;
     }
+  }, {
+    key: _Symbol$asyncIterator2,
+    value: function value() {
+      return this.getCursor()[Symbol.asyncIterator]();
+    }
+  }], [{
+    key: "openFile",
+    value: function () {
+      var _openFile = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee6(filePath) {
+        var envelopeReader, metadata;
+        return _regenerator.default.wrap(function _callee6$(_context6) {
+          while (1) {
+            switch (_context6.prev = _context6.next) {
+              case 0:
+                _context6.next = 2;
+                return ParquetEnvelopeReader.openFile(filePath);
+
+              case 2:
+                envelopeReader = _context6.sent;
+                _context6.prev = 3;
+                _context6.next = 6;
+                return envelopeReader.readHeader();
+
+              case 6:
+                _context6.next = 8;
+                return envelopeReader.readFooter();
+
+              case 8:
+                metadata = _context6.sent;
+                return _context6.abrupt("return", new ParquetReader(metadata, envelopeReader));
+
+              case 12:
+                _context6.prev = 12;
+                _context6.t0 = _context6["catch"](3);
+                _context6.next = 16;
+                return envelopeReader.close();
+
+              case 16:
+                throw _context6.t0;
+
+              case 17:
+              case "end":
+                return _context6.stop();
+            }
+          }
+        }, _callee6, null, [[3, 12]]);
+      }));
+
+      function openFile(_x) {
+        return _openFile.apply(this, arguments);
+      }
 
-    return md;
-  }
+      return openFile;
+    }()
+  }, {
+    key: "openBuffer",
+    value: function () {
+      var _openBuffer = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee7(buffer) {
+        var envelopeReader, metadata;
+        return _regenerator.default.wrap(function _callee7$(_context7) {
+          while (1) {
+            switch (_context7.prev = _context7.next) {
+              case 0:
+                _context7.next = 2;
+                return ParquetEnvelopeReader.openBuffer(buffer);
+
+              case 2:
+                envelopeReader = _context7.sent;
+                _context7.prev = 3;
+                _context7.next = 6;
+                return envelopeReader.readHeader();
+
+              case 6:
+                _context7.next = 8;
+                return envelopeReader.readFooter();
+
+              case 8:
+                metadata = _context7.sent;
+                return _context7.abrupt("return", new ParquetReader(metadata, envelopeReader));
+
+              case 12:
+                _context7.prev = 12;
+                _context7.t0 = _context7["catch"](3);
+                _context7.next = 16;
+                return envelopeReader.close();
+
+              case 16:
+                throw _context7.t0;
+
+              case 17:
+              case "end":
+                return _context7.stop();
+            }
+          }
+        }, _callee7, null, [[3, 12]]);
+      }));
+
+      function openBuffer(_x2) {
+        return _openBuffer.apply(this, arguments);
+      }
 
-  [_Symbol$asyncIterator2]() {
-    return this.getCursor()[Symbol.asyncIterator]();
-  }
+      return openBuffer;
+    }()
+  }, {
+    key: "openArrayBuffer",
+    value: function () {
+      var _openArrayBuffer = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee10(arrayBuffer) {
+        var readFn, closeFn, size, envelopeReader, metadata;
+        return _regenerator.default.wrap(function _callee10$(_context10) {
+          while (1) {
+            switch (_context10.prev = _context10.next) {
+              case 0:
+                readFn = function () {
+                  var _ref = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee8(start, length) {
+                    return _regenerator.default.wrap(function _callee8$(_context8) {
+                      while (1) {
+                        switch (_context8.prev = _context8.next) {
+                          case 0:
+                            return _context8.abrupt("return", Buffer.from(arrayBuffer, start, length));
+
+                          case 1:
+                          case "end":
+                            return _context8.stop();
+                        }
+                      }
+                    }, _callee8);
+                  }));
+
+                  return function readFn(_x4, _x5) {
+                    return _ref.apply(this, arguments);
+                  };
+                }();
+
+                closeFn = function () {
+                  var _ref2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee9() {
+                    return _regenerator.default.wrap(function _callee9$(_context9) {
+                      while (1) {
+                        switch (_context9.prev = _context9.next) {
+                          case 0:
+                          case "end":
+                            return _context9.stop();
+                        }
+                      }
+                    }, _callee9);
+                  }));
+
+                  return function closeFn() {
+                    return _ref2.apply(this, arguments);
+                  };
+                }();
+
+                size = arrayBuffer.byteLength;
+                envelopeReader = new ParquetEnvelopeReader(readFn, closeFn, size);
+                _context10.prev = 4;
+                _context10.next = 7;
+                return envelopeReader.readHeader();
+
+              case 7:
+                _context10.next = 9;
+                return envelopeReader.readFooter();
+
+              case 9:
+                metadata = _context10.sent;
+                return _context10.abrupt("return", new ParquetReader(metadata, envelopeReader));
+
+              case 13:
+                _context10.prev = 13;
+                _context10.t0 = _context10["catch"](4);
+                _context10.next = 17;
+                return envelopeReader.close();
+
+              case 17:
+                throw _context10.t0;
+
+              case 18:
+              case "end":
+                return _context10.stop();
+            }
+          }
+        }, _callee10, null, [[4, 13]]);
+      }));
+
+      function openArrayBuffer(_x3) {
+        return _openArrayBuffer.apply(this, arguments);
+      }
 
-}
+      return openArrayBuffer;
+    }()
+  }]);
+  return ParquetReader;
+}();
 
 exports.ParquetReader = ParquetReader;
 
-class ParquetEnvelopeReader {
-  static async openFile(filePath) {
-    const fileStat = await Util.fstat(filePath);
-    const fileDescriptor = await Util.fopen(filePath);
-    const readFn = Util.fread.bind(undefined, fileDescriptor);
-    const closeFn = Util.fclose.bind(undefined, fileDescriptor);
-    return new ParquetEnvelopeReader(readFn, closeFn, fileStat.size);
-  }
-
-  static async openBuffer(buffer) {
-    const readFn = (position, length) => Promise.resolve(buffer.slice(position, position + length));
-
-    const closeFn = () => Promise.resolve();
-
-    return new ParquetEnvelopeReader(readFn, closeFn, buffer.length);
-  }
-
-  constructor(read, close, fileSize) {
+var ParquetEnvelopeReader = function () {
+  function ParquetEnvelopeReader(read, close, fileSize) {
+    (0, _classCallCheck2.default)(this, ParquetEnvelopeReader);
     (0, _defineProperty2.default)(this, "read", void 0);
     (0, _defineProperty2.default)(this, "close", void 0);
     (0, _defineProperty2.default)(this, "fileSize", void 0);
@@ -243,74 +535,308 @@ class ParquetEnvelopeReader {
     this.fileSize = fileSize;
   }
 
-  async readHeader() {
-    const buf = await this.read(0, PARQUET_MAGIC.length);
-
-    if (buf.toString() !== PARQUET_MAGIC) {
-      throw new Error('not valid parquet file');
-    }
-  }
-
-  async readRowGroup(schema, rowGroup, columnList) {
-    const buffer = {
-      rowCount: Number(rowGroup.num_rows),
-      columnData: {}
-    };
-
-    for (const colChunk of rowGroup.columns) {
-      const colMetadata = colChunk.meta_data;
-      const colKey = colMetadata === null || colMetadata === void 0 ? void 0 : colMetadata.path_in_schema;
-
-      if (columnList.length > 0 && Util.fieldIndexOf(columnList, colKey) < 0) {
-        continue;
+  (0, _createClass2.default)(ParquetEnvelopeReader, [{
+    key: "readHeader",
+    value: function () {
+      var _readHeader = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee11() {
+        var buf;
+        return _regenerator.default.wrap(function _callee11$(_context11) {
+          while (1) {
+            switch (_context11.prev = _context11.next) {
+              case 0:
+                _context11.next = 2;
+                return this.read(0, PARQUET_MAGIC.length);
+
+              case 2:
+                buf = _context11.sent;
+
+                if (!(buf.toString() !== PARQUET_MAGIC)) {
+                  _context11.next = 5;
+                  break;
+                }
+
+                throw new Error('not valid parquet file');
+
+              case 5:
+              case "end":
+                return _context11.stop();
+            }
+          }
+        }, _callee11, this);
+      }));
+
+      function readHeader() {
+        return _readHeader.apply(this, arguments);
       }
 
-      buffer.columnData[colKey.join()] = await this.readColumnChunk(schema, colChunk);
-    }
-
-    return buffer;
-  }
-
-  async readColumnChunk(schema, colChunk) {
-    var _colChunk$meta_data, _colChunk$meta_data2, _colChunk$meta_data3, _colChunk$meta_data4, _colChunk$meta_data5;
-
-    if (colChunk.file_path !== undefined && colChunk.file_path !== null) {
-      throw new Error('external references are not supported');
-    }
-
-    const field = schema.findField((_colChunk$meta_data = colChunk.meta_data) === null || _colChunk$meta_data === void 0 ? void 0 : _colChunk$meta_data.path_in_schema);
-    const type = Util.getThriftEnum(_parquetThrift.Type, (_colChunk$meta_data2 = colChunk.meta_data) === null || _colChunk$meta_data2 === void 0 ? void 0 : _colChunk$meta_data2.type);
-    if (type !== field.primitiveType) throw new Error("chunk type not matching schema: ".concat(type));
-    const compression = Util.getThriftEnum(_parquetThrift.CompressionCodec, (_colChunk$meta_data3 = colChunk.meta_data) === null || _colChunk$meta_data3 === void 0 ? void 0 : _colChunk$meta_data3.codec);
-    const pagesOffset = Number((_colChunk$meta_data4 = colChunk.meta_data) === null || _colChunk$meta_data4 === void 0 ? void 0 : _colChunk$meta_data4.data_page_offset);
-    const pagesSize = Number((_colChunk$meta_data5 = colChunk.meta_data) === null || _colChunk$meta_data5 === void 0 ? void 0 : _colChunk$meta_data5.total_compressed_size);
-    const pagesBuf = await this.read(pagesOffset, pagesSize);
-    return decodeDataPages(pagesBuf, field, compression);
-  }
-
-  async readFooter() {
-    const trailerLen = PARQUET_MAGIC.length + 4;
-    const trailerBuf = await this.read(this.fileSize - trailerLen, trailerLen);
+      return readHeader;
+    }()
+  }, {
+    key: "readRowGroup",
+    value: function () {
+      var _readRowGroup = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee12(schema, rowGroup, columnList) {
+        var buffer, _iterator2, _step2, colChunk, colMetadata, colKey;
+
+        return _regenerator.default.wrap(function _callee12$(_context12) {
+          while (1) {
+            switch (_context12.prev = _context12.next) {
+              case 0:
+                buffer = {
+                  rowCount: Number(rowGroup.num_rows),
+                  columnData: {}
+                };
+                _iterator2 = _createForOfIteratorHelper(rowGroup.columns);
+                _context12.prev = 2;
+
+                _iterator2.s();
+
+              case 4:
+                if ((_step2 = _iterator2.n()).done) {
+                  _context12.next = 15;
+                  break;
+                }
+
+                colChunk = _step2.value;
+                colMetadata = colChunk.meta_data;
+                colKey = colMetadata === null || colMetadata === void 0 ? void 0 : colMetadata.path_in_schema;
+
+                if (!(columnList.length > 0 && Util.fieldIndexOf(columnList, colKey) < 0)) {
+                  _context12.next = 10;
+                  break;
+                }
+
+                return _context12.abrupt("continue", 13);
+
+              case 10:
+                _context12.next = 12;
+                return this.readColumnChunk(schema, colChunk);
+
+              case 12:
+                buffer.columnData[colKey.join()] = _context12.sent;
+
+              case 13:
+                _context12.next = 4;
+                break;
+
+              case 15:
+                _context12.next = 20;
+                break;
+
+              case 17:
+                _context12.prev = 17;
+                _context12.t0 = _context12["catch"](2);
+
+                _iterator2.e(_context12.t0);
+
+              case 20:
+                _context12.prev = 20;
+
+                _iterator2.f();
+
+                return _context12.finish(20);
+
+              case 23:
+                return _context12.abrupt("return", buffer);
+
+              case 24:
+              case "end":
+                return _context12.stop();
+            }
+          }
+        }, _callee12, this, [[2, 17, 20, 23]]);
+      }));
+
+      function readRowGroup(_x6, _x7, _x8) {
+        return _readRowGroup.apply(this, arguments);
+      }
 
-    if (trailerBuf.slice(4).toString() !== PARQUET_MAGIC) {
-      throw new Error('not a valid parquet file');
-    }
+      return readRowGroup;
+    }()
+  }, {
+    key: "readColumnChunk",
+    value: function () {
+      var _readColumnChunk = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee13(schema, colChunk) {
+        var _colChunk$meta_data, _colChunk$meta_data2, _colChunk$meta_data3, _colChunk$meta_data4, _colChunk$meta_data5;
+
+        var field, type, compression, pagesOffset, pagesSize, pagesBuf;
+        return _regenerator.default.wrap(function _callee13$(_context13) {
+          while (1) {
+            switch (_context13.prev = _context13.next) {
+              case 0:
+                if (!(colChunk.file_path !== undefined && colChunk.file_path !== null)) {
+                  _context13.next = 2;
+                  break;
+                }
+
+                throw new Error('external references are not supported');
+
+              case 2:
+                field = schema.findField((_colChunk$meta_data = colChunk.meta_data) === null || _colChunk$meta_data === void 0 ? void 0 : _colChunk$meta_data.path_in_schema);
+                type = Util.getThriftEnum(_parquetThrift.Type, (_colChunk$meta_data2 = colChunk.meta_data) === null || _colChunk$meta_data2 === void 0 ? void 0 : _colChunk$meta_data2.type);
+
+                if (!(type !== field.primitiveType)) {
+                  _context13.next = 6;
+                  break;
+                }
+
+                throw new Error("chunk type not matching schema: ".concat(type));
+
+              case 6:
+                compression = Util.getThriftEnum(_parquetThrift.CompressionCodec, (_colChunk$meta_data3 = colChunk.meta_data) === null || _colChunk$meta_data3 === void 0 ? void 0 : _colChunk$meta_data3.codec);
+                pagesOffset = Number((_colChunk$meta_data4 = colChunk.meta_data) === null || _colChunk$meta_data4 === void 0 ? void 0 : _colChunk$meta_data4.data_page_offset);
+                pagesSize = Number((_colChunk$meta_data5 = colChunk.meta_data) === null || _colChunk$meta_data5 === void 0 ? void 0 : _colChunk$meta_data5.total_compressed_size);
+                _context13.next = 11;
+                return this.read(pagesOffset, pagesSize);
+
+              case 11:
+                pagesBuf = _context13.sent;
+                return _context13.abrupt("return", decodeDataPages(pagesBuf, field, compression));
+
+              case 13:
+              case "end":
+                return _context13.stop();
+            }
+          }
+        }, _callee13, this);
+      }));
+
+      function readColumnChunk(_x9, _x10) {
+        return _readColumnChunk.apply(this, arguments);
+      }
 
-    const metadataSize = trailerBuf.readUInt32LE(0);
-    const metadataOffset = this.fileSize - metadataSize - trailerLen;
+      return readColumnChunk;
+    }()
+  }, {
+    key: "readFooter",
+    value: function () {
+      var _readFooter = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee14() {
+        var trailerLen, trailerBuf, metadataSize, metadataOffset, metadataBuf, _Util$decodeFileMetad, metadata;
+
+        return _regenerator.default.wrap(function _callee14$(_context14) {
+          while (1) {
+            switch (_context14.prev = _context14.next) {
+              case 0:
+                trailerLen = PARQUET_MAGIC.length + 4;
+                _context14.next = 3;
+                return this.read(this.fileSize - trailerLen, trailerLen);
+
+              case 3:
+                trailerBuf = _context14.sent;
+
+                if (!(trailerBuf.slice(4).toString() !== PARQUET_MAGIC)) {
+                  _context14.next = 6;
+                  break;
+                }
+
+                throw new Error('not a valid parquet file');
+
+              case 6:
+                metadataSize = trailerBuf.readUInt32LE(0);
+                metadataOffset = this.fileSize - metadataSize - trailerLen;
+
+                if (!(metadataOffset < PARQUET_MAGIC.length)) {
+                  _context14.next = 10;
+                  break;
+                }
+
+                throw new Error('invalid metadata size');
+
+              case 10:
+                _context14.next = 12;
+                return this.read(metadataOffset, metadataSize);
+
+              case 12:
+                metadataBuf = _context14.sent;
+                _Util$decodeFileMetad = Util.decodeFileMetadata(metadataBuf), metadata = _Util$decodeFileMetad.metadata;
+                return _context14.abrupt("return", metadata);
+
+              case 15:
+              case "end":
+                return _context14.stop();
+            }
+          }
+        }, _callee14, this);
+      }));
+
+      function readFooter() {
+        return _readFooter.apply(this, arguments);
+      }
 
-    if (metadataOffset < PARQUET_MAGIC.length) {
-      throw new Error('invalid metadata size');
-    }
+      return readFooter;
+    }()
+  }], [{
+    key: "openFile",
+    value: function () {
+      var _openFile2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee15(filePath) {
+        var fileStat, fileDescriptor, readFn, closeFn;
+        return _regenerator.default.wrap(function _callee15$(_context15) {
+          while (1) {
+            switch (_context15.prev = _context15.next) {
+              case 0:
+                _context15.next = 2;
+                return Util.fstat(filePath);
+
+              case 2:
+                fileStat = _context15.sent;
+                _context15.next = 5;
+                return Util.fopen(filePath);
+
+              case 5:
+                fileDescriptor = _context15.sent;
+                readFn = Util.fread.bind(undefined, fileDescriptor);
+                closeFn = Util.fclose.bind(undefined, fileDescriptor);
+                return _context15.abrupt("return", new ParquetEnvelopeReader(readFn, closeFn, fileStat.size));
+
+              case 9:
+              case "end":
+                return _context15.stop();
+            }
+          }
+        }, _callee15);
+      }));
+
+      function openFile(_x11) {
+        return _openFile2.apply(this, arguments);
+      }
 
-    const metadataBuf = await this.read(metadataOffset, metadataSize);
-    const {
-      metadata
-    } = Util.decodeFileMetadata(metadataBuf);
-    return metadata;
-  }
+      return openFile;
+    }()
+  }, {
+    key: "openBuffer",
+    value: function () {
+      var _openBuffer2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee16(buffer) {
+        var readFn, closeFn;
+        return _regenerator.default.wrap(function _callee16$(_context16) {
+          while (1) {
+            switch (_context16.prev = _context16.next) {
+              case 0:
+                readFn = function readFn(position, length) {
+                  return Promise.resolve(buffer.slice(position, position + length));
+                };
+
+                closeFn = function closeFn() {
+                  return Promise.resolve();
+                };
+
+                return _context16.abrupt("return", new ParquetEnvelopeReader(readFn, closeFn, buffer.length));
+
+              case 3:
+              case "end":
+                return _context16.stop();
+            }
+          }
+        }, _callee16);
+      }));
+
+      function openBuffer(_x12) {
+        return _openBuffer2.apply(this, arguments);
+      }
 
-}
+      return openBuffer;
+    }()
+  }]);
+  return ParquetEnvelopeReader;
+}();
 
 exports.ParquetEnvelopeReader = ParquetEnvelopeReader;
 
@@ -323,12 +849,12 @@ function decodeValues(type, encoding, cursor, count, opts) {
 }
 
 function decodeDataPages(buffer, column, compression) {
-  const cursor = {
-    buffer,
+  var cursor = {
+    buffer: buffer,
     offset: 0,
     size: buffer.length
   };
-  const data = {
+  var data = {
     rlevels: [],
     dlevels: [],
     values: [],
@@ -336,13 +862,13 @@ function decodeDataPages(buffer, column, compression) {
   };
 
   while (cursor.offset < cursor.size) {
-    const {
-      pageHeader,
-      length
-    } = Util.decodePageHeader(cursor.buffer);
-    cursor.offset += length;
-    const pageType = Util.getThriftEnum(_parquetThrift.PageType, pageHeader.type);
-    let pageData = null;
+    var _Util$decodePageHeade = Util.decodePageHeader(cursor.buffer),
+        pageHeader = _Util$decodePageHeade.pageHeader,
+        _length = _Util$decodePageHeade.length;
+
+    cursor.offset += _length;
+    var pageType = Util.getThriftEnum(_parquetThrift.PageType, pageHeader.type);
+    var pageData = null;
 
     switch (pageType) {
       case 'DATA_PAGE':
@@ -369,12 +895,12 @@ function decodeDataPages(buffer, column, compression) {
 function decodeDataPage(cursor, header, column, compression) {
   var _header$data_page_hea, _header$data_page_hea2, _header$data_page_hea3, _header$data_page_hea4;
 
-  const cursorEnd = cursor.offset + header.compressed_page_size;
-  const valueCount = (_header$data_page_hea = header.data_page_header) === null || _header$data_page_hea === void 0 ? void 0 : _header$data_page_hea.num_values;
-  let dataCursor = cursor;
+  var cursorEnd = cursor.offset + header.compressed_page_size;
+  var valueCount = (_header$data_page_hea = header.data_page_header) === null || _header$data_page_hea === void 0 ? void 0 : _header$data_page_hea.num_values;
+  var dataCursor = cursor;
 
   if (compression !== 'UNCOMPRESSED') {
-    const valuesBuf = Compression.inflate(compression, cursor.buffer.slice(cursor.offset, cursorEnd), header.uncompressed_page_size);
+    var valuesBuf = Compression.inflate(compression, cursor.buffer.slice(cursor.offset, cursorEnd), header.uncompressed_page_size);
     dataCursor = {
       buffer: valuesBuf,
       offset: 0,
@@ -383,8 +909,8 @@ function decodeDataPage(cursor, header, column, compression) {
     cursor.offset = cursorEnd;
   }
 
-  const rLevelEncoding = Util.getThriftEnum(_parquetThrift.Encoding, (_header$data_page_hea2 = header.data_page_header) === null || _header$data_page_hea2 === void 0 ? void 0 : _header$data_page_hea2.repetition_level_encoding);
-  let rLevels = new Array(valueCount);
+  var rLevelEncoding = Util.getThriftEnum(_parquetThrift.Encoding, (_header$data_page_hea2 = header.data_page_header) === null || _header$data_page_hea2 === void 0 ? void 0 : _header$data_page_hea2.repetition_level_encoding);
+  var rLevels = new Array(valueCount);
 
   if (column.rLevelMax > 0) {
     rLevels = decodeValues(PARQUET_RDLVL_TYPE, rLevelEncoding, dataCursor, valueCount, {
@@ -395,8 +921,8 @@ function decodeDataPage(cursor, header, column, compression) {
     rLevels.fill(0);
   }
 
-  const dLevelEncoding = Util.getThriftEnum(_parquetThrift.Encoding, (_header$data_page_hea3 = header.data_page_header) === null || _header$data_page_hea3 === void 0 ? void 0 : _header$data_page_hea3.definition_level_encoding);
-  let dLevels = new Array(valueCount);
+  var dLevelEncoding = Util.getThriftEnum(_parquetThrift.Encoding, (_header$data_page_hea3 = header.data_page_header) === null || _header$data_page_hea3 === void 0 ? void 0 : _header$data_page_hea3.definition_level_encoding);
+  var dLevels = new Array(valueCount);
 
   if (column.dLevelMax > 0) {
     dLevels = decodeValues(PARQUET_RDLVL_TYPE, dLevelEncoding, dataCursor, valueCount, {
@@ -407,23 +933,34 @@ function decodeDataPage(cursor, header, column, compression) {
     dLevels.fill(0);
   }
 
-  let valueCountNonNull = 0;
+  var valueCountNonNull = 0;
 
-  for (const dlvl of dLevels) {
-    if (dlvl === column.dLevelMax) {
-      valueCountNonNull++;
+  var _iterator3 = _createForOfIteratorHelper(dLevels),
+      _step3;
+
+  try {
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var dlvl = _step3.value;
+
+      if (dlvl === column.dLevelMax) {
+        valueCountNonNull++;
+      }
     }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
   }
 
-  const valueEncoding = Util.getThriftEnum(_parquetThrift.Encoding, (_header$data_page_hea4 = header.data_page_header) === null || _header$data_page_hea4 === void 0 ? void 0 : _header$data_page_hea4.encoding);
-  const values = decodeValues(column.primitiveType, valueEncoding, dataCursor, valueCountNonNull, {
+  var valueEncoding = Util.getThriftEnum(_parquetThrift.Encoding, (_header$data_page_hea4 = header.data_page_header) === null || _header$data_page_hea4 === void 0 ? void 0 : _header$data_page_hea4.encoding);
+  var values = decodeValues(column.primitiveType, valueEncoding, dataCursor, valueCountNonNull, {
     typeLength: column.typeLength,
     bitWidth: column.typeLength
   });
   return {
     dlevels: dLevels,
     rlevels: rLevels,
-    values,
+    values: values,
     count: valueCount
   };
 }
@@ -431,11 +968,11 @@ function decodeDataPage(cursor, header, column, compression) {
 function decodeDataPageV2(cursor, header, column, compression) {
   var _header$data_page_hea5, _header$data_page_hea6, _header$data_page_hea7, _header$data_page_hea8;
 
-  const cursorEnd = cursor.offset + header.compressed_page_size;
-  const valueCount = (_header$data_page_hea5 = header.data_page_header_v2) === null || _header$data_page_hea5 === void 0 ? void 0 : _header$data_page_hea5.num_values;
-  const valueCountNonNull = valueCount - ((_header$data_page_hea6 = header.data_page_header_v2) === null || _header$data_page_hea6 === void 0 ? void 0 : _header$data_page_hea6.num_nulls);
-  const valueEncoding = Util.getThriftEnum(_parquetThrift.Encoding, (_header$data_page_hea7 = header.data_page_header_v2) === null || _header$data_page_hea7 === void 0 ? void 0 : _header$data_page_hea7.encoding);
-  let rLevels = new Array(valueCount);
+  var cursorEnd = cursor.offset + header.compressed_page_size;
+  var valueCount = (_header$data_page_hea5 = header.data_page_header_v2) === null || _header$data_page_hea5 === void 0 ? void 0 : _header$data_page_hea5.num_values;
+  var valueCountNonNull = valueCount - ((_header$data_page_hea6 = header.data_page_header_v2) === null || _header$data_page_hea6 === void 0 ? void 0 : _header$data_page_hea6.num_nulls);
+  var valueEncoding = Util.getThriftEnum(_parquetThrift.Encoding, (_header$data_page_hea7 = header.data_page_header_v2) === null || _header$data_page_hea7 === void 0 ? void 0 : _header$data_page_hea7.encoding);
+  var rLevels = new Array(valueCount);
 
   if (column.rLevelMax > 0) {
     rLevels = decodeValues(PARQUET_RDLVL_TYPE, PARQUET_RDLVL_ENCODING, cursor, valueCount, {
@@ -446,7 +983,7 @@ function decodeDataPageV2(cursor, header, column, compression) {
     rLevels.fill(0);
   }
 
-  let dLevels = new Array(valueCount);
+  var dLevels = new Array(valueCount);
 
   if (column.dLevelMax > 0) {
     dLevels = decodeValues(PARQUET_RDLVL_TYPE, PARQUET_RDLVL_ENCODING, cursor, valueCount, {
@@ -457,10 +994,10 @@ function decodeDataPageV2(cursor, header, column, compression) {
     dLevels.fill(0);
   }
 
-  let valuesBufCursor = cursor;
+  var valuesBufCursor = cursor;
 
   if ((_header$data_page_hea8 = header.data_page_header_v2) !== null && _header$data_page_hea8 !== void 0 && _header$data_page_hea8.is_compressed) {
-    const valuesBuf = Compression.inflate(compression, cursor.buffer.slice(cursor.offset, cursorEnd), header.uncompressed_page_size);
+    var valuesBuf = Compression.inflate(compression, cursor.buffer.slice(cursor.offset, cursorEnd), header.uncompressed_page_size);
     valuesBufCursor = {
       buffer: valuesBuf,
       offset: 0,
@@ -469,27 +1006,27 @@ function decodeDataPageV2(cursor, header, column, compression) {
     cursor.offset = cursorEnd;
   }
 
-  const values = decodeValues(column.primitiveType, valueEncoding, valuesBufCursor, valueCountNonNull, {
+  var values = decodeValues(column.primitiveType, valueEncoding, valuesBufCursor, valueCountNonNull, {
     typeLength: column.typeLength,
     bitWidth: column.typeLength
   });
   return {
     dlevels: dLevels,
     rlevels: rLevels,
-    values,
+    values: values,
     count: valueCount
   };
 }
 
 function decodeSchema(schemaElements, offset, len) {
-  const schema = {};
-  let next = offset;
+  var schema = {};
+  var next = offset;
 
-  for (let i = 0; i < len; i++) {
-    const schemaElement = schemaElements[next];
-    const repetitionType = next > 0 ? Util.getThriftEnum(_parquetThrift.FieldRepetitionType, schemaElement.repetition_type) : 'ROOT';
-    let optional = false;
-    let repeated = false;
+  for (var i = 0; i < len; i++) {
+    var schemaElement = schemaElements[next];
+    var repetitionType = next > 0 ? Util.getThriftEnum(_parquetThrift.FieldRepetitionType, schemaElement.repetition_type) : 'ROOT';
+    var optional = false;
+    var repeated = false;
 
     switch (repetitionType) {
       case 'REQUIRED':
@@ -508,15 +1045,15 @@ function decodeSchema(schemaElements, offset, len) {
     }
 
     if (schemaElement.num_children > 0) {
-      const res = decodeSchema(schemaElements, next + 1, schemaElement.num_children);
+      var res = decodeSchema(schemaElements, next + 1, schemaElement.num_children);
       next = res.next;
       schema[schemaElement.name] = {
-        optional,
-        repeated,
+        optional: optional,
+        repeated: repeated,
         fields: res.schema
       };
     } else {
-      let logicalType = Util.getThriftEnum(_parquetThrift.Type, schemaElement.type);
+      var logicalType = Util.getThriftEnum(_parquetThrift.Type, schemaElement.type);
 
       if (schemaElement.converted_type) {
         logicalType = Util.getThriftEnum(_parquetThrift.ConvertedType, schemaElement.converted_type);
@@ -525,17 +1062,17 @@ function decodeSchema(schemaElements, offset, len) {
       schema[schemaElement.name] = {
         type: logicalType,
         typeLength: schemaElement.type_length,
-        optional,
-        repeated
+        optional: optional,
+        repeated: repeated
       };
       next++;
     }
   }
 
   return {
-    schema,
-    offset,
-    next
+    schema: schema,
+    offset: offset,
+    next: next
   };
 }
 //# sourceMappingURL=reader.js.map