@sqlanvil/cli 1.13.0 → 1.15.0

package/bundle.js

@@ -34,10 +34,11 @@ var pg = require('pg');
 var bigquery = require('@google-cloud/bigquery');
 var EventEmitter = require('events');
 var Long = require('long');
-var os = require('os');
+var googleAuthLibrary = require('google-auth-library');
 var promisePoolExecutor = require('promise-pool-executor');
 var sizeof = require('object-sizeof');
 var QueryStream = require('pg-query-stream');
+var os = require('os');
 var readlineSync = require('readline-sync');
 var untildify = require('untildify');
 var googleSqlSyntaxTs = require('google-sql-syntax-ts');
@@ -80,9 +81,9 @@ var mysql__namespace = /*#__PURE__*/_interopNamespace(mysql);
 var pg__namespace = /*#__PURE__*/_interopNamespace(pg);
 var EventEmitter__default = /*#__PURE__*/_interopDefaultLegacy(EventEmitter);
 var Long__default = /*#__PURE__*/_interopDefaultLegacy(Long);
-var os__namespace = /*#__PURE__*/_interopNamespace(os);
 var sizeof__default = /*#__PURE__*/_interopDefaultLegacy(sizeof);
 var QueryStream__default = /*#__PURE__*/_interopDefaultLegacy(QueryStream);
+var os__namespace = /*#__PURE__*/_interopNamespace(os);
 var readlineSync__namespace = /*#__PURE__*/_interopNamespace(readlineSync);
 var untildify__default = /*#__PURE__*/_interopDefaultLegacy(untildify);
 var jsBeautify__namespace = /*#__PURE__*/_interopNamespace(jsBeautify);
@@ -1282,6 +1283,7 @@ const sqlanvil = $root.sqlanvil = (() => {
          * @property {number|null} [port] ConnectionConfig port
          * @property {string|null} [database] ConnectionConfig database
          * @property {string|null} [defaultSchema] ConnectionConfig defaultSchema
+         * @property {string|null} [mode] ConnectionConfig mode
          */
 
         /**
@@ -1371,6 +1373,14 @@ const sqlanvil = $root.sqlanvil = (() => {
          */
         ConnectionConfig.prototype.defaultSchema = "";
 
+        /**
+         * ConnectionConfig mode.
+         * @member {string} mode
+         * @memberof sqlanvil.ConnectionConfig
+         * @instance
+         */
+        ConnectionConfig.prototype.mode = "";
+
         /**
          * Creates a new ConnectionConfig instance using the specified properties.
          * @function create
@@ -1413,6 +1423,8 @@ const sqlanvil = $root.sqlanvil = (() => {
                 writer.uint32(/* id 8, wireType 2 =*/66).string(message.defaultSchema);
             if (message.billingProject != null && Object.hasOwnProperty.call(message, "billingProject"))
                 writer.uint32(/* id 9, wireType 2 =*/74).string(message.billingProject);
+            if (message.mode != null && Object.hasOwnProperty.call(message, "mode"))
+                writer.uint32(/* id 10, wireType 2 =*/82).string(message.mode);
             return writer;
         };
 
@@ -1489,6 +1501,10 @@ const sqlanvil = $root.sqlanvil = (() => {
                         message.defaultSchema = reader.string();
                         break;
                     }
+                case 10: {
+                        message.mode = reader.string();
+                        break;
+                    }
                 default:
                     reader.skipType(tag & 7, long);
                     break;
@@ -1555,6 +1571,9 @@ const sqlanvil = $root.sqlanvil = (() => {
             if (message.defaultSchema != null && message.hasOwnProperty("defaultSchema"))
                 if (!$util.isString(message.defaultSchema))
                     return "defaultSchema: string expected";
+            if (message.mode != null && message.hasOwnProperty("mode"))
+                if (!$util.isString(message.mode))
+                    return "mode: string expected";
             return null;
         };
 
@@ -1592,6 +1611,8 @@ const sqlanvil = $root.sqlanvil = (() => {
                 message.database = String(object.database);
             if (object.defaultSchema != null)
                 message.defaultSchema = String(object.defaultSchema);
+            if (object.mode != null)
+                message.mode = String(object.mode);
             return message;
         };
 
@@ -1618,6 +1639,7 @@ const sqlanvil = $root.sqlanvil = (() => {
                 object.database = "";
                 object.defaultSchema = "";
                 object.billingProject = "";
+                object.mode = "";
             }
             if (message.platform != null && message.hasOwnProperty("platform"))
                 object.platform = message.platform;
@@ -1637,6 +1659,8 @@ const sqlanvil = $root.sqlanvil = (() => {
                 object.defaultSchema = message.defaultSchema;
             if (message.billingProject != null && message.hasOwnProperty("billingProject"))
                 object.billingProject = message.billingProject;
+            if (message.mode != null && message.hasOwnProperty("mode"))
+                object.mode = message.mode;
             return object;
         };
 
@@ -26389,6 +26413,668 @@ const sqlanvil = $root.sqlanvil = (() => {
         return Import;
     })();
 
+    sqlanvil.Extract = (function() {
+
+        /**
+         * Properties of an Extract.
+         * @memberof sqlanvil
+         * @interface IExtract
+         * @property {sqlanvil.ITarget|null} [target] Extract target
+         * @property {sqlanvil.ITarget|null} [canonicalTarget] Extract canonicalTarget
+         * @property {Array.<sqlanvil.ITarget>|null} [dependencyTargets] Extract dependencyTargets
+         * @property {sqlanvil.ActionHermeticity|null} [hermeticity] Extract hermeticity
+         * @property {boolean|null} [disabled] Extract disabled
+         * @property {Array.<string>|null} [tags] Extract tags
+         * @property {sqlanvil.IActionDescriptor|null} [actionDescriptor] Extract actionDescriptor
+         * @property {string|null} [connectionName] Extract connectionName
+         * @property {string|null} [platform] Extract platform
+         * @property {string|null} [project] Extract project
+         * @property {string|null} [dataset] Extract dataset
+         * @property {string|null} [sourceName] Extract sourceName
+         * @property {string|null} [billingProject] Extract billingProject
+         * @property {Object.<string,string>|null} [columnTypes] Extract columnTypes
+         * @property {string|null} [fileName] Extract fileName
+         */
+
+        /**
+         * Constructs a new Extract.
+         * @memberof sqlanvil
+         * @classdesc Represents an Extract.
+         * @implements IExtract
+         * @constructor
+         * @param {sqlanvil.IExtract=} [properties] Properties to set
+         */
+        function Extract(properties) {
+            this.dependencyTargets = [];
+            this.tags = [];
+            this.columnTypes = {};
+            if (properties)
+                for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                    if (properties[keys[i]] != null && keys[i] !== "__proto__")
+                        this[keys[i]] = properties[keys[i]];
+        }
+
+        /**
+         * Extract target.
+         * @member {sqlanvil.ITarget|null|undefined} target
+         * @memberof sqlanvil.Extract
+         * @instance
+         */
+        Extract.prototype.target = null;
+
+        /**
+         * Extract canonicalTarget.
+         * @member {sqlanvil.ITarget|null|undefined} canonicalTarget
+         * @memberof sqlanvil.Extract
+         * @instance
+         */
+        Extract.prototype.canonicalTarget = null;
+
+        /**
+         * Extract dependencyTargets.
+         * @member {Array.<sqlanvil.ITarget>} dependencyTargets
+         * @memberof sqlanvil.Extract
+         * @instance
+         */
+        Extract.prototype.dependencyTargets = $util.emptyArray;
+
+        /**
+         * Extract hermeticity.
+         * @member {sqlanvil.ActionHermeticity} hermeticity
+         * @memberof sqlanvil.Extract
+         * @instance
+         */
+        Extract.prototype.hermeticity = 0;
+
+        /**
+         * Extract disabled.
+         * @member {boolean} disabled
+         * @memberof sqlanvil.Extract
+         * @instance
+         */
+        Extract.prototype.disabled = false;
+
+        /**
+         * Extract tags.
+         * @member {Array.<string>} tags
+         * @memberof sqlanvil.Extract
+         * @instance
+         */
+        Extract.prototype.tags = $util.emptyArray;
+
+        /**
+         * Extract actionDescriptor.
+         * @member {sqlanvil.IActionDescriptor|null|undefined} actionDescriptor
+         * @memberof sqlanvil.Extract
+         * @instance
+         */
+        Extract.prototype.actionDescriptor = null;
+
+        /**
+         * Extract connectionName.
+         * @member {string} connectionName
+         * @memberof sqlanvil.Extract
+         * @instance
+         */
+        Extract.prototype.connectionName = "";
+
+        /**
+         * Extract platform.
+         * @member {string} platform
+         * @memberof sqlanvil.Extract
+         * @instance
+         */
+        Extract.prototype.platform = "";
+
+        /**
+         * Extract project.
+         * @member {string} project
+         * @memberof sqlanvil.Extract
+         * @instance
+         */
+        Extract.prototype.project = "";
+
+        /**
+         * Extract dataset.
+         * @member {string} dataset
+         * @memberof sqlanvil.Extract
+         * @instance
+         */
+        Extract.prototype.dataset = "";
+
+        /**
+         * Extract sourceName.
+         * @member {string} sourceName
+         * @memberof sqlanvil.Extract
+         * @instance
+         */
+        Extract.prototype.sourceName = "";
+
+        /**
+         * Extract billingProject.
+         * @member {string} billingProject
+         * @memberof sqlanvil.Extract
+         * @instance
+         */
+        Extract.prototype.billingProject = "";
+
+        /**
+         * Extract columnTypes.
+         * @member {Object.<string,string>} columnTypes
+         * @memberof sqlanvil.Extract
+         * @instance
+         */
+        Extract.prototype.columnTypes = $util.emptyObject;
+
+        /**
+         * Extract fileName.
+         * @member {string} fileName
+         * @memberof sqlanvil.Extract
+         * @instance
+         */
+        Extract.prototype.fileName = "";
+
+        /**
+         * Creates a new Extract instance using the specified properties.
+         * @function create
+         * @memberof sqlanvil.Extract
+         * @static
+         * @param {sqlanvil.IExtract=} [properties] Properties to set
+         * @returns {sqlanvil.Extract} Extract instance
+         */
+        Extract.create = function create(properties) {
+            return new Extract(properties);
+        };
+
+        /**
+         * Encodes the specified Extract message. Does not implicitly {@link sqlanvil.Extract.verify|verify} messages.
+         * @function encode
+         * @memberof sqlanvil.Extract
+         * @static
+         * @param {sqlanvil.IExtract} message Extract message or plain object to encode
+         * @param {$protobuf.Writer} [writer] Writer to encode to
+         * @returns {$protobuf.Writer} Writer
+         */
+        Extract.encode = function encode(message, writer) {
+            if (!writer)
+                writer = $Writer.create();
+            if (message.target != null && Object.hasOwnProperty.call(message, "target"))
+                $root.sqlanvil.Target.encode(message.target, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
+            if (message.canonicalTarget != null && Object.hasOwnProperty.call(message, "canonicalTarget"))
+                $root.sqlanvil.Target.encode(message.canonicalTarget, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();
+            if (message.dependencyTargets != null && message.dependencyTargets.length)
+                for (let i = 0; i < message.dependencyTargets.length; ++i)
+                    $root.sqlanvil.Target.encode(message.dependencyTargets[i], writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim();
+            if (message.hermeticity != null && Object.hasOwnProperty.call(message, "hermeticity"))
+                writer.uint32(/* id 4, wireType 0 =*/32).int32(message.hermeticity);
+            if (message.disabled != null && Object.hasOwnProperty.call(message, "disabled"))
+                writer.uint32(/* id 5, wireType 0 =*/40).bool(message.disabled);
+            if (message.tags != null && message.tags.length)
+                for (let i = 0; i < message.tags.length; ++i)
+                    writer.uint32(/* id 6, wireType 2 =*/50).string(message.tags[i]);
+            if (message.actionDescriptor != null && Object.hasOwnProperty.call(message, "actionDescriptor"))
+                $root.sqlanvil.ActionDescriptor.encode(message.actionDescriptor, writer.uint32(/* id 7, wireType 2 =*/58).fork()).ldelim();
+            if (message.connectionName != null && Object.hasOwnProperty.call(message, "connectionName"))
+                writer.uint32(/* id 8, wireType 2 =*/66).string(message.connectionName);
+            if (message.platform != null && Object.hasOwnProperty.call(message, "platform"))
+                writer.uint32(/* id 9, wireType 2 =*/74).string(message.platform);
+            if (message.project != null && Object.hasOwnProperty.call(message, "project"))
+                writer.uint32(/* id 10, wireType 2 =*/82).string(message.project);
+            if (message.dataset != null && Object.hasOwnProperty.call(message, "dataset"))
+                writer.uint32(/* id 11, wireType 2 =*/90).string(message.dataset);
+            if (message.sourceName != null && Object.hasOwnProperty.call(message, "sourceName"))
+                writer.uint32(/* id 12, wireType 2 =*/98).string(message.sourceName);
+            if (message.billingProject != null && Object.hasOwnProperty.call(message, "billingProject"))
+                writer.uint32(/* id 13, wireType 2 =*/106).string(message.billingProject);
+            if (message.columnTypes != null && Object.hasOwnProperty.call(message, "columnTypes"))
+                for (let keys = Object.keys(message.columnTypes), i = 0; i < keys.length; ++i)
+                    writer.uint32(/* id 14, wireType 2 =*/114).fork().uint32(/* id 1, wireType 2 =*/10).string(keys[i]).uint32(/* id 2, wireType 2 =*/18).string(message.columnTypes[keys[i]]).ldelim();
+            if (message.fileName != null && Object.hasOwnProperty.call(message, "fileName"))
+                writer.uint32(/* id 15, wireType 2 =*/122).string(message.fileName);
+            return writer;
+        };
+
+        /**
+         * Encodes the specified Extract message, length delimited. Does not implicitly {@link sqlanvil.Extract.verify|verify} messages.
+         * @function encodeDelimited
+         * @memberof sqlanvil.Extract
+         * @static
+         * @param {sqlanvil.IExtract} message Extract message or plain object to encode
+         * @param {$protobuf.Writer} [writer] Writer to encode to
+         * @returns {$protobuf.Writer} Writer
+         */
+        Extract.encodeDelimited = function encodeDelimited(message, writer) {
+            return this.encode(message, writer).ldelim();
+        };
+
+        /**
+         * Decodes an Extract message from the specified reader or buffer.
+         * @function decode
+         * @memberof sqlanvil.Extract
+         * @static
+         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+         * @param {number} [length] Message length if known beforehand
+         * @returns {sqlanvil.Extract} Extract
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        Extract.decode = function decode(reader, length, error, long) {
+            if (!(reader instanceof $Reader))
+                reader = $Reader.create(reader);
+            if (long === undefined)
+                long = 0;
+            if (long > $Reader.recursionLimit)
+                throw Error("maximum nesting depth exceeded");
+            let end = length === undefined ? reader.len : reader.pos + length, message = new $root.sqlanvil.Extract(), key, value;
+            while (reader.pos < end) {
+                let tag = reader.uint32();
+                if (tag === error)
+                    break;
+                switch (tag >>> 3) {
+                case 1: {
+                        message.target = $root.sqlanvil.Target.decode(reader, reader.uint32(), undefined, long + 1);
+                        break;
+                    }
+                case 2: {
+                        message.canonicalTarget = $root.sqlanvil.Target.decode(reader, reader.uint32(), undefined, long + 1);
+                        break;
+                    }
+                case 3: {
+                        if (!(message.dependencyTargets && message.dependencyTargets.length))
+                            message.dependencyTargets = [];
+                        message.dependencyTargets.push($root.sqlanvil.Target.decode(reader, reader.uint32(), undefined, long + 1));
+                        break;
+                    }
+                case 4: {
+                        message.hermeticity = reader.int32();
+                        break;
+                    }
+                case 5: {
+                        message.disabled = reader.bool();
+                        break;
+                    }
+                case 6: {
+                        if (!(message.tags && message.tags.length))
+                            message.tags = [];
+                        message.tags.push(reader.string());
+                        break;
+                    }
+                case 7: {
+                        message.actionDescriptor = $root.sqlanvil.ActionDescriptor.decode(reader, reader.uint32(), undefined, long + 1);
+                        break;
+                    }
+                case 8: {
+                        message.connectionName = reader.string();
+                        break;
+                    }
+                case 9: {
+                        message.platform = reader.string();
+                        break;
+                    }
+                case 10: {
+                        message.project = reader.string();
+                        break;
+                    }
+                case 11: {
+                        message.dataset = reader.string();
+                        break;
+                    }
+                case 12: {
+                        message.sourceName = reader.string();
+                        break;
+                    }
+                case 13: {
+                        message.billingProject = reader.string();
+                        break;
+                    }
+                case 14: {
+                        if (message.columnTypes === $util.emptyObject)
+                            message.columnTypes = {};
+                        let end2 = reader.uint32() + reader.pos;
+                        key = "";
+                        value = "";
+                        while (reader.pos < end2) {
+                            let tag2 = reader.uint32();
+                            switch (tag2 >>> 3) {
+                            case 1:
+                                key = reader.string();
+                                break;
+                            case 2:
+                                value = reader.string();
+                                break;
+                            default:
+                                reader.skipType(tag2 & 7, long);
+                                break;
+                            }
+                        }
+                        if (key === "__proto__")
+                            $util.makeProp(message.columnTypes, key);
+                        message.columnTypes[key] = value;
+                        break;
+                    }
+                case 15: {
+                        message.fileName = reader.string();
+                        break;
+                    }
+                default:
+                    reader.skipType(tag & 7, long);
+                    break;
+                }
+            }
+            return message;
+        };
+
+        /**
+         * Decodes an Extract message from the specified reader or buffer, length delimited.
+         * @function decodeDelimited
+         * @memberof sqlanvil.Extract
+         * @static
+         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+         * @returns {sqlanvil.Extract} Extract
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        Extract.decodeDelimited = function decodeDelimited(reader) {
+            if (!(reader instanceof $Reader))
+                reader = new $Reader(reader);
+            return this.decode(reader, reader.uint32());
+        };
+
+        /**
+         * Verifies an Extract message.
+         * @function verify
+         * @memberof sqlanvil.Extract
+         * @static
+         * @param {Object.<string,*>} message Plain object to verify
+         * @returns {string|null} `null` if valid, otherwise the reason why it is not
+         */
+        Extract.verify = function verify(message, long) {
+            if (typeof message !== "object" || message === null)
+                return "object expected";
+            if (long === undefined)
+                long = 0;
+            if (long > $util.recursionLimit)
+                return "maximum nesting depth exceeded";
+            if (message.target != null && message.hasOwnProperty("target")) {
+                let error = $root.sqlanvil.Target.verify(message.target, long + 1);
+                if (error)
+                    return "target." + error;
+            }
+            if (message.canonicalTarget != null && message.hasOwnProperty("canonicalTarget")) {
+                let error = $root.sqlanvil.Target.verify(message.canonicalTarget, long + 1);
+                if (error)
+                    return "canonicalTarget." + error;
+            }
+            if (message.dependencyTargets != null && message.hasOwnProperty("dependencyTargets")) {
+                if (!Array.isArray(message.dependencyTargets))
+                    return "dependencyTargets: array expected";
+                for (let i = 0; i < message.dependencyTargets.length; ++i) {
+                    let error = $root.sqlanvil.Target.verify(message.dependencyTargets[i], long + 1);
+                    if (error)
+                        return "dependencyTargets." + error;
+                }
+            }
+            if (message.hermeticity != null && message.hasOwnProperty("hermeticity"))
+                switch (message.hermeticity) {
+                default:
+                    return "hermeticity: enum value expected";
+                case 0:
+                case 1:
+                case 2:
+                    break;
+                }
+            if (message.disabled != null && message.hasOwnProperty("disabled"))
+                if (typeof message.disabled !== "boolean")
+                    return "disabled: boolean expected";
+            if (message.tags != null && message.hasOwnProperty("tags")) {
+                if (!Array.isArray(message.tags))
+                    return "tags: array expected";
+                for (let i = 0; i < message.tags.length; ++i)
+                    if (!$util.isString(message.tags[i]))
+                        return "tags: string[] expected";
+            }
+            if (message.actionDescriptor != null && message.hasOwnProperty("actionDescriptor")) {
+                let error = $root.sqlanvil.ActionDescriptor.verify(message.actionDescriptor, long + 1);
+                if (error)
+                    return "actionDescriptor." + error;
+            }
+            if (message.connectionName != null && message.hasOwnProperty("connectionName"))
+                if (!$util.isString(message.connectionName))
+                    return "connectionName: string expected";
+            if (message.platform != null && message.hasOwnProperty("platform"))
+                if (!$util.isString(message.platform))
+                    return "platform: string expected";
+            if (message.project != null && message.hasOwnProperty("project"))
+                if (!$util.isString(message.project))
+                    return "project: string expected";
+            if (message.dataset != null && message.hasOwnProperty("dataset"))
+                if (!$util.isString(message.dataset))
+                    return "dataset: string expected";
+            if (message.sourceName != null && message.hasOwnProperty("sourceName"))
+                if (!$util.isString(message.sourceName))
+                    return "sourceName: string expected";
+            if (message.billingProject != null && message.hasOwnProperty("billingProject"))
+                if (!$util.isString(message.billingProject))
+                    return "billingProject: string expected";
+            if (message.columnTypes != null && message.hasOwnProperty("columnTypes")) {
+                if (!$util.isObject(message.columnTypes))
+                    return "columnTypes: object expected";
+                let key = Object.keys(message.columnTypes);
+                for (let i = 0; i < key.length; ++i)
+                    if (!$util.isString(message.columnTypes[key[i]]))
+                        return "columnTypes: string{k:string} expected";
+            }
+            if (message.fileName != null && message.hasOwnProperty("fileName"))
+                if (!$util.isString(message.fileName))
+                    return "fileName: string expected";
+            return null;
+        };
+
+        /**
+         * Creates an Extract message from a plain object. Also converts values to their respective internal types.
+         * @function fromObject
+         * @memberof sqlanvil.Extract
+         * @static
+         * @param {Object.<string,*>} object Plain object
+         * @returns {sqlanvil.Extract} Extract
+         */
+        Extract.fromObject = function fromObject(object, long) {
+            if (object instanceof $root.sqlanvil.Extract)
+                return object;
+            if (long === undefined)
+                long = 0;
+            if (long > $util.recursionLimit)
+                throw Error("maximum nesting depth exceeded");
+            let message = new $root.sqlanvil.Extract();
+            if (object.target != null) {
+                if (typeof object.target !== "object")
+                    throw TypeError(".sqlanvil.Extract.target: object expected");
+                message.target = $root.sqlanvil.Target.fromObject(object.target, long + 1);
+            }
+            if (object.canonicalTarget != null) {
+                if (typeof object.canonicalTarget !== "object")
+                    throw TypeError(".sqlanvil.Extract.canonicalTarget: object expected");
+                message.canonicalTarget = $root.sqlanvil.Target.fromObject(object.canonicalTarget, long + 1);
+            }
+            if (object.dependencyTargets) {
+                if (!Array.isArray(object.dependencyTargets))
+                    throw TypeError(".sqlanvil.Extract.dependencyTargets: array expected");
+                message.dependencyTargets = [];
+                for (let i = 0; i < object.dependencyTargets.length; ++i) {
+                    if (typeof object.dependencyTargets[i] !== "object")
+                        throw TypeError(".sqlanvil.Extract.dependencyTargets: object expected");
+                    message.dependencyTargets[i] = $root.sqlanvil.Target.fromObject(object.dependencyTargets[i], long + 1);
+                }
+            }
+            switch (object.hermeticity) {
+            default:
+                if (typeof object.hermeticity === "number") {
+                    message.hermeticity = object.hermeticity;
+                    break;
+                }
+                break;
+            case "UNKNOWN":
+            case 0:
+                message.hermeticity = 0;
+                break;
+            case "HERMETIC":
+            case 1:
+                message.hermeticity = 1;
+                break;
+            case "NON_HERMETIC":
+            case 2:
+                message.hermeticity = 2;
+                break;
+            }
+            if (object.disabled != null)
+                message.disabled = Boolean(object.disabled);
+            if (object.tags) {
+                if (!Array.isArray(object.tags))
+                    throw TypeError(".sqlanvil.Extract.tags: array expected");
+                message.tags = [];
+                for (let i = 0; i < object.tags.length; ++i)
+                    message.tags[i] = String(object.tags[i]);
+            }
+            if (object.actionDescriptor != null) {
+                if (typeof object.actionDescriptor !== "object")
+                    throw TypeError(".sqlanvil.Extract.actionDescriptor: object expected");
+                message.actionDescriptor = $root.sqlanvil.ActionDescriptor.fromObject(object.actionDescriptor, long + 1);
+            }
+            if (object.connectionName != null)
+                message.connectionName = String(object.connectionName);
+            if (object.platform != null)
+                message.platform = String(object.platform);
+            if (object.project != null)
+                message.project = String(object.project);
+            if (object.dataset != null)
+                message.dataset = String(object.dataset);
+            if (object.sourceName != null)
+                message.sourceName = String(object.sourceName);
+            if (object.billingProject != null)
+                message.billingProject = String(object.billingProject);
+            if (object.columnTypes) {
+                if (typeof object.columnTypes !== "object")
+                    throw TypeError(".sqlanvil.Extract.columnTypes: object expected");
+                message.columnTypes = {};
+                for (let keys = Object.keys(object.columnTypes), i = 0; i < keys.length; ++i) {
+                    if (keys[i] === "__proto__")
+                        $util.makeProp(message.columnTypes, keys[i]);
+                    message.columnTypes[keys[i]] = String(object.columnTypes[keys[i]]);
+                }
+            }
+            if (object.fileName != null)
+                message.fileName = String(object.fileName);
+            return message;
+        };
+
+        /**
+         * Creates a plain object from an Extract message. Also converts values to other types if specified.
+         * @function toObject
+         * @memberof sqlanvil.Extract
+         * @static
+         * @param {sqlanvil.Extract} message Extract
+         * @param {$protobuf.IConversionOptions} [options] Conversion options
+         * @returns {Object.<string,*>} Plain object
+         */
+        Extract.toObject = function toObject(message, options) {
+            if (!options)
+                options = {};
+            let object = {};
+            if (options.arrays || options.defaults) {
+                object.dependencyTargets = [];
+                object.tags = [];
+            }
+            if (options.objects || options.defaults)
+                object.columnTypes = {};
+            if (options.defaults) {
+                object.target = null;
+                object.canonicalTarget = null;
+                object.hermeticity = options.enums === String ? "UNKNOWN" : 0;
+                object.disabled = false;
+                object.actionDescriptor = null;
+                object.connectionName = "";
+                object.platform = "";
+                object.project = "";
+                object.dataset = "";
+                object.sourceName = "";
+                object.billingProject = "";
+                object.fileName = "";
+            }
+            if (message.target != null && message.hasOwnProperty("target"))
+                object.target = $root.sqlanvil.Target.toObject(message.target, options);
+            if (message.canonicalTarget != null && message.hasOwnProperty("canonicalTarget"))
+                object.canonicalTarget = $root.sqlanvil.Target.toObject(message.canonicalTarget, options);
+            if (message.dependencyTargets && message.dependencyTargets.length) {
+                object.dependencyTargets = [];
+                for (let j = 0; j < message.dependencyTargets.length; ++j)
+                    object.dependencyTargets[j] = $root.sqlanvil.Target.toObject(message.dependencyTargets[j], options);
+            }
+            if (message.hermeticity != null && message.hasOwnProperty("hermeticity"))
+                object.hermeticity = options.enums === String ? $root.sqlanvil.ActionHermeticity[message.hermeticity] === undefined ? message.hermeticity : $root.sqlanvil.ActionHermeticity[message.hermeticity] : message.hermeticity;
+            if (message.disabled != null && message.hasOwnProperty("disabled"))
+                object.disabled = message.disabled;
+            if (message.tags && message.tags.length) {
+                object.tags = [];
+                for (let j = 0; j < message.tags.length; ++j)
+                    object.tags[j] = message.tags[j];
+            }
+            if (message.actionDescriptor != null && message.hasOwnProperty("actionDescriptor"))
+                object.actionDescriptor = $root.sqlanvil.ActionDescriptor.toObject(message.actionDescriptor, options);
+            if (message.connectionName != null && message.hasOwnProperty("connectionName"))
+                object.connectionName = message.connectionName;
+            if (message.platform != null && message.hasOwnProperty("platform"))
+                object.platform = message.platform;
+            if (message.project != null && message.hasOwnProperty("project"))
+                object.project = message.project;
+            if (message.dataset != null && message.hasOwnProperty("dataset"))
+                object.dataset = message.dataset;
+            if (message.sourceName != null && message.hasOwnProperty("sourceName"))
+                object.sourceName = message.sourceName;
+            if (message.billingProject != null && message.hasOwnProperty("billingProject"))
+                object.billingProject = message.billingProject;
+            let keys2;
+            if (message.columnTypes && (keys2 = Object.keys(message.columnTypes)).length) {
+                object.columnTypes = {};
+                for (let j = 0; j < keys2.length; ++j) {
+                    if (keys2[j] === "__proto__")
+                        $util.makeProp(object.columnTypes, keys2[j]);
+                    object.columnTypes[keys2[j]] = message.columnTypes[keys2[j]];
+                }
+            }
+            if (message.fileName != null && message.hasOwnProperty("fileName"))
+                object.fileName = message.fileName;
+            return object;
+        };
+
+        /**
+         * Converts this Extract to JSON.
+         * @function toJSON
+         * @memberof sqlanvil.Extract
+         * @instance
+         * @returns {Object.<string,*>} JSON object
+         */
+        Extract.prototype.toJSON = function toJSON() {
+            return this.constructor.toObject(this, $protobuf__namespace.util.toJSONOptions);
+        };
+
+        /**
+         * Gets the default type url for Extract
+         * @function getTypeUrl
+         * @memberof sqlanvil.Extract
+         * @static
+         * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+         * @returns {string} The default type url
+         */
+        Extract.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+            if (typeUrlPrefix === undefined) {
+                typeUrlPrefix = "type.googleapis.com";
+            }
+            return typeUrlPrefix + "/sqlanvil.Extract";
+        };
+
+        return Extract;
+    })();
+
     sqlanvil.Assertion = (function() {
 
         /**
@@ -30365,6 +31051,7 @@ const sqlanvil = $root.sqlanvil = (() => {
          * @property {Array.<sqlanvil.IDataPreparation>|null} [dataPreparations] CompiledGraph dataPreparations
          * @property {Array.<sqlanvil.IExport>|null} [exports] CompiledGraph exports
          * @property {Array.<sqlanvil.IImport>|null} [imports] CompiledGraph imports
+         * @property {Array.<sqlanvil.IExtract>|null} [extracts] CompiledGraph extracts
          * @property {sqlanvil.IGraphErrors|null} [graphErrors] CompiledGraph graphErrors
          * @property {string|null} [sqlanvilCoreVersion] CompiledGraph sqlanvilCoreVersion
          * @property {Array.<sqlanvil.ITarget>|null} [targets] CompiledGraph targets
@@ -30389,6 +31076,7 @@ const sqlanvil = $root.sqlanvil = (() => {
             this.dataPreparations = [];
             this.exports = [];
             this.imports = [];
+            this.extracts = [];
             this.targets = [];
             if (properties)
                 for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
@@ -30476,6 +31164,14 @@ const sqlanvil = $root.sqlanvil = (() => {
          */
         CompiledGraph.prototype.imports = $util.emptyArray;
 
+        /**
+         * CompiledGraph extracts.
+         * @member {Array.<sqlanvil.IExtract>} extracts
+         * @memberof sqlanvil.CompiledGraph
+         * @instance
+         */
+        CompiledGraph.prototype.extracts = $util.emptyArray;
+
         /**
          * CompiledGraph graphErrors.
          * @member {sqlanvil.IGraphErrors|null|undefined} graphErrors
@@ -30570,6 +31266,9 @@ const sqlanvil = $root.sqlanvil = (() => {
             if (message.imports != null && message.imports.length)
                 for (let i = 0; i < message.imports.length; ++i)
                     $root.sqlanvil.Import.encode(message.imports[i], writer.uint32(/* id 16, wireType 2 =*/130).fork()).ldelim();
+            if (message.extracts != null && message.extracts.length)
+                for (let i = 0; i < message.extracts.length; ++i)
+                    $root.sqlanvil.Extract.encode(message.extracts[i], writer.uint32(/* id 17, wireType 2 =*/138).fork()).ldelim();
             return writer;
         };
 
@@ -30668,6 +31367,12 @@ const sqlanvil = $root.sqlanvil = (() => {
                         message.imports.push($root.sqlanvil.Import.decode(reader, reader.uint32(), undefined, long + 1));
                         break;
                     }
+                case 17: {
+                        if (!(message.extracts && message.extracts.length))
+                            message.extracts = [];
+                        message.extracts.push($root.sqlanvil.Extract.decode(reader, reader.uint32(), undefined, long + 1));
+                        break;
+                    }
                 case 7: {
                         message.graphErrors = $root.sqlanvil.GraphErrors.decode(reader, reader.uint32(), undefined, long + 1);
                         break;
@@ -30811,6 +31516,15 @@ const sqlanvil = $root.sqlanvil = (() => {
                         return "imports." + error;
                 }
             }
+            if (message.extracts != null && message.hasOwnProperty("extracts")) {
+                if (!Array.isArray(message.extracts))
+                    return "extracts: array expected";
+                for (let i = 0; i < message.extracts.length; ++i) {
+                    let error = $root.sqlanvil.Extract.verify(message.extracts[i], long + 1);
+                    if (error)
+                        return "extracts." + error;
+                }
+            }
             if (message.graphErrors != null && message.hasOwnProperty("graphErrors")) {
                 let error = $root.sqlanvil.GraphErrors.verify(message.graphErrors, long + 1);
                 if (error)
@@ -30947,6 +31661,16 @@ const sqlanvil = $root.sqlanvil = (() => {
                     message.imports[i] = $root.sqlanvil.Import.fromObject(object.imports[i], long + 1);
                 }
             }
+            if (object.extracts) {
+                if (!Array.isArray(object.extracts))
+                    throw TypeError(".sqlanvil.CompiledGraph.extracts: array expected");
+                message.extracts = [];
+                for (let i = 0; i < object.extracts.length; ++i) {
+                    if (typeof object.extracts[i] !== "object")
+                        throw TypeError(".sqlanvil.CompiledGraph.extracts: object expected");
+                    message.extracts[i] = $root.sqlanvil.Extract.fromObject(object.extracts[i], long + 1);
+                }
+            }
             if (object.graphErrors != null) {
                 if (typeof object.graphErrors !== "object")
                     throw TypeError(".sqlanvil.CompiledGraph.graphErrors: object expected");
@@ -30996,6 +31720,7 @@ const sqlanvil = $root.sqlanvil = (() => {
                 object.dataPreparations = [];
                 object.exports = [];
                 object.imports = [];
+                object.extracts = [];
             }
             if (options.defaults) {
                 object.projectConfig = null;
@@ -31061,6 +31786,11 @@ const sqlanvil = $root.sqlanvil = (() => {
                 for (let j = 0; j < message.imports.length; ++j)
                     object.imports[j] = $root.sqlanvil.Import.toObject(message.imports[j], options);
             }
+            if (message.extracts && message.extracts.length) {
+                object.extracts = [];
+                for (let j = 0; j < message.extracts.length; ++j)
+                    object.extracts[j] = $root.sqlanvil.Extract.toObject(message.extracts[j], options);
+            }
             return object;
         };
 
@@ -36183,6 +36913,406 @@ const sqlanvil = $root.sqlanvil = (() => {
         return ImportSpec;
     })();
 
+    sqlanvil.ExtractSpec = (function() {
+
+        /**
+         * Properties of an ExtractSpec.
+         * @memberof sqlanvil
+         * @interface IExtractSpec
+         * @property {string|null} [connectionName] ExtractSpec connectionName
+         * @property {string|null} [platform] ExtractSpec platform
+         * @property {string|null} [project] ExtractSpec project
+         * @property {string|null} [dataset] ExtractSpec dataset
+         * @property {string|null} [sourceName] ExtractSpec sourceName
+         * @property {string|null} [billingProject] ExtractSpec billingProject
+         * @property {Object.<string,string>|null} [columnTypes] ExtractSpec columnTypes
+         */
+
+        /**
+         * Constructs a new ExtractSpec.
+         * @memberof sqlanvil
+         * @classdesc Represents an ExtractSpec.
+         * @implements IExtractSpec
+         * @constructor
+         * @param {sqlanvil.IExtractSpec=} [properties] Properties to set
+         */
+        function ExtractSpec(properties) {
+            this.columnTypes = {};
+            if (properties)
+                for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                    if (properties[keys[i]] != null && keys[i] !== "__proto__")
+                        this[keys[i]] = properties[keys[i]];
+        }
+
+        /**
+         * ExtractSpec connectionName.
+         * @member {string} connectionName
+         * @memberof sqlanvil.ExtractSpec
+         * @instance
+         */
+        ExtractSpec.prototype.connectionName = "";
+
+        /**
+         * ExtractSpec platform.
+         * @member {string} platform
+         * @memberof sqlanvil.ExtractSpec
+         * @instance
+         */
+        ExtractSpec.prototype.platform = "";
+
+        /**
+         * ExtractSpec project.
+         * @member {string} project
+         * @memberof sqlanvil.ExtractSpec
+         * @instance
+         */
+        ExtractSpec.prototype.project = "";
+
+        /**
+         * ExtractSpec dataset.
+         * @member {string} dataset
+         * @memberof sqlanvil.ExtractSpec
+         * @instance
+         */
+        ExtractSpec.prototype.dataset = "";
+
+        /**
+         * ExtractSpec sourceName.
+         * @member {string} sourceName
+         * @memberof sqlanvil.ExtractSpec
+         * @instance
+         */
+        ExtractSpec.prototype.sourceName = "";
+
+        /**
+         * ExtractSpec billingProject.
+         * @member {string} billingProject
+         * @memberof sqlanvil.ExtractSpec
+         * @instance
+         */
+        ExtractSpec.prototype.billingProject = "";
+
+        /**
+         * ExtractSpec columnTypes.
+         * @member {Object.<string,string>} columnTypes
+         * @memberof sqlanvil.ExtractSpec
+         * @instance
+         */
+        ExtractSpec.prototype.columnTypes = $util.emptyObject;
+
+        /**
+         * Creates a new ExtractSpec instance using the specified properties.
+         * @function create
+         * @memberof sqlanvil.ExtractSpec
+         * @static
+         * @param {sqlanvil.IExtractSpec=} [properties] Properties to set
+         * @returns {sqlanvil.ExtractSpec} ExtractSpec instance
+         */
+        ExtractSpec.create = function create(properties) {
+            return new ExtractSpec(properties);
+        };
+
+        /**
+         * Encodes the specified ExtractSpec message. Does not implicitly {@link sqlanvil.ExtractSpec.verify|verify} messages.
+         * @function encode
+         * @memberof sqlanvil.ExtractSpec
+         * @static
+         * @param {sqlanvil.IExtractSpec} message ExtractSpec message or plain object to encode
+         * @param {$protobuf.Writer} [writer] Writer to encode to
+         * @returns {$protobuf.Writer} Writer
+         */
+        ExtractSpec.encode = function encode(message, writer) {
+            if (!writer)
+                writer = $Writer.create();
+            if (message.connectionName != null && Object.hasOwnProperty.call(message, "connectionName"))
+                writer.uint32(/* id 1, wireType 2 =*/10).string(message.connectionName);
+            if (message.platform != null && Object.hasOwnProperty.call(message, "platform"))
+                writer.uint32(/* id 2, wireType 2 =*/18).string(message.platform);
+            if (message.project != null && Object.hasOwnProperty.call(message, "project"))
+                writer.uint32(/* id 3, wireType 2 =*/26).string(message.project);
+            if (message.dataset != null && Object.hasOwnProperty.call(message, "dataset"))
+                writer.uint32(/* id 4, wireType 2 =*/34).string(message.dataset);
+            if (message.sourceName != null && Object.hasOwnProperty.call(message, "sourceName"))
+                writer.uint32(/* id 5, wireType 2 =*/42).string(message.sourceName);
+            if (message.billingProject != null && Object.hasOwnProperty.call(message, "billingProject"))
+                writer.uint32(/* id 6, wireType 2 =*/50).string(message.billingProject);
+            if (message.columnTypes != null && Object.hasOwnProperty.call(message, "columnTypes"))
+                for (let keys = Object.keys(message.columnTypes), i = 0; i < keys.length; ++i)
+                    writer.uint32(/* id 7, wireType 2 =*/58).fork().uint32(/* id 1, wireType 2 =*/10).string(keys[i]).uint32(/* id 2, wireType 2 =*/18).string(message.columnTypes[keys[i]]).ldelim();
+            return writer;
+        };
+
+        /**
+         * Encodes the specified ExtractSpec message, length delimited. Does not implicitly {@link sqlanvil.ExtractSpec.verify|verify} messages.
+         * @function encodeDelimited
+         * @memberof sqlanvil.ExtractSpec
+         * @static
+         * @param {sqlanvil.IExtractSpec} message ExtractSpec message or plain object to encode
+         * @param {$protobuf.Writer} [writer] Writer to encode to
+         * @returns {$protobuf.Writer} Writer
+         */
+        ExtractSpec.encodeDelimited = function encodeDelimited(message, writer) {
+            return this.encode(message, writer).ldelim();
+        };
+
+        /**
+         * Decodes an ExtractSpec message from the specified reader or buffer.
+         * @function decode
+         * @memberof sqlanvil.ExtractSpec
+         * @static
+         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+         * @param {number} [length] Message length if known beforehand
+         * @returns {sqlanvil.ExtractSpec} ExtractSpec
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        ExtractSpec.decode = function decode(reader, length, error, long) {
+            if (!(reader instanceof $Reader))
+                reader = $Reader.create(reader);
+            if (long === undefined)
+                long = 0;
+            if (long > $Reader.recursionLimit)
+                throw Error("maximum nesting depth exceeded");
+            let end = length === undefined ? reader.len : reader.pos + length, message = new $root.sqlanvil.ExtractSpec(), key, value;
+            while (reader.pos < end) {
+                let tag = reader.uint32();
+                if (tag === error)
+                    break;
+                switch (tag >>> 3) {
+                case 1: {
+                        message.connectionName = reader.string();
+                        break;
+                    }
+                case 2: {
+                        message.platform = reader.string();
+                        break;
+                    }
+                case 3: {
+                        message.project = reader.string();
+                        break;
+                    }
+                case 4: {
+                        message.dataset = reader.string();
+                        break;
+                    }
+                case 5: {
+                        message.sourceName = reader.string();
+                        break;
+                    }
+                case 6: {
+                        message.billingProject = reader.string();
+                        break;
+                    }
+                case 7: {
+                        if (message.columnTypes === $util.emptyObject)
+                            message.columnTypes = {};
+                        let end2 = reader.uint32() + reader.pos;
+                        key = "";
+                        value = "";
+                        while (reader.pos < end2) {
+                            let tag2 = reader.uint32();
+                            switch (tag2 >>> 3) {
+                            case 1:
+                                key = reader.string();
+                                break;
+                            case 2:
+                                value = reader.string();
+                                break;
+                            default:
+                                reader.skipType(tag2 & 7, long);
+                                break;
+                            }
+                        }
+                        if (key === "__proto__")
+                            $util.makeProp(message.columnTypes, key);
+                        message.columnTypes[key] = value;
+                        break;
+                    }
+                default:
+                    reader.skipType(tag & 7, long);
+                    break;
+                }
+            }
+            return message;
+        };
+
+        /**
+         * Decodes an ExtractSpec message from the specified reader or buffer, length delimited.
+         * @function decodeDelimited
+         * @memberof sqlanvil.ExtractSpec
+         * @static
+         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+         * @returns {sqlanvil.ExtractSpec} ExtractSpec
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        ExtractSpec.decodeDelimited = function decodeDelimited(reader) {
+            if (!(reader instanceof $Reader))
+                reader = new $Reader(reader);
+            return this.decode(reader, reader.uint32());
+        };
+
+        /**
+         * Verifies an ExtractSpec message.
+         * @function verify
+         * @memberof sqlanvil.ExtractSpec
+         * @static
+         * @param {Object.<string,*>} message Plain object to verify
+         * @returns {string|null} `null` if valid, otherwise the reason why it is not
+         */
+        ExtractSpec.verify = function verify(message, long) {
+            if (typeof message !== "object" || message === null)
+                return "object expected";
+            if (long === undefined)
+                long = 0;
+            if (long > $util.recursionLimit)
+                return "maximum nesting depth exceeded";
+            if (message.connectionName != null && message.hasOwnProperty("connectionName"))
+                if (!$util.isString(message.connectionName))
+                    return "connectionName: string expected";
+            if (message.platform != null && message.hasOwnProperty("platform"))
+                if (!$util.isString(message.platform))
+                    return "platform: string expected";
+            if (message.project != null && message.hasOwnProperty("project"))
+                if (!$util.isString(message.project))
+                    return "project: string expected";
+            if (message.dataset != null && message.hasOwnProperty("dataset"))
+                if (!$util.isString(message.dataset))
+                    return "dataset: string expected";
+            if (message.sourceName != null && message.hasOwnProperty("sourceName"))
+                if (!$util.isString(message.sourceName))
+                    return "sourceName: string expected";
+            if (message.billingProject != null && message.hasOwnProperty("billingProject"))
+                if (!$util.isString(message.billingProject))
+                    return "billingProject: string expected";
+            if (message.columnTypes != null && message.hasOwnProperty("columnTypes")) {
+                if (!$util.isObject(message.columnTypes))
+                    return "columnTypes: object expected";
+                let key = Object.keys(message.columnTypes);
+                for (let i = 0; i < key.length; ++i)
+                    if (!$util.isString(message.columnTypes[key[i]]))
+                        return "columnTypes: string{k:string} expected";
+            }
+            return null;
+        };
+
+        /**
+         * Creates an ExtractSpec message from a plain object. Also converts values to their respective internal types.
+         * @function fromObject
+         * @memberof sqlanvil.ExtractSpec
+         * @static
+         * @param {Object.<string,*>} object Plain object
+         * @returns {sqlanvil.ExtractSpec} ExtractSpec
+         */
+        ExtractSpec.fromObject = function fromObject(object, long) {
+            if (object instanceof $root.sqlanvil.ExtractSpec)
+                return object;
+            if (long === undefined)
+                long = 0;
+            if (long > $util.recursionLimit)
+                throw Error("maximum nesting depth exceeded");
+            let message = new $root.sqlanvil.ExtractSpec();
+            if (object.connectionName != null)
+                message.connectionName = String(object.connectionName);
+            if (object.platform != null)
+                message.platform = String(object.platform);
+            if (object.project != null)
+                message.project = String(object.project);
+            if (object.dataset != null)
+                message.dataset = String(object.dataset);
+            if (object.sourceName != null)
+                message.sourceName = String(object.sourceName);
+            if (object.billingProject != null)
+                message.billingProject = String(object.billingProject);
+            if (object.columnTypes) {
+                if (typeof object.columnTypes !== "object")
+                    throw TypeError(".sqlanvil.ExtractSpec.columnTypes: object expected");
+                message.columnTypes = {};
+                for (let keys = Object.keys(object.columnTypes), i = 0; i < keys.length; ++i) {
+                    if (keys[i] === "__proto__")
+                        $util.makeProp(message.columnTypes, keys[i]);
+                    message.columnTypes[keys[i]] = String(object.columnTypes[keys[i]]);
+                }
+            }
+            return message;
+        };
+
+        /**
+         * Creates a plain object from an ExtractSpec message. Also converts values to other types if specified.
+         * @function toObject
+         * @memberof sqlanvil.ExtractSpec
+         * @static
+         * @param {sqlanvil.ExtractSpec} message ExtractSpec
+         * @param {$protobuf.IConversionOptions} [options] Conversion options
+         * @returns {Object.<string,*>} Plain object
+         */
+        ExtractSpec.toObject = function toObject(message, options) {
+            if (!options)
+                options = {};
+            let object = {};
+            if (options.objects || options.defaults)
+                object.columnTypes = {};
+            if (options.defaults) {
+                object.connectionName = "";
+                object.platform = "";
+                object.project = "";
+                object.dataset = "";
+                object.sourceName = "";
+                object.billingProject = "";
+            }
+            if (message.connectionName != null && message.hasOwnProperty("connectionName"))
+                object.connectionName = message.connectionName;
+            if (message.platform != null && message.hasOwnProperty("platform"))
+                object.platform = message.platform;
+            if (message.project != null && message.hasOwnProperty("project"))
+                object.project = message.project;
+            if (message.dataset != null && message.hasOwnProperty("dataset"))
+                object.dataset = message.dataset;
+            if (message.sourceName != null && message.hasOwnProperty("sourceName"))
+                object.sourceName = message.sourceName;
+            if (message.billingProject != null && message.hasOwnProperty("billingProject"))
+                object.billingProject = message.billingProject;
+            let keys2;
+            if (message.columnTypes && (keys2 = Object.keys(message.columnTypes)).length) {
+                object.columnTypes = {};
+                for (let j = 0; j < keys2.length; ++j) {
+                    if (keys2[j] === "__proto__")
+                        $util.makeProp(object.columnTypes, keys2[j]);
+                    object.columnTypes[keys2[j]] = message.columnTypes[keys2[j]];
+                }
+            }
+            return object;
+        };
+
+        /**
+         * Converts this ExtractSpec to JSON.
+         * @function toJSON
+         * @memberof sqlanvil.ExtractSpec
+         * @instance
+         * @returns {Object.<string,*>} JSON object
+         */
+        ExtractSpec.prototype.toJSON = function toJSON() {
+            return this.constructor.toObject(this, $protobuf__namespace.util.toJSONOptions);
+        };
+
+        /**
+         * Gets the default type url for ExtractSpec
+         * @function getTypeUrl
+         * @memberof sqlanvil.ExtractSpec
+         * @static
+         * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+         * @returns {string} The default type url
+         */
+        ExtractSpec.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+            if (typeUrlPrefix === undefined) {
+                typeUrlPrefix = "type.googleapis.com";
+            }
+            return typeUrlPrefix + "/sqlanvil.ExtractSpec";
+        };
+
+        return ExtractSpec;
+    })();
+
     sqlanvil.ExecutionAction = (function() {
 
         /**
@@ -36200,6 +37330,7 @@ const sqlanvil = $root.sqlanvil = (() => {
          * @property {string|null} [jitCode] ExecutionAction jitCode
          * @property {sqlanvil.IExportSpec|null} ["export"] ExecutionAction export
          * @property {sqlanvil.IImportSpec|null} ["import"] ExecutionAction import
+         * @property {sqlanvil.IExtractSpec|null} [extract] ExecutionAction extract
          */
 
         /**
@@ -36307,6 +37438,14 @@ const sqlanvil = $root.sqlanvil = (() => {
          */
         ExecutionAction.prototype["import"] = null;
 
+        /**
+         * ExecutionAction extract.
+         * @member {sqlanvil.IExtractSpec|null|undefined} extract
+         * @memberof sqlanvil.ExecutionAction
+         * @instance
+         */
+        ExecutionAction.prototype.extract = null;
+
         /**
          * Creates a new ExecutionAction instance using the specified properties.
          * @function create
@@ -36355,6 +37494,8 @@ const sqlanvil = $root.sqlanvil = (() => {
                 $root.sqlanvil.ExportSpec.encode(message["export"], writer.uint32(/* id 13, wireType 2 =*/106).fork()).ldelim();
             if (message["import"] != null && Object.hasOwnProperty.call(message, "import"))
                 $root.sqlanvil.ImportSpec.encode(message["import"], writer.uint32(/* id 14, wireType 2 =*/114).fork()).ldelim();
+            if (message.extract != null && Object.hasOwnProperty.call(message, "extract"))
+                $root.sqlanvil.ExtractSpec.encode(message.extract, writer.uint32(/* id 15, wireType 2 =*/122).fork()).ldelim();
             return writer;
         };
 
@@ -36443,6 +37584,10 @@ const sqlanvil = $root.sqlanvil = (() => {
                         message["import"] = $root.sqlanvil.ImportSpec.decode(reader, reader.uint32(), undefined, long + 1);
                         break;
                     }
+                case 15: {
+                        message.extract = $root.sqlanvil.ExtractSpec.decode(reader, reader.uint32(), undefined, long + 1);
+                        break;
+                    }
                 default:
                     reader.skipType(tag & 7, long);
                     break;
@@ -36541,6 +37686,11 @@ const sqlanvil = $root.sqlanvil = (() => {
                 if (error)
                     return "import." + error;
             }
+            if (message.extract != null && message.hasOwnProperty("extract")) {
+                let error = $root.sqlanvil.ExtractSpec.verify(message.extract, long + 1);
+                if (error)
+                    return "extract." + error;
+            }
             return null;
         };
 
@@ -36628,6 +37778,11 @@ const sqlanvil = $root.sqlanvil = (() => {
                     throw TypeError(".sqlanvil.ExecutionAction.import: object expected");
                 message["import"] = $root.sqlanvil.ImportSpec.fromObject(object["import"], long + 1);
             }
+            if (object.extract != null) {
+                if (typeof object.extract !== "object")
+                    throw TypeError(".sqlanvil.ExecutionAction.extract: object expected");
+                message.extract = $root.sqlanvil.ExtractSpec.fromObject(object.extract, long + 1);
+            }
             return message;
         };
 
@@ -36658,6 +37813,7 @@ const sqlanvil = $root.sqlanvil = (() => {
                 object.jitCode = "";
                 object["export"] = null;
                 object["import"] = null;
+                object.extract = null;
             }
             if (message.tasks && message.tasks.length) {
                 object.tasks = [];
@@ -36687,6 +37843,8 @@ const sqlanvil = $root.sqlanvil = (() => {
                 object["export"] = $root.sqlanvil.ExportSpec.toObject(message["export"], options);
             if (message["import"] != null && message.hasOwnProperty("import"))
                 object["import"] = $root.sqlanvil.ImportSpec.toObject(message["import"], options);
+            if (message.extract != null && message.hasOwnProperty("extract"))
+                object.extract = $root.sqlanvil.ExtractSpec.toObject(message.extract, options);
             return object;
         };
 
@@ -43305,6 +44463,7 @@ const sqlanvil = $root.sqlanvil = (() => {
          * @property {string|null} [projectId] BigQuery projectId
          * @property {string|null} [credentials] BigQuery credentials
          * @property {string|null} [location] BigQuery location
+         * @property {string|null} [accessToken] BigQuery accessToken
          */
 
         /**
@@ -43346,6 +44505,14 @@ const sqlanvil = $root.sqlanvil = (() => {
          */
         BigQuery.prototype.location = "";
 
+        /**
+         * BigQuery accessToken.
+         * @member {string} accessToken
+         * @memberof sqlanvil.BigQuery
+         * @instance
+         */
+        BigQuery.prototype.accessToken = "";
+
         /**
          * Creates a new BigQuery instance using the specified properties.
          * @function create
@@ -43376,6 +44543,8 @@ const sqlanvil = $root.sqlanvil = (() => {
                 writer.uint32(/* id 3, wireType 2 =*/26).string(message.credentials);
             if (message.location != null && Object.hasOwnProperty.call(message, "location"))
                 writer.uint32(/* id 4, wireType 2 =*/34).string(message.location);
+            if (message.accessToken != null && Object.hasOwnProperty.call(message, "accessToken"))
+                writer.uint32(/* id 5, wireType 2 =*/42).string(message.accessToken);
             return writer;
         };
 
@@ -43428,6 +44597,10 @@ const sqlanvil = $root.sqlanvil = (() => {
                         message.location = reader.string();
                         break;
                     }
+                case 5: {
+                        message.accessToken = reader.string();
+                        break;
+                    }
                 default:
                     reader.skipType(tag & 7, long);
                     break;
@@ -43476,6 +44649,9 @@ const sqlanvil = $root.sqlanvil = (() => {
             if (message.location != null && message.hasOwnProperty("location"))
                 if (!$util.isString(message.location))
                     return "location: string expected";
+            if (message.accessToken != null && message.hasOwnProperty("accessToken"))
+                if (!$util.isString(message.accessToken))
+                    return "accessToken: string expected";
             return null;
         };
 
@@ -43501,6 +44677,8 @@ const sqlanvil = $root.sqlanvil = (() => {
                 message.credentials = String(object.credentials);
             if (object.location != null)
                 message.location = String(object.location);
+            if (object.accessToken != null)
+                message.accessToken = String(object.accessToken);
             return message;
         };
 
@@ -43521,6 +44699,7 @@ const sqlanvil = $root.sqlanvil = (() => {
                 object.projectId = "";
                 object.credentials = "";
                 object.location = "";
+                object.accessToken = "";
             }
             if (message.projectId != null && message.hasOwnProperty("projectId"))
                 object.projectId = message.projectId;
@@ -43528,6 +44707,8 @@ const sqlanvil = $root.sqlanvil = (() => {
                 object.credentials = message.credentials;
             if (message.location != null && message.hasOwnProperty("location"))
                 object.location = message.location;
+            if (message.accessToken != null && message.hasOwnProperty("accessToken"))
+                object.accessToken = message.accessToken;
             return object;
         };
 
@@ -46342,7 +47523,7 @@ function collectEvaluationQueries(queryOrAction, concatenate, queryModifier = (q
         .filter(validationQuery => !!validationQuery.query);
 }
 
-const version = "1.13.0";
+const version = "1.15.0";
 const dataformVersion = "3.0.60";
 
 async function build(compiledGraph, runConfig, dbadapter) {
@@ -46366,7 +47547,7 @@ class Builder {
         this.warehouseState.tables.forEach(tableState => {
             tableMetadataByTarget.set(targetStringifier.stringify(tableState.target), tableState);
         });
-        const actions = [].concat(this.prunedGraph.tables.map(t => this.buildTable(t, tableMetadataByTarget.get(targetStringifier.stringify(t.target)), this.runConfig)), this.prunedGraph.operations.map(o => this.buildOperation(o)), this.prunedGraph.assertions.map(a => this.buildAssertion(a)), this.prunedGraph.exports.map(e => this.buildExport(e)), this.prunedGraph.imports.map(i => this.buildImport(i)));
+        const actions = [].concat(this.prunedGraph.tables.map(t => this.buildTable(t, tableMetadataByTarget.get(targetStringifier.stringify(t.target)), this.runConfig)), this.prunedGraph.operations.map(o => this.buildOperation(o)), this.prunedGraph.assertions.map(a => this.buildAssertion(a)), this.prunedGraph.exports.map(e => this.buildExport(e)), this.prunedGraph.imports.map(i => this.buildImport(i)), this.prunedGraph.extracts.map(e => this.buildExtract(e)));
         return sqlanvil.ExecutionGraph.create({
             projectConfig: this.prunedGraph.projectConfig,
             runConfig: this.runConfig,
@@ -46402,6 +47583,17 @@ class Builder {
                 options: imp.options
             }) });
     }
+    buildExtract(ext) {
+        return Object.assign(Object.assign({}, this.toPartialExecutionAction(ext)), { type: "extract", tasks: ext.disabled ? [] : [sqlanvil.ExecutionTask.create({ type: "extract", statement: "" })], hermeticity: ext.hermeticity || sqlanvil.ActionHermeticity.NON_HERMETIC, extract: sqlanvil.ExtractSpec.create({
+                connectionName: ext.connectionName,
+                platform: ext.platform,
+                project: ext.project,
+                dataset: ext.dataset,
+                sourceName: ext.sourceName,
+                billingProject: ext.billingProject,
+                columnTypes: ext.columnTypes
+            }) });
+    }
     toPartialExecutionAction(action) {
         return sqlanvil.ExecutionAction.create({
             target: action.target,
@@ -47061,319 +48253,1250 @@ function assertConnectionCredentialsAvailable(graph, connections) {
     }));
 }
 
-function loadDuckdb() {
-    try {
-        return nativeRequire("@duckdb/node-api");
-    }
-    catch (e) {
-        throw new Error(`This feature requires the optional "@duckdb/node-api" dependency, which failed to load: ` +
-            `${e.message}`);
-    }
-}
-async function runAsync(conn, sql) {
-    await conn.run(sql);
-}
-async function allAsync(conn, sql) {
-    const reader = await conn.runAndReadAll(sql);
-    return reader.getRowObjects();
+function parsePostgresEvalError(_query, error) {
+    return sqlanvil.QueryEvaluationError.create({
+        message: (error === null || error === void 0 ? void 0 : error.message) ? String(error.message) : String(error)
+    });
 }
-async function withDuckdb(fn, dbPath = ":memory:") {
-    const { DuckDBInstance } = loadDuckdb();
-    const instance = await DuckDBInstance.create(dbPath);
-    const conn = await instance.connect();
-    const done = () => {
-        var _a, _b;
-        try {
-            (_a = conn.closeSync) === null || _a === void 0 ? void 0 : _a.call(conn);
-        }
-        catch (e) {
-        }
-        try {
-            (_b = instance.closeSync) === null || _b === void 0 ? void 0 : _b.call(instance);
-        }
-        catch (e) {
-        }
-    };
+function parseBigqueryEvalError(error) {
+    const evalError = sqlanvil.QueryEvaluationError.create({
+        message: String(error)
+    });
     try {
-        if (!process.env.HOME) {
-            await runAsync(conn, `SET home_directory='${os__namespace.tmpdir()}'`);
+        if (!error.message) {
+            return evalError;
+        }
+        const bracketsString = error.message.split("[").slice(-1)[0];
+        const [_, lineNumber, columnNumber] = bracketsString.match(/([0-9]*)[^0-9]*([0-9]*).*/);
+        const line = Number(lineNumber);
+        const column = Number(columnNumber);
+        if (line || line === 0) {
+            evalError.errorLocation = { line, column };
         }
-        const result = await fn(conn);
-        done();
-        return result;
     }
-    catch (e) {
-        done();
-        throw e;
+    catch (_) {
     }
+    return evalError;
 }
 
-const PG_ATTACH_ALIAS = "pg";
-const SECRET_NAME = "sa_export";
-function buildAttachSql(pg, opts = {}) {
-    const readOnly = opts.readOnly !== false;
-    const dsn = [
-        pg.host && `host=${pg.host}`,
-        pg.port && `port=${pg.port}`,
-        pg.database && `dbname=${pg.database}`,
-        pg.user && `user=${pg.user}`,
-        pg.password && `password=${pg.password}`
-    ]
-        .filter(Boolean)
-        .join(" ");
-    const mode = readOnly ? ", READ_ONLY" : "";
-    return `ATTACH '${dsn}' AS ${PG_ATTACH_ALIAS} (TYPE postgres${mode})`;
-}
-function buildSecretSql(scheme, creds) {
-    if (scheme === "s3") {
-        const fields = [
-            "TYPE s3",
-            creds.accessKeyId && `KEY_ID '${creds.accessKeyId}'`,
-            creds.secretAccessKey && `SECRET '${creds.secretAccessKey}'`,
-            creds.region && `REGION '${creds.region}'`,
-            creds.endpoint && `ENDPOINT '${creds.endpoint}'`,
-            creds.endpoint && `URL_STYLE 'path'`,
-            creds.endpoint && `USE_SSL true`
-        ]
-            .filter(Boolean)
-            .join(", ");
-        return `CREATE OR REPLACE SECRET ${SECRET_NAME} (${fields})`;
-    }
-    if (scheme === "gcs") {
-        const fields = [
-            "TYPE gcs",
-            creds.keyId && `KEY_ID '${creds.keyId}'`,
-            creds.secret && `SECRET '${creds.secret}'`
-        ]
-            .filter(Boolean)
-            .join(", ");
-        return `CREATE OR REPLACE SECRET ${SECRET_NAME} (${fields})`;
-    }
-    return null;
-}
-function toCopyTarget(uri) {
-    if (uri.startsWith("local://")) {
-        return uri.slice("local://".length);
+class LimitedResultSet {
+    constructor(options) {
+        this.options = options;
+        this.results = [];
+        this.currentBytes = 0;
     }
-    return uri;
-}
-function schemeOf(uri) {
-    if (uri.startsWith("s3://")) {
-        return "s3";
+    push(row) {
+        var _a, _b, _c, _d;
+        this.currentBytes += sizeof__default["default"](row);
+        if ((((_a = this.options) === null || _a === void 0 ? void 0 : _a.rowLimit) && this.results.length >= ((_b = this.options) === null || _b === void 0 ? void 0 : _b.rowLimit)) ||
+            (((_c = this.options) === null || _c === void 0 ? void 0 : _c.byteLimit) && this.currentBytes >= ((_d = this.options) === null || _d === void 0 ? void 0 : _d.byteLimit))) {
+            return false;
+        }
+        this.results.push(row);
+        return true;
     }
-    if (uri.startsWith("gs://") || uri.startsWith("gcs://")) {
-        return "gcs";
+    get rows() {
+        return this.results;
     }
-    return "local";
-}
-function buildCopySql(selectSql, uri, format, options = {}) {
-    const target = toCopyTarget(uri);
-    const fmt = (format || "").toLowerCase();
-    const extraOptions = Object.entries(options || {}).map(([key, value]) => `${key.toUpperCase()} ${value}`);
-    const optionList = [`FORMAT ${fmt}`, ...extraOptions].join(", ");
-    return `COPY (SELECT * FROM postgres_query('${PG_ATTACH_ALIAS}', $sa$${selectSql}$sa$)) TO '${target}' (${optionList})`;
 }
-async function runDuckdbExport(args) {
-    const { spec, selectSql, pg, storage, actionName } = args;
-    const uri = resolveExportUri(spec, actionName, { wildcard: false });
-    const scheme = schemeOf(uri);
-    if (scheme !== "local" && !(storage === null || storage === void 0 ? void 0 : storage[scheme])) {
-        throw new Error(`No "${scheme}" storage credentials found in .df-credentials.json (storage.${scheme}) for ` +
-            `export to ${uri}.`);
-    }
-    return withDuckdb(async (conn) => {
-        await runAsync(conn, "INSTALL postgres; LOAD postgres; INSTALL httpfs; LOAD httpfs;");
-        await runAsync(conn, buildAttachSql(pg));
-        if (scheme !== "local") {
-            const secret = buildSecretSql(scheme, storage[scheme]);
-            if (secret) {
-                await runAsync(conn, secret);
+
+async function retry(fn, maxAttempts = 1, matchesRetriableError = () => true) {
+    let lastErr;
+    for (let i = 0; i < maxAttempts; i++) {
+        try {
+            return await fn();
+        }
+        catch (e) {
+            if (!matchesRetriableError(e)) {
+                throw e;
             }
+            lastErr = e;
         }
-        await runAsync(conn, buildCopySql(selectSql, uri, spec.format, spec.options || {}));
-        return { destination: toCopyTarget(uri) };
-    });
-}
-
-function readerForFormat(format) {
-    switch ((format || "").toLowerCase()) {
-        case "csv":
-            return "read_csv_auto";
-        case "json":
-            return "read_json_auto";
-        case "parquet":
-        default:
-            return "read_parquet";
     }
+    throw lastErr;
 }
-function importTargetSql(target) {
-    return target.schema
-        ? `${PG_ATTACH_ALIAS}."${target.schema}"."${target.name}"`
-        : `${PG_ATTACH_ALIAS}."${target.name}"`;
-}
-function buildImportSql(target, location, format, overwrite) {
-    const reader = readerForFormat(format);
-    const source = toCopyTarget(location);
-    const dest = importTargetSql(target);
-    const select = `SELECT * FROM ${reader}('${source}')`;
-    if (overwrite) {
-        return [`DROP TABLE IF EXISTS ${dest}`, `CREATE TABLE ${dest} AS ${select}`];
+
+const EXTRA_GOOGLE_SCOPES = ["https://www.googleapis.com/auth/drive"];
+function bigQueryClientOptions(credentials, projectId) {
+    const base = {
+        projectId,
+        scopes: EXTRA_GOOGLE_SCOPES,
+        location: credentials.location || undefined
+    };
+    if (credentials.accessToken) {
+        const authClient = new googleAuthLibrary.OAuth2Client();
+        authClient.setCredentials({ access_token: credentials.accessToken });
+        return Object.assign(Object.assign({}, base), { authClient: authClient });
     }
-    return [`INSERT INTO ${dest} ${select}`];
+    return Object.assign(Object.assign({}, base), { credentials: credentials.credentials ? JSON.parse(credentials.credentials) : undefined });
 }
-async function runDuckdbImport(args) {
-    const { spec, target, pg, storage } = args;
-    const location = spec.location || "";
-    const scheme = schemeOf(location);
-    if (scheme !== "local" && !(storage === null || storage === void 0 ? void 0 : storage[scheme])) {
-        throw new Error(`No "${scheme}" storage credentials found in .df-credentials.json (storage.${scheme}) for ` +
-            `import from ${location}.`);
+const BIGQUERY_DATE_RELATED_FIELDS = [
+    "BigQueryDate",
+    "BigQueryTime",
+    "BigQueryTimestamp",
+    "BigQueryDatetime"
+];
+const BIGQUERY_INTERNAL_ERROR_JOB_MAX_ATTEMPTS = 3;
+class BigQueryDbAdapter {
+    constructor(credentials, options) {
+        this.clients = new Map();
+        this.bigQueryCredentials = credentials;
+        this.bigqueryClient = options === null || options === void 0 ? void 0 : options.bigqueryClient;
+        this.pool = new promisePoolExecutor.PromisePoolExecutor({
+            concurrencyLimit: options === null || options === void 0 ? void 0 : options.concurrencyLimit,
+            frequencyWindow: 1000,
+            frequencyLimit: 30
+        });
     }
-    return withDuckdb(async (conn) => {
-        await runAsync(conn, "INSTALL postgres; LOAD postgres; INSTALL httpfs; LOAD httpfs;");
-        await runAsync(conn, buildAttachSql(pg, { readOnly: false }));
-        if (scheme !== "local") {
-            const secret = buildSecretSql(scheme, storage[scheme]);
-            if (secret) {
-                await runAsync(conn, secret);
-            }
-        }
-        for (const statement of buildImportSql(target, location, spec.format, spec.overwrite)) {
-            await runAsync(conn, statement);
-        }
-        return { source: toCopyTarget(location) };
-    });
-}
-
-function parseArgvFlags(argv) {
-    const parsedArgv = {};
-    const splitArgv = [];
-    for (let arg of argv) {
-        if (arg.startsWith("--no-")) {
-            arg = `--${arg.slice(5)}=false`;
-        }
-        if (arg.startsWith("--") && arg.includes("=")) {
-            splitArgv.push(arg.slice(0, arg.indexOf("=")));
-            splitArgv.push(arg.slice(arg.indexOf("=") + 1));
+    async execute(statement, options = { interactive: false, rowLimit: 1000, byteLimit: 1024 * 1024 }) {
+        var _a;
+        if ((options === null || options === void 0 ? void 0 : options.interactive) && ((_a = options === null || options === void 0 ? void 0 : options.bigquery) === null || _a === void 0 ? void 0 : _a.labels)) {
+            throw new Error("BigQuery job labels may not be set for interactive queries.");
         }
-        else {
-            splitArgv.push(arg);
+        if (!statement) {
+            throw new Error("Query string cannot be empty");
         }
+        return this.pool
+            .addSingleTask({
+            generator: () => {
+                var _a, _b, _c, _d, _e, _f;
+                return (options === null || options === void 0 ? void 0 : options.interactive) ? this.runQuery(statement, options === null || options === void 0 ? void 0 : options.params, options === null || options === void 0 ? void 0 : options.rowLimit, options === null || options === void 0 ? void 0 : options.byteLimit, (_a = options.bigquery) === null || _a === void 0 ? void 0 : _a.location)
+                    : this.createQueryJob(statement, options === null || options === void 0 ? void 0 : options.params, options === null || options === void 0 ? void 0 : options.rowLimit, options === null || options === void 0 ? void 0 : options.byteLimit, options === null || options === void 0 ? void 0 : options.onCancel, (_b = options === null || options === void 0 ? void 0 : options.bigquery) === null || _b === void 0 ? void 0 : _b.labels, (_c = options === null || options === void 0 ? void 0 : options.bigquery) === null || _c === void 0 ? void 0 : _c.location, (_d = options === null || options === void 0 ? void 0 : options.bigquery) === null || _d === void 0 ? void 0 : _d.jobPrefix, (_e = options === null || options === void 0 ? void 0 : options.bigquery) === null || _e === void 0 ? void 0 : _e.dryRun, (_f = options === null || options === void 0 ? void 0 : options.bigquery) === null || _f === void 0 ? void 0 : _f.reservation);
+            }
+        })
+            .promise();
     }
-    let currentFlagName = "";
-    for (const splitArg of splitArgv) {
-        if (splitArg.startsWith("--")) {
-            currentFlagName = splitArg.slice(2);
-            parsedArgv[currentFlagName] = "";
-        }
-        else if (currentFlagName) {
-            parsedArgv[currentFlagName] = splitArg;
-            currentFlagName = "";
+    async executeRaw(statement, options = { rowLimit: 1000 }) {
+        if (!statement) {
+            throw new Error("Query string cannot be empty");
         }
-    }
-    return parsedArgv;
-}
-class Flags {
-    static boolean(name, defaultValue = false) {
-        return new SingleValueFlag(name, defaultValue, (stringValue) => {
-            if (stringValue === "" || stringValue === "true") {
-                return true;
-            }
-            if (stringValue === "false") {
-                return false;
+        return this.pool
+            .addSingleTask({
+            generator: async () => {
+                var _a, _b;
+                const [rows, , apiResponse] = await this.getClient().query(Object.assign(Object.assign({}, this.prepareQueryOptions(statement, options.rowLimit, options.bigquery, options.params)), { skipParsing: true }));
+                const schema = (_b = (_a = apiResponse === null || apiResponse === void 0 ? void 0 : apiResponse.schema) === null || _a === void 0 ? void 0 : _a.fields) === null || _b === void 0 ? void 0 : _b.map((field) => convertField(field));
+                return { rows, schema, metadata: {} };
             }
-            throw Flags.invalidFlagValueError(name);
-        });
-    }
-    static string(name, defaultValue = "") {
-        return new SingleValueFlag(name, defaultValue, (stringValue) => stringValue);
-    }
-    static number(name, defaultValue = 0) {
-        return new SingleValueFlag(name, defaultValue, (stringValue) => parseFloat(stringValue));
-    }
-    static long(name, defaultValue = Long__default["default"].ZERO) {
-        return new SingleValueFlag(name, defaultValue, Long__default["default"].fromString);
-    }
-    static stringSet(name, defaultValue = new Set()) {
-        return new SetFlag(name, defaultValue, (singleValue) => singleValue);
+        })
+            .promise();
     }
-    static getRawFlagValue(flagName) {
-        return Flags.parsedArgv[flagName];
+    async withClientLock(callback) {
+        return await callback(this);
     }
-    static setRawFlagValueForTesting(flagName, value) {
-        Flags.parsedArgv[flagName] = value;
+    async evaluate(queryOrAction) {
+        const validationQueries = collectEvaluationQueries(queryOrAction, true);
+        return await Promise.all(validationQueries.map(async ({ query, incremental }) => {
+            try {
+                await this.pool
+                    .addSingleTask({
+                    generator: () => this.getClient().query({
+                        useLegacySql: false,
+                        query,
+                        dryRun: true
+                    })
+                })
+                    .promise();
+                return sqlanvil.QueryEvaluation.create({
+                    status: sqlanvil.QueryEvaluation.QueryEvaluationStatus.SUCCESS,
+                    incremental,
+                    query
+                });
+            }
+            catch (e) {
+                return {
+                    status: sqlanvil.QueryEvaluation.QueryEvaluationStatus.FAILURE,
+                    error: parseBigqueryEvalError(e),
+                    incremental,
+                    query
+                };
+            }
+        }));
     }
-    static invalidFlagValueError(flagName) {
-        return new Error(`Invalid flag value: ${Flags.getRawFlagValue(flagName)} [${flagName}]`);
+    async tables(database, schema) {
+        const datasetIds = schema ? [schema] : await this.schemas(database);
+        const tablesMetadata = [];
+        await Promise.all(datasetIds.map(async (datasetId) => {
+            const [tables] = await this.getClient(database)
+                .dataset(datasetId)
+                .getTables();
+            await Promise.all(tables.map(async (table) => {
+                const metadata = await this.table({
+                    database,
+                    schema: datasetId,
+                    name: table.id
+                });
+                if (metadata) {
+                    tablesMetadata.push(metadata);
+                }
+            }));
+        }));
+        return tablesMetadata;
     }
-}
-Flags.parsedArgv = parseArgvFlags(process.argv);
-class AbstractFlag {
-    constructor(name, defaultValue) {
-        this.name = name;
-        this.defaultValue = defaultValue;
-        this.parsed = {};
+    async search(searchText, options = { limit: 1000 }) {
+        const results = await this.execute(`select table_catalog, table_schema, table_name
+       from region-${this.bigQueryCredentials.location}.INFORMATION_SCHEMA.COLUMN_FIELD_PATHS
+       where regexp_contains(table_schema, @searchText) or regexp_contains(table_name, @searchText) or regexp_contains(field_path, @searchText)
+       group by 1, 2, 3`, {
+            params: {
+                searchText: `(?i)${searchText}`
+            },
+            interactive: true,
+            rowLimit: options.limit
+        });
+        return await Promise.all(results.rows.map(row => this.table({
+            database: row.table_catalog,
+            schema: row.table_schema,
+            name: row.table_name
+        })));
     }
-    get() {
-        if (Flags.getRawFlagValue(this.name) === undefined) {
-            return this.defaultValue;
+    async table(target) {
+        var _a;
+        const metadata = await this.getMetadata(target);
+        if (!metadata) {
+            return null;
         }
-        const stringValue = Flags.getRawFlagValue(this.name);
-        if (!(stringValue in this.parsed)) {
-            this.parsed[stringValue] = this.parse(stringValue);
+        if (metadata.tableReference.datasetId !== target.schema ||
+            metadata.tableReference.tableId !== target.name) {
+            const metadataTarget = {
+                database: metadata.tableReference.projectId,
+                schema: metadata.tableReference.datasetId,
+                name: metadata.tableReference.tableId
+            };
+            throw new Error(`Target ${JSON.stringify(metadataTarget)} does not match requested target ${JSON.stringify(target)}.`);
         }
-        return this.parsed[stringValue];
+        return sqlanvil.TableMetadata.create({
+            type: metadata.type === "TABLE"
+                ? sqlanvil.TableMetadata.Type.TABLE
+                : metadata.type === "VIEW"
+                    ? sqlanvil.TableMetadata.Type.VIEW
+                    : sqlanvil.TableMetadata.Type.UNKNOWN,
+            target,
+            fields: (_a = metadata.schema.fields) === null || _a === void 0 ? void 0 : _a.map(field => convertField(field)),
+            lastUpdatedMillis: Long__default["default"].fromString(metadata.lastModifiedTime),
+            description: metadata.description,
+            labels: metadata.labels,
+            bigquery: {
+                hasStreamingBuffer: !!metadata.streamingBuffer
+            }
+        });
     }
-}
-class SingleValueFlag extends AbstractFlag {
-    constructor(name, defaultValue, parser) {
-        super(name, defaultValue);
-        this.parser = parser;
+    async deleteTable(target) {
+        await this.getClient(target.database)
+            .dataset(target.schema)
+            .table(target.name)
+            .delete({ ignoreNotFound: true });
     }
-    parse(stringValue) {
-        return this.parser(stringValue);
+    async schemas(database) {
+        const data = await this.getClient(database).getDatasets();
+        return data[0].map(dataset => dataset.id);
     }
-}
-class SetFlag extends AbstractFlag {
-    constructor(name, defaultValue, parser) {
-        super(name, defaultValue);
-        this.parser = parser;
+    async createSchema(database, schema) {
+        await this.execute(`create schema if not exists \`${database || this.bigQueryCredentials.projectId}.${schema}\``, { bigquery: { location: this.bigQueryCredentials.location } });
     }
-    parse(stringValue) {
-        return new Set(stringValue
-            .split(",")
-            .filter(singleValue => singleValue.length > 0)
-            .map(this.parser));
+    async setMetadata(action) {
+        const { target, actionDescriptor } = action;
+        const metadata = await this.getMetadata(target);
+        const schemaWithDescription = addDescriptionToMetadata(actionDescriptor.columns, metadata.schema.fields);
+        await this.getClient(target.database)
+            .dataset(target.schema)
+            .table(target.name)
+            .setMetadata({
+            description: actionDescriptor.description,
+            schema: schemaWithDescription,
+            labels: actionDescriptor.bigqueryLabels
+        });
     }
-}
-
-async function retry(fn, maxAttempts = 1, matchesRetriableError = () => true) {
-    let lastErr;
-    for (let i = 0; i < maxAttempts; i++) {
+    async getMetadata(target) {
+        var _a, _b;
         try {
-            return await fn();
+            const table = await this.getClient(target.database)
+                .dataset(target.schema)
+                .table(target.name)
+                .getMetadata();
+            return table === null || table === void 0 ? void 0 : table[0];
         }
         catch (e) {
-            if (!matchesRetriableError(e)) {
-                throw e;
+            if (((_b = (_a = e === null || e === void 0 ? void 0 : e.errors) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.reason) === "notFound") {
+                return null;
             }
-            lastErr = e;
+            throw coerceAsError(e);
         }
     }
-    throw lastErr;
-}
-
-const CANCEL_EVENT = "jobCancel";
-const flags = {
-    runnerNotificationPeriodMillis: Flags.number("runner-notification-period-millis", 5000)
-};
-const isSuccessfulAction = (actionResult) => actionResult.status === sqlanvil.ActionResult.ExecutionStatus.SUCCESSFUL ||
-    actionResult.status === sqlanvil.ActionResult.ExecutionStatus.DISABLED;
-function run(dbadapter, graph, executionOptions, partiallyExecutedRunResult = {}, runnerNotificationPeriodMillis = flags.runnerNotificationPeriodMillis.get()) {
-    return new Runner(dbadapter, graph, executionOptions, partiallyExecutedRunResult, runnerNotificationPeriodMillis).execute();
-}
-class Runner {
-    constructor(dbadapter, graph, executionOptions = {}, partiallyExecutedRunResult = {}, runnerNotificationPeriodMillis = flags.runnerNotificationPeriodMillis.get()) {
+    getClient(projectId) {
+        if (this.bigqueryClient) {
+            return this.bigqueryClient;
+        }
+        projectId = projectId || this.bigQueryCredentials.projectId;
+        if (!this.clients.has(projectId)) {
+            this.clients.set(projectId, new bigquery.BigQuery(bigQueryClientOptions(this.bigQueryCredentials, projectId)));
+        }
+        return this.clients.get(projectId);
+    }
+    async runQuery(query, params, rowLimit, byteLimit, location) {
+        const results = await new Promise((resolve, reject) => {
+            const allRows = new LimitedResultSet({
+                rowLimit,
+                byteLimit
+            });
+            const stream = this.getClient().createQueryStream({
+                query,
+                params,
+                location
+            });
+            stream
+                .on("error", e => reject(coerceAsError(e)))
+                .on("data", row => {
+                if (!allRows.push(row)) {
+                    stream.end();
+                }
+            })
+                .on("end", () => {
+                resolve(allRows.rows);
+            });
+        });
+        return { rows: cleanRows(results), metadata: {} };
+    }
+    prepareQueryOptions(query, rowLimit, bigqueryOptions, params) {
+        return {
+            query,
+            useLegacySql: false,
+            jobPrefix: "sqlanvil-" + ((bigqueryOptions === null || bigqueryOptions === void 0 ? void 0 : bigqueryOptions.jobPrefix) ? `${bigqueryOptions.jobPrefix}-` : ""),
+            location: bigqueryOptions === null || bigqueryOptions === void 0 ? void 0 : bigqueryOptions.location,
+            maxResults: rowLimit,
+            labels: bigqueryOptions === null || bigqueryOptions === void 0 ? void 0 : bigqueryOptions.labels,
+            dryRun: bigqueryOptions === null || bigqueryOptions === void 0 ? void 0 : bigqueryOptions.dryRun,
+            reservation: bigqueryOptions === null || bigqueryOptions === void 0 ? void 0 : bigqueryOptions.reservation,
+            params
+        };
+    }
+    async createQueryJob(query, params, rowLimit, byteLimit, onCancel, labels, location, jobPrefix, dryRun, reservation) {
+        let isCancelled = false;
+        onCancel === null || onCancel === void 0 ? void 0 : onCancel(() => (isCancelled = true));
+        return retry(async () => {
+            try {
+                const job = await this.getClient().createQueryJob(this.prepareQueryOptions(query, rowLimit, {
+                    labels,
+                    location,
+                    jobPrefix,
+                    dryRun,
+                    reservation
+                }, params));
+                const resultStream = job[0].getQueryResultsStream();
+                return new Promise((resolve, reject) => {
+                    if (isCancelled) {
+                        resultStream.end();
+                        reject(new Error("Query cancelled."));
+                        return;
+                    }
+                    onCancel === null || onCancel === void 0 ? void 0 : onCancel(() => {
+                        resultStream.end();
+                        reject(new Error("Query cancelled."));
+                    });
+                    const results = new LimitedResultSet({
+                        rowLimit,
+                        byteLimit
+                    });
+                    resultStream
+                        .on("error", async (e) => {
+                        var _a, _b;
+                        if (dryRun && ((_a = e.message) === null || _a === void 0 ? void 0 : _a.includes("Not found: Job"))) {
+                            resolve({ rows: [], metadata: {} });
+                            return;
+                        }
+                        try {
+                            const [jobMetadata] = await job[0].getMetadata();
+                            if (!!((_b = jobMetadata.status) === null || _b === void 0 ? void 0 : _b.errorResult)) {
+                                const error = createBigQueryError(jobMetadata);
+                                reject(error);
+                            }
+                        }
+                        catch (metadataError) {
+                            reject(metadataError);
+                        }
+                        reject(e);
+                    })
+                        .on("data", row => {
+                        if (!results.push(row)) {
+                            resultStream.end();
+                        }
+                    })
+                        .on("end", async () => {
+                        var _a;
+                        try {
+                            const [jobMetadata] = await job[0].getMetadata();
+                            if (!!((_a = jobMetadata.status) === null || _a === void 0 ? void 0 : _a.errorResult)) {
+                                const error = createBigQueryError(jobMetadata);
+                                reject(error);
+                                return;
+                            }
+                            resolve({
+                                rows: results.rows,
+                                metadata: {
+                                    bigquery: {
+                                        jobId: jobMetadata.jobReference.jobId,
+                                        totalBytesBilled: jobMetadata.statistics.query.totalBytesBilled
+                                            ? Long__default["default"].fromString(jobMetadata.statistics.query.totalBytesBilled)
+                                            : Long__default["default"].ZERO,
+                                        totalBytesProcessed: jobMetadata.statistics.query.totalBytesProcessed
+                                            ? Long__default["default"].fromString(jobMetadata.statistics.query.totalBytesProcessed)
+                                            : Long__default["default"].ZERO,
+                                    }
+                                }
+                            });
+                        }
+                        catch (e) {
+                            reject(e);
+                        }
+                    });
+                });
+            }
+            catch (e) {
+                throw coerceAsError(e);
+            }
+        }, BIGQUERY_INTERNAL_ERROR_JOB_MAX_ATTEMPTS, e => { var _a; return (_a = e.message) === null || _a === void 0 ? void 0 : _a.includes("Retrying the job may solve the problem"); });
+    }
+}
+function cleanRows(rows) {
+    if (rows.length === 0) {
+        return rows;
+    }
+    const sampleData = rows[0];
+    const fieldsWithBigQueryDates = Object.keys(sampleData).filter(key => sampleData[key] &&
+        sampleData[key].constructor &&
+        BIGQUERY_DATE_RELATED_FIELDS.includes(sampleData[key].constructor.name));
+    fieldsWithBigQueryDates.forEach(dateField => {
+        rows.forEach(row => (row[dateField] = row[dateField] ? row[dateField].value : row[dateField]));
+    });
+    return rows;
+}
+function convertField(field) {
+    const result = {
+        name: field.name,
+        flags: field.mode === "REPEATED" ? [sqlanvil.Field.Flag.REPEATED] : [],
+        description: field.description
+    };
+    if (field.type === "RECORD" || field.type === "STRUCT") {
+        result.struct = sqlanvil.Fields.create({
+            fields: field.fields.map(innerField => convertField(innerField))
+        });
+    }
+    else {
+        result.primitive = convertFieldType$2(field.type);
+    }
+    return sqlanvil.Field.create(result);
+}
+function convertFieldType$2(type) {
+    switch (String(type).toUpperCase()) {
+        case "FLOAT":
+        case "FLOAT64":
+            return sqlanvil.Field.Primitive.FLOAT;
+        case "INTEGER":
+        case "INT64":
+            return sqlanvil.Field.Primitive.INTEGER;
+        case "NUMERIC":
+            return sqlanvil.Field.Primitive.NUMERIC;
+        case "BOOL":
+        case "BOOLEAN":
+            return sqlanvil.Field.Primitive.BOOLEAN;
+        case "STRING":
+            return sqlanvil.Field.Primitive.STRING;
+        case "DATE":
+            return sqlanvil.Field.Primitive.DATE;
+        case "DATETIME":
+            return sqlanvil.Field.Primitive.DATETIME;
+        case "TIMESTAMP":
+            return sqlanvil.Field.Primitive.TIMESTAMP;
+        case "TIME":
+            return sqlanvil.Field.Primitive.TIME;
+        case "BYTES":
+            return sqlanvil.Field.Primitive.BYTES;
+        case "GEOGRAPHY":
+            return sqlanvil.Field.Primitive.GEOGRAPHY;
+        case "BIGNUMERIC":
+            return sqlanvil.Field.Primitive.BIGNUMERIC;
+        case "JSON":
+            return sqlanvil.Field.Primitive.JSON;
+        case "INTERVAL":
+            return sqlanvil.Field.Primitive.INTERVAL;
+        default:
+            return sqlanvil.Field.Primitive.UNKNOWN;
+    }
+}
+function addDescriptionToMetadata(columnDescriptions, metadataArray) {
+    if (!columnDescriptions) {
+        return metadataArray;
+    }
+    const findDescription = (path) => columnDescriptions.find(column => column.path.join("") === path.join(""));
+    const mapDescriptionToMetadata = (metadata, path) => {
+        var _a;
+        const description = findDescription(path);
+        if (description) {
+            metadata.description = description.description;
+            if (((_a = description.bigqueryPolicyTags) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+                metadata.policyTags = {
+                    names: description.bigqueryPolicyTags
+                };
+            }
+        }
+        if (metadata.fields) {
+            metadata.fields = metadata.fields.map(nestedMetadata => mapDescriptionToMetadata(nestedMetadata, [...path, nestedMetadata.name]));
+        }
+        return metadata;
+    };
+    const newMetadata = metadataArray.map(metaItem => mapDescriptionToMetadata(metaItem, [metaItem.name]));
+    return newMetadata;
+}
+function createBigQueryError(jobMetadata) {
+    const error = new Error(jobMetadata.status.errorResult.message);
+    if (jobMetadata.jobReference && jobMetadata.jobReference.jobId) {
+        error.metadata = {
+            bigquery: {
+                jobId: jobMetadata.jobReference.jobId,
+            }
+        };
+    }
+    return error;
+}
+
+const maybeInitializePg = (() => {
+    let initialized = false;
+    return () => {
+        if (!initialized) {
+            initialized = true;
+            pg__namespace.types.setTypeParser(20, Number);
+        }
+    };
+})();
+class PgPoolExecutor {
+    constructor(clientConfig, options) {
+        maybeInitializePg();
+        this.pool = new pg__namespace.Pool(Object.assign(Object.assign({}, clientConfig), { max: options === null || options === void 0 ? void 0 : options.concurrencyLimit }));
+        this.pool.on("error", err => {
+            console.error("pg.Pool idle client error", err.message, err.stack);
+        });
+    }
+    async verifyConnection() {
+        const client = await this.pool.connect();
+        try {
+            await client.query("select 1");
+        }
+        finally {
+            client.release();
+        }
+    }
+    async withClientLock(callback) {
+        const client = await this.pool.connect();
+        let released = false;
+        const releaseOnce = (err) => {
+            if (released) {
+                return;
+            }
+            released = true;
+            try {
+                client.release(err);
+            }
+            catch (e) {
+                console.error("Error thrown when releasing pg.Client", e.message, e.stack);
+            }
+        };
+        try {
+            client.on("error", err => {
+                console.error("pg.Client client error", err.message, err.stack);
+                releaseOnce(err);
+            });
+            return await callback({
+                execute: async (statement, options = { rowLimit: 1000, byteLimit: 1024 * 1024 }) => {
+                    return await new Promise((resolve, reject) => {
+                        var _a;
+                        const query = client.query(new QueryStream__default["default"](statement, options === null || options === void 0 ? void 0 : options.params));
+                        const results = new LimitedResultSet({
+                            rowLimit: options === null || options === void 0 ? void 0 : options.rowLimit,
+                            byteLimit: options === null || options === void 0 ? void 0 : options.byteLimit
+                        });
+                        (_a = options === null || options === void 0 ? void 0 : options.onCancel) === null || _a === void 0 ? void 0 : _a.call(options, () => query.destroy(new Error("Query cancelled.")));
+                        query.on("data", (row) => {
+                            try {
+                                verifyUniqueColumnNames(query.cursor._result.fields);
+                            }
+                            catch (e) {
+                                query.destroy(e);
+                                return;
+                            }
+                            if (!results.push(row)) {
+                                query.cursor.close();
+                            }
+                        });
+                        query.on("error", err => {
+                            releaseOnce(err);
+                            reject(err);
+                        });
+                        query.on("end", () => {
+                            resolve(results.rows);
+                        });
+                    });
+                }
+            });
+        }
+        finally {
+            releaseOnce();
+        }
+    }
+    async close() {
+        await this.pool.end();
+    }
+}
+function verifyUniqueColumnNames(fields) {
+    const colNames = new Set();
+    fields.forEach(field => {
+        if (colNames.has(field.name)) {
+            throw new Error(`Ambiguous column name: ${field.name}`);
+        }
+        colNames.add(field.name);
+    });
+}
+function convertFieldType$1(type) {
+    switch (String(type).toUpperCase()) {
+        case "FLOAT":
+        case "FLOAT4":
+        case "FLOAT8":
+        case "DOUBLE PRECISION":
+        case "REAL":
+            return sqlanvil.Field.Primitive.FLOAT;
+        case "INTEGER":
+        case "INT":
+        case "INT2":
+        case "INT4":
+        case "INT8":
+        case "BIGINT":
+        case "SMALLINT":
+            return sqlanvil.Field.Primitive.INTEGER;
+        case "DECIMAL":
+        case "NUMERIC":
+            return sqlanvil.Field.Primitive.NUMERIC;
+        case "BOOLEAN":
+        case "BOOL":
+            return sqlanvil.Field.Primitive.BOOLEAN;
+        case "STRING":
+        case "VARCHAR":
+        case "CHAR":
+        case "CHARACTER":
+        case "CHARACTER VARYING":
+        case "NVARCHAR":
+        case "TEXT":
+        case "NCHAR":
+        case "BPCHAR":
+            return sqlanvil.Field.Primitive.STRING;
+        case "DATE":
+            return sqlanvil.Field.Primitive.DATE;
+        case "TIMESTAMP":
+        case "TIMESTAMPZ":
+        case "TIMESTAMP WITHOUT TIME ZONE":
+        case "TIMESTAMP WITH TIME ZONE":
+            return sqlanvil.Field.Primitive.TIMESTAMP;
+        default:
+            return sqlanvil.Field.Primitive.UNKNOWN;
+    }
+}
+
+const INTERNAL_SCHEMAS$1 = new Set(["information_schema", "pg_catalog", "pg_internal", "pg_toast"]);
+class PostgresDbAdapter {
+    constructor(queryExecutor) {
+        this.queryExecutor = queryExecutor;
+    }
+    static async create(credentials, options) {
+        const sslMode = (credentials.sslMode || "").toLowerCase();
+        const sslEnabled = !(options === null || options === void 0 ? void 0 : options.disableSslForTestsOnly) && sslMode !== "disable";
+        const clientConfig = {
+            host: credentials.host,
+            port: credentials.port,
+            database: credentials.database,
+            user: credentials.user,
+            password: credentials.password,
+            ssl: sslEnabled
+                ? {
+                    rejectUnauthorized: sslMode === "verify-ca" || sslMode === "verify-full"
+                }
+                : false
+        };
+        const queryExecutor = new PgPoolExecutor(clientConfig, options);
+        try {
+            await queryExecutor.verifyConnection();
+        }
+        catch (e) {
+            await queryExecutor.close().catch(() => undefined);
+            throw new ErrorWithCause(`Could not connect to Postgres at ${credentials.host}:${credentials.port} ` +
+                `as "${credentials.user}": ${e.message}`, e);
+        }
+        return new PostgresDbAdapter(queryExecutor);
+    }
+    async execute(statement, options = { rowLimit: 1000, byteLimit: 1024 * 1024 }) {
+        return await this.withClientLock(client => client.execute(statement, options));
+    }
+    async executeRaw(statement, options = { rowLimit: 1000 }) {
+        const result = await this.execute(statement, options);
+        return Object.assign(Object.assign({}, result), { schema: [] });
+    }
+    async withClientLock(callback) {
+        return await this.queryExecutor.withClientLock(client => callback({
+            execute: async (stmt, opts = { rowLimit: 1000, byteLimit: 1024 * 1024 }) => {
+                try {
+                    const rows = await client.execute(stmt, opts);
+                    return { rows, metadata: {} };
+                }
+                catch (e) {
+                    if (opts.includeQueryInError) {
+                        throw new Error(`Error encountered while running "${stmt}": ${e.message}`);
+                    }
+                    throw new ErrorWithCause(`Error executing postgres query: ${e.message}`, e);
+                }
+            },
+            executeRaw: async (stmt, opts = { rowLimit: 1000 }) => {
+                const positional = opts.params ? Object.values(opts.params) : undefined;
+                const rows = await client.execute(stmt, { params: positional, rowLimit: opts.rowLimit });
+                return { rows, schema: [], metadata: {} };
+            }
+        }));
+    }
+    async evaluate(queryOrAction) {
+        const validationQueries = collectEvaluationQueries(queryOrAction, false, (query) => !!query ? `explain ${query}` : "").map((validationQuery, index) => ({ index, validationQuery }));
+        const validationQueriesWithoutWrappers = collectEvaluationQueries(queryOrAction, false);
+        const queryEvaluations = new Array();
+        for (const { index, validationQuery } of validationQueries) {
+            let evaluationResponse = {
+                status: sqlanvil.QueryEvaluation.QueryEvaluationStatus.SUCCESS
+            };
+            try {
+                await this.execute(validationQuery.query);
+            }
+            catch (e) {
+                evaluationResponse = {
+                    status: sqlanvil.QueryEvaluation.QueryEvaluationStatus.FAILURE,
+                    error: parsePostgresEvalError(validationQuery.query, e)
+                };
+            }
+            queryEvaluations.push(sqlanvil.QueryEvaluation.create(Object.assign(Object.assign({}, evaluationResponse), { incremental: validationQuery.incremental, query: validationQueriesWithoutWrappers[index].query })));
+        }
+        return queryEvaluations;
+    }
+    async tables(_database, schema) {
+        const params = [];
+        let schemaClause = "";
+        let matviewSchemaClause = "";
+        if (schema) {
+            schemaClause = "and table_schema = $1";
+            matviewSchemaClause = "and schemaname = $1";
+            params.push(schema);
+        }
+        const queryResult = await this.execute(`select table_name, table_schema
+       from information_schema.tables
+       where table_schema not in ('information_schema', 'pg_catalog', 'pg_internal', 'pg_toast')
+       ${schemaClause}
+       union
+       select matviewname as table_name, schemaname as table_schema
+       from pg_matviews
+       where schemaname not in ('information_schema', 'pg_catalog', 'pg_internal', 'pg_toast')
+       ${matviewSchemaClause}`, { params, rowLimit: 10000, includeQueryInError: true });
+        const targets = queryResult.rows.map(row => ({
+            schema: row.table_schema,
+            name: row.table_name
+        }));
+        return await Promise.all(targets.map(target => this.table(target)));
+    }
+    async search(searchText, options = { limit: 1000 }) {
+        const results = await this.execute(`select tables.table_schema as table_schema, tables.table_name as table_name
+       from information_schema.tables as tables
+       left join information_schema.columns columns
+         on tables.table_schema = columns.table_schema
+         and tables.table_name = columns.table_name
+       where tables.table_schema ilike $1
+          or tables.table_name ilike $1
+          or columns.column_name ilike $1
+       group by 1, 2`, {
+            params: [`%${searchText}%`],
+            rowLimit: options.limit
+        });
+        return await Promise.all(results.rows.map(row => this.table({
+            schema: row.table_schema,
+            name: row.table_name
+        })));
+    }
+    async table(target) {
+        const params = [target.schema, target.name];
+        const [tableResults, columnResults, descriptionResults, matviewResults, matviewColumns] = await Promise.all([
+            this.execute(`select table_type from information_schema.tables where table_schema = $1 and table_name = $2`, { params, includeQueryInError: true }),
+            this.execute(`select column_name, data_type, is_nullable, ordinal_position
+           from information_schema.columns
+           where table_schema = $1 and table_name = $2`, { params, includeQueryInError: true }),
+            this.execute(`select objsubid as column_number, description
+           from pg_description
+           where objoid = (
+             select oid from pg_class where relname = $2 and relnamespace = (
+               select oid from pg_namespace where nspname = $1
+             )
+           )`, { params, includeQueryInError: true }),
+            this.execute(`select 1 from pg_matviews where schemaname = $1 and matviewname = $2`, { params, includeQueryInError: true }),
+            this.execute(`select a.attname as column_name, format_type(a.atttypid, a.atttypmod) as data_type,
+                  a.attnum as ordinal_position
+           from pg_attribute a
+           join pg_class c on c.oid = a.attrelid
+           join pg_namespace n on n.oid = c.relnamespace
+           where n.nspname = $1 and c.relname = $2 and a.attnum > 0 and not a.attisdropped
+           order by a.attnum`, { params, includeQueryInError: true })
+        ]);
+        const findDescription = (columnNumber) => { var _a; return (_a = descriptionResults.rows.find(row => row.column_number === columnNumber)) === null || _a === void 0 ? void 0 : _a.description; };
+        if (tableResults.rows.length > 0) {
+            return sqlanvil.TableMetadata.create({
+                target,
+                type: tableResults.rows[0].table_type === "VIEW"
+                    ? sqlanvil.TableMetadata.Type.VIEW
+                    : sqlanvil.TableMetadata.Type.TABLE,
+                fields: columnResults.rows.map(row => sqlanvil.Field.create({
+                    name: row.column_name,
+                    primitive: convertFieldType$1(row.data_type),
+                    description: findDescription(row.ordinal_position)
+                })),
+                description: findDescription(0)
+            });
+        }
+        if (matviewResults.rows.length > 0) {
+            return sqlanvil.TableMetadata.create({
+                target,
+                type: sqlanvil.TableMetadata.Type.MATERIALIZED_VIEW,
+                fields: matviewColumns.rows.map(row => sqlanvil.Field.create({
+                    name: row.column_name,
+                    primitive: convertFieldType$1(String(row.data_type).replace(/\(.*\)/, "")),
+                    description: findDescription(row.ordinal_position)
+                })),
+                description: findDescription(0)
+            });
+        }
+        return null;
+    }
+    async deleteTable(target) {
+        const metadata = await this.table(target);
+        if (!metadata) {
+            return;
+        }
+        const kind = metadata.type === sqlanvil.TableMetadata.Type.VIEW ? "view" : "table";
+        await this.execute(`drop ${kind} if exists "${target.schema}"."${target.name}" cascade`, { includeQueryInError: true });
+    }
+    async schemas(_database) {
+        const result = await this.execute(`select nspname from pg_namespace`, {
+            includeQueryInError: true
+        });
+        return result.rows
+            .map(row => row.nspname)
+            .filter(name => !INTERNAL_SCHEMAS$1.has(name) && !name.startsWith("pg_"));
+    }
+    async createSchema(_database, schema) {
+        await this.execute(`create schema if not exists "${schema}"`, {
+            includeQueryInError: true
+        });
+    }
+    async setMetadata(action) {
+        var _a;
+        const { target, actionDescriptor, tableType } = action;
+        const actualMetadata = await this.table(target);
+        if (!actualMetadata) {
+            return;
+        }
+        const relationKind = actualMetadata.type === sqlanvil.TableMetadata.Type.MATERIALIZED_VIEW
+            ? "materialized view"
+            : tableType === "view"
+                ? "view"
+                : "table";
+        const queries = [];
+        if (actionDescriptor === null || actionDescriptor === void 0 ? void 0 : actionDescriptor.description) {
+            queries.push(this.execute(`comment on ${relationKind} "${target.schema}"."${target.name}" is '${actionDescriptor.description.replace(/'/g, "''")}'`));
+        }
+        if (((_a = actionDescriptor === null || actionDescriptor === void 0 ? void 0 : actionDescriptor.columns) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+            actionDescriptor.columns
+                .filter(column => column.path.length === 1 &&
+                actualMetadata.fields.some(field => field.name === column.path[0]))
+                .forEach(column => {
+                queries.push(this.execute(`comment on column "${target.schema}"."${target.name}"."${column.path[0]}" is '${column.description.replace(/'/g, "''")}'`));
+            });
+        }
+        await Promise.all(queries);
+    }
+    async close() {
+        await this.queryExecutor.close();
+    }
+}
+
+const DEFAULT_ROW_CAP = 1000000;
+const DEFAULT_BYTE_CAP = 512 * 1024 * 1024;
+const MAX_PARAMS_PER_INSERT = 60000;
+const quoteIdent = (id) => `"${String(id).replace(/"/g, '""')}"`;
+function coerce(v) {
+    if (v === null || v === undefined) {
+        return null;
+    }
+    if (typeof v === "object" && v !== null && "value" in v) {
+        return v.value;
+    }
+    return v;
+}
+async function runBigQueryExtract(args) {
+    var _a, _b;
+    const { spec, target, connectionCredentials } = args;
+    if ((spec.platform || "bigquery") !== "bigquery") {
+        throw new Error(`runner-extract supports only bigquery sources (got "${spec.platform}").`);
+    }
+    const cols = Object.keys(spec.columnTypes || {});
+    if (cols.length === 0) {
+        throw new Error(`Extract "${target.schema}.${target.name}" has no columnTypes; run \`sqlanvil introspect\`.`);
+    }
+    if (!args.pg) {
+        throw new Error("runner-extract needs the write-warehouse connection (warehouseConnection).");
+    }
+    const conn = (connectionCredentials === null || connectionCredentials === void 0 ? void 0 : connectionCredentials[spec.connectionName]) || {};
+    const bq = new BigQueryDbAdapter(sqlanvil.BigQuery.create({
+        projectId: spec.billingProject || spec.project,
+        location: conn.location,
+        accessToken: conn.accessToken,
+        credentials: conn.credentials
+    }));
+    const rowCap = (_a = args.rowCap) !== null && _a !== void 0 ? _a : DEFAULT_ROW_CAP;
+    const byteCap = (_b = args.byteCap) !== null && _b !== void 0 ? _b : DEFAULT_BYTE_CAP;
+    const colList = cols.map(c => "`" + c + "`").join(", ");
+    const fqn = "`" + `${spec.project}.${spec.dataset}.${spec.sourceName}` + "`";
+    const { rows } = await bq.execute(`select ${colList} from ${fqn}`, {
+        rowLimit: rowCap,
+        byteLimit: byteCap
+    });
+    if (rows.length >= rowCap) {
+        console.warn(`runner-extract: ${target.schema}.${target.name} truncated at ${rowCap} rows (source is larger).`);
+    }
+    const pg = await PostgresDbAdapter.create(args.pg, {
+        disableSslForTestsOnly: args.disableSslForTestsOnly
+    });
+    try {
+        const qualified = `${quoteIdent(target.schema)}.${quoteIdent(target.name)}`;
+        const colDefs = cols.map(c => `${quoteIdent(c)} ${spec.columnTypes[c]}`).join(", ");
+        await pg.execute(`create schema if not exists ${quoteIdent(target.schema)}`);
+        await pg.execute(`drop foreign table if exists ${qualified} cascade`);
+        await pg.execute(`drop table if exists ${qualified} cascade`);
+        await pg.execute(`create table ${qualified} (${colDefs})`);
+        const colIdents = cols.map(quoteIdent).join(", ");
+        const batchRows = Math.max(1, Math.min(1000, Math.floor(MAX_PARAMS_PER_INSERT / cols.length)));
+        for (let i = 0; i < rows.length; i += batchRows) {
+            const batch = rows.slice(i, i + batchRows);
+            const params = [];
+            const tuples = batch.map((row, r) => {
+                const placeholders = cols.map((c, ci) => `$${r * cols.length + ci + 1}`);
+                cols.forEach(c => params.push(coerce(row[c])));
+                return `(${placeholders.join(", ")})`;
+            });
+            await pg.execute(`insert into ${qualified} (${colIdents}) values ${tuples.join(", ")}`, {
+                params
+            });
+        }
+        return { rowCount: rows.length };
+    }
+    finally {
+        await pg.close();
+    }
+}
+
+function loadDuckdb() {
+    try {
+        return nativeRequire("@duckdb/node-api");
+    }
+    catch (e) {
+        throw new Error(`This feature requires the optional "@duckdb/node-api" dependency, which failed to load: ` +
+            `${e.message}`);
+    }
+}
+async function runAsync(conn, sql) {
+    await conn.run(sql);
+}
+async function allAsync(conn, sql) {
+    const reader = await conn.runAndReadAll(sql);
+    return reader.getRowObjects();
+}
+async function withDuckdb(fn, dbPath = ":memory:") {
+    const { DuckDBInstance } = loadDuckdb();
+    const instance = await DuckDBInstance.create(dbPath);
+    const conn = await instance.connect();
+    const done = () => {
+        var _a, _b;
+        try {
+            (_a = conn.closeSync) === null || _a === void 0 ? void 0 : _a.call(conn);
+        }
+        catch (e) {
+        }
+        try {
+            (_b = instance.closeSync) === null || _b === void 0 ? void 0 : _b.call(instance);
+        }
+        catch (e) {
+        }
+    };
+    try {
+        if (!process.env.HOME) {
+            await runAsync(conn, `SET home_directory='${os__namespace.tmpdir()}'`);
+        }
+        const result = await fn(conn);
+        done();
+        return result;
+    }
+    catch (e) {
+        done();
+        throw e;
+    }
+}
+
+const PG_ATTACH_ALIAS = "pg";
+const SECRET_NAME = "sa_export";
+function buildAttachSql(pg, opts = {}) {
+    const readOnly = opts.readOnly !== false;
+    const dsn = [
+        pg.host && `host=${pg.host}`,
+        pg.port && `port=${pg.port}`,
+        pg.database && `dbname=${pg.database}`,
+        pg.user && `user=${pg.user}`,
+        pg.password && `password=${pg.password}`
+    ]
+        .filter(Boolean)
+        .join(" ");
+    const mode = readOnly ? ", READ_ONLY" : "";
+    return `ATTACH '${dsn}' AS ${PG_ATTACH_ALIAS} (TYPE postgres${mode})`;
+}
+function buildSecretSql(scheme, creds) {
+    if (scheme === "s3") {
+        const fields = [
+            "TYPE s3",
+            creds.accessKeyId && `KEY_ID '${creds.accessKeyId}'`,
+            creds.secretAccessKey && `SECRET '${creds.secretAccessKey}'`,
+            creds.region && `REGION '${creds.region}'`,
+            creds.endpoint && `ENDPOINT '${creds.endpoint}'`,
+            creds.endpoint && `URL_STYLE 'path'`,
+            creds.endpoint && `USE_SSL true`
+        ]
+            .filter(Boolean)
+            .join(", ");
+        return `CREATE OR REPLACE SECRET ${SECRET_NAME} (${fields})`;
+    }
+    if (scheme === "gcs") {
+        const fields = [
+            "TYPE gcs",
+            creds.keyId && `KEY_ID '${creds.keyId}'`,
+            creds.secret && `SECRET '${creds.secret}'`
+        ]
+            .filter(Boolean)
+            .join(", ");
+        return `CREATE OR REPLACE SECRET ${SECRET_NAME} (${fields})`;
+    }
+    return null;
+}
+function toCopyTarget(uri) {
+    if (uri.startsWith("local://")) {
+        return uri.slice("local://".length);
+    }
+    return uri;
+}
+function schemeOf(uri) {
+    if (uri.startsWith("s3://")) {
+        return "s3";
+    }
+    if (uri.startsWith("gs://") || uri.startsWith("gcs://")) {
+        return "gcs";
+    }
+    return "local";
+}
+function buildCopySql(selectSql, uri, format, options = {}) {
+    const target = toCopyTarget(uri);
+    const fmt = (format || "").toLowerCase();
+    const extraOptions = Object.entries(options || {}).map(([key, value]) => `${key.toUpperCase()} ${value}`);
+    const optionList = [`FORMAT ${fmt}`, ...extraOptions].join(", ");
+    return `COPY (SELECT * FROM postgres_query('${PG_ATTACH_ALIAS}', $sa$${selectSql}$sa$)) TO '${target}' (${optionList})`;
+}
+async function runDuckdbExport(args) {
+    const { spec, selectSql, pg, storage, actionName } = args;
+    const uri = resolveExportUri(spec, actionName, { wildcard: false });
+    const scheme = schemeOf(uri);
+    if (scheme !== "local" && !(storage === null || storage === void 0 ? void 0 : storage[scheme])) {
+        throw new Error(`No "${scheme}" storage credentials found in .df-credentials.json (storage.${scheme}) for ` +
+            `export to ${uri}.`);
+    }
+    return withDuckdb(async (conn) => {
+        await runAsync(conn, "INSTALL postgres; LOAD postgres; INSTALL httpfs; LOAD httpfs;");
+        await runAsync(conn, buildAttachSql(pg));
+        if (scheme !== "local") {
+            const secret = buildSecretSql(scheme, storage[scheme]);
+            if (secret) {
+                await runAsync(conn, secret);
+            }
+        }
+        await runAsync(conn, buildCopySql(selectSql, uri, spec.format, spec.options || {}));
+        return { destination: toCopyTarget(uri) };
+    });
+}
+
+function readerForFormat(format) {
+    switch ((format || "").toLowerCase()) {
+        case "csv":
+            return "read_csv_auto";
+        case "json":
+            return "read_json_auto";
+        case "parquet":
+        default:
+            return "read_parquet";
+    }
+}
+function importTargetSql(target) {
+    return target.schema
+        ? `${PG_ATTACH_ALIAS}."${target.schema}"."${target.name}"`
+        : `${PG_ATTACH_ALIAS}."${target.name}"`;
+}
+function buildImportSql(target, location, format, overwrite) {
+    const reader = readerForFormat(format);
+    const source = toCopyTarget(location);
+    const dest = importTargetSql(target);
+    const select = `SELECT * FROM ${reader}('${source}')`;
+    if (overwrite) {
+        return [`DROP TABLE IF EXISTS ${dest}`, `CREATE TABLE ${dest} AS ${select}`];
+    }
+    return [`INSERT INTO ${dest} ${select}`];
+}
+async function runDuckdbImport(args) {
+    const { spec, target, pg, storage } = args;
+    const location = spec.location || "";
+    const scheme = schemeOf(location);
+    if (scheme !== "local" && !(storage === null || storage === void 0 ? void 0 : storage[scheme])) {
+        throw new Error(`No "${scheme}" storage credentials found in .df-credentials.json (storage.${scheme}) for ` +
+            `import from ${location}.`);
+    }
+    return withDuckdb(async (conn) => {
+        await runAsync(conn, "INSTALL postgres; LOAD postgres; INSTALL httpfs; LOAD httpfs;");
+        await runAsync(conn, buildAttachSql(pg, { readOnly: false }));
+        if (scheme !== "local") {
+            const secret = buildSecretSql(scheme, storage[scheme]);
+            if (secret) {
+                await runAsync(conn, secret);
+            }
+        }
+        for (const statement of buildImportSql(target, location, spec.format, spec.overwrite)) {
+            await runAsync(conn, statement);
+        }
+        return { source: toCopyTarget(location) };
+    });
+}
+
+function parseArgvFlags(argv) {
+    const parsedArgv = {};
+    const splitArgv = [];
+    for (let arg of argv) {
+        if (arg.startsWith("--no-")) {
+            arg = `--${arg.slice(5)}=false`;
+        }
+        if (arg.startsWith("--") && arg.includes("=")) {
+            splitArgv.push(arg.slice(0, arg.indexOf("=")));
+            splitArgv.push(arg.slice(arg.indexOf("=") + 1));
+        }
+        else {
+            splitArgv.push(arg);
+        }
+    }
+    let currentFlagName = "";
+    for (const splitArg of splitArgv) {
+        if (splitArg.startsWith("--")) {
+            currentFlagName = splitArg.slice(2);
+            parsedArgv[currentFlagName] = "";
+        }
+        else if (currentFlagName) {
+            parsedArgv[currentFlagName] = splitArg;
+            currentFlagName = "";
+        }
+    }
+    return parsedArgv;
+}
+class Flags {
+    static boolean(name, defaultValue = false) {
+        return new SingleValueFlag(name, defaultValue, (stringValue) => {
+            if (stringValue === "" || stringValue === "true") {
+                return true;
+            }
+            if (stringValue === "false") {
+                return false;
+            }
+            throw Flags.invalidFlagValueError(name);
+        });
+    }
+    static string(name, defaultValue = "") {
+        return new SingleValueFlag(name, defaultValue, (stringValue) => stringValue);
+    }
+    static number(name, defaultValue = 0) {
+        return new SingleValueFlag(name, defaultValue, (stringValue) => parseFloat(stringValue));
+    }
+    static long(name, defaultValue = Long__default["default"].ZERO) {
+        return new SingleValueFlag(name, defaultValue, Long__default["default"].fromString);
+    }
+    static stringSet(name, defaultValue = new Set()) {
+        return new SetFlag(name, defaultValue, (singleValue) => singleValue);
+    }
+    static getRawFlagValue(flagName) {
+        return Flags.parsedArgv[flagName];
+    }
+    static setRawFlagValueForTesting(flagName, value) {
+        Flags.parsedArgv[flagName] = value;
+    }
+    static invalidFlagValueError(flagName) {
+        return new Error(`Invalid flag value: ${Flags.getRawFlagValue(flagName)} [${flagName}]`);
+    }
+}
+Flags.parsedArgv = parseArgvFlags(process.argv);
+class AbstractFlag {
+    constructor(name, defaultValue) {
+        this.name = name;
+        this.defaultValue = defaultValue;
+        this.parsed = {};
+    }
+    get() {
+        if (Flags.getRawFlagValue(this.name) === undefined) {
+            return this.defaultValue;
+        }
+        const stringValue = Flags.getRawFlagValue(this.name);
+        if (!(stringValue in this.parsed)) {
+            this.parsed[stringValue] = this.parse(stringValue);
+        }
+        return this.parsed[stringValue];
+    }
+}
+class SingleValueFlag extends AbstractFlag {
+    constructor(name, defaultValue, parser) {
+        super(name, defaultValue);
+        this.parser = parser;
+    }
+    parse(stringValue) {
+        return this.parser(stringValue);
+    }
+}
+class SetFlag extends AbstractFlag {
+    constructor(name, defaultValue, parser) {
+        super(name, defaultValue);
+        this.parser = parser;
+    }
+    parse(stringValue) {
+        return new Set(stringValue
+            .split(",")
+            .filter(singleValue => singleValue.length > 0)
+            .map(this.parser));
+    }
+}
+
+const CANCEL_EVENT = "jobCancel";
+const flags = {
+    runnerNotificationPeriodMillis: Flags.number("runner-notification-period-millis", 5000)
+};
+const isSuccessfulAction = (actionResult) => actionResult.status === sqlanvil.ActionResult.ExecutionStatus.SUCCESSFUL ||
+    actionResult.status === sqlanvil.ActionResult.ExecutionStatus.DISABLED;
+function run(dbadapter, graph, executionOptions, partiallyExecutedRunResult = {}, runnerNotificationPeriodMillis = flags.runnerNotificationPeriodMillis.get()) {
+    return new Runner(dbadapter, graph, executionOptions, partiallyExecutedRunResult, runnerNotificationPeriodMillis).execute();
+}
+class Runner {
+    constructor(dbadapter, graph, executionOptions = {}, partiallyExecutedRunResult = {}, runnerNotificationPeriodMillis = flags.runnerNotificationPeriodMillis.get()) {
         var _a;
         this.dbadapter = dbadapter;
         this.graph = graph;
@@ -47680,6 +49803,24 @@ class Runner {
                 taskResult.errorMessage = `${this.graph.projectConfig.warehouse} import error: ${e.message}`;
             }
         }
+        else if (task.type === "extract") {
+            try {
+                const extractor = this.executionOptions.bigQueryExtract || runBigQueryExtract;
+                await extractor({
+                    spec: action === null || action === void 0 ? void 0 : action.extract,
+                    target: action === null || action === void 0 ? void 0 : action.target,
+                    pg: this.executionOptions.warehouseConnection,
+                    connectionCredentials: this.executionOptions.connectionCredentials || {}
+                });
+                taskResult.status = sqlanvil.TaskResult.ExecutionStatus.SUCCESSFUL;
+            }
+            catch (e) {
+                taskResult.status = this.cancelled
+                    ? sqlanvil.TaskResult.ExecutionStatus.CANCELLED
+                    : sqlanvil.TaskResult.ExecutionStatus.FAILED;
+                taskResult.errorMessage = `${this.graph.projectConfig.warehouse} extract error: ${e.message}`;
+            }
+        }
         else {
             try {
                 const statement = this.executionOptions.connectionCredentials
@@ -48321,576 +50462,94 @@ async function validate(compiledGraph, deps, options = {}) {
         nodes.push({
             key: targetKey(table.target),
             dependencyKeys: depKeys(table.dependencyTargets),
-            kind: "table",
-            type: tableType(table.enumType),
-            target: table.target,
-            table,
-            action: table
-        });
-    }
-    for (const assertion of compiledGraph.assertions || []) {
-        nodes.push({
-            key: targetKey(assertion.target),
-            dependencyKeys: depKeys(assertion.dependencyTargets),
-            kind: "assertion",
-            type: "assertion",
-            target: assertion.target,
-            action: assertion
-        });
-    }
-    for (const operation of compiledGraph.operations || []) {
-        if (!operation.target) {
-            continue;
-        }
-        nodes.push({
-            key: targetKey(operation.target),
-            dependencyKeys: depKeys(operation.dependencyTargets),
-            kind: "operation",
-            type: "operation",
-            target: operation.target,
-            action: undefined
-        });
-    }
-    for (const imp of compiledGraph.imports || []) {
-        if (!imp.target) {
-            continue;
-        }
-        nodes.push({
-            key: targetKey(imp.target),
-            dependencyKeys: depKeys(imp.dependencyTargets),
-            kind: "import",
-            type: "import",
-            target: imp.target,
-            action: undefined
-        });
-    }
-    const ordered = topoOrder(nodes);
-    const shadowSchemas = Array.from(new Set(nodes.filter(n => n.kind === "table").map(n => n.target.schema)));
-    const statusByKey = new Map();
-    const results = [];
-    try {
-        for (const schema of shadowSchemas) {
-            await deps.execute(deps.createSchemaSql(schema));
-        }
-        for (const node of ordered) {
-            if (node.kind === "operation" || node.kind === "import") {
-                statusByKey.set(node.key, "SKIPPED");
-                results.push({ target: node.target, type: node.type, status: "SKIPPED", errors: [] });
-                continue;
-            }
-            if (dependencyBlocked(node.dependencyKeys, statusByKey)) {
-                statusByKey.set(node.key, "BLOCKED");
-                results.push({ target: node.target, type: node.type, status: "BLOCKED", errors: [] });
-                continue;
-            }
-            const evaluations = await deps.evaluate(node.action);
-            const failed = evaluations.some(e => e.status === sqlanvil.QueryEvaluation.QueryEvaluationStatus.FAILURE);
-            const status = failed ? "FAILURE" : "PASS";
-            statusByKey.set(node.key, status);
-            results.push({ target: node.target, type: node.type, status, errors: evaluations });
-            if (status === "PASS" && node.kind === "table") {
-                try {
-                    await deps.execute(deps.validationStubSql(node.table));
-                }
-                catch (e) {
-                }
-            }
-        }
-    }
-    finally {
-        if (!options.keepShadow) {
-            for (const schema of shadowSchemas.slice().reverse()) {
-                try {
-                    await deps.execute(deps.dropSchemaCascadeSql(schema));
-                }
-                catch (e) {
-                }
-            }
-        }
-    }
-    return results;
-}
-
-function parsePostgresEvalError(_query, error) {
-    return sqlanvil.QueryEvaluationError.create({
-        message: (error === null || error === void 0 ? void 0 : error.message) ? String(error.message) : String(error)
-    });
-}
-function parseBigqueryEvalError(error) {
-    const evalError = sqlanvil.QueryEvaluationError.create({
-        message: String(error)
-    });
-    try {
-        if (!error.message) {
-            return evalError;
-        }
-        const bracketsString = error.message.split("[").slice(-1)[0];
-        const [_, lineNumber, columnNumber] = bracketsString.match(/([0-9]*)[^0-9]*([0-9]*).*/);
-        const line = Number(lineNumber);
-        const column = Number(columnNumber);
-        if (line || line === 0) {
-            evalError.errorLocation = { line, column };
-        }
-    }
-    catch (_) {
-    }
-    return evalError;
-}
-
-class LimitedResultSet {
-    constructor(options) {
-        this.options = options;
-        this.results = [];
-        this.currentBytes = 0;
-    }
-    push(row) {
-        var _a, _b, _c, _d;
-        this.currentBytes += sizeof__default["default"](row);
-        if ((((_a = this.options) === null || _a === void 0 ? void 0 : _a.rowLimit) && this.results.length >= ((_b = this.options) === null || _b === void 0 ? void 0 : _b.rowLimit)) ||
-            (((_c = this.options) === null || _c === void 0 ? void 0 : _c.byteLimit) && this.currentBytes >= ((_d = this.options) === null || _d === void 0 ? void 0 : _d.byteLimit))) {
-            return false;
-        }
-        this.results.push(row);
-        return true;
-    }
-    get rows() {
-        return this.results;
-    }
-}
-
-const EXTRA_GOOGLE_SCOPES = ["https://www.googleapis.com/auth/drive"];
-const BIGQUERY_DATE_RELATED_FIELDS = [
-    "BigQueryDate",
-    "BigQueryTime",
-    "BigQueryTimestamp",
-    "BigQueryDatetime"
-];
-const BIGQUERY_INTERNAL_ERROR_JOB_MAX_ATTEMPTS = 3;
-class BigQueryDbAdapter {
-    constructor(credentials, options) {
-        this.clients = new Map();
-        this.bigQueryCredentials = credentials;
-        this.bigqueryClient = options === null || options === void 0 ? void 0 : options.bigqueryClient;
-        this.pool = new promisePoolExecutor.PromisePoolExecutor({
-            concurrencyLimit: options === null || options === void 0 ? void 0 : options.concurrencyLimit,
-            frequencyWindow: 1000,
-            frequencyLimit: 30
-        });
-    }
-    async execute(statement, options = { interactive: false, rowLimit: 1000, byteLimit: 1024 * 1024 }) {
-        var _a;
-        if ((options === null || options === void 0 ? void 0 : options.interactive) && ((_a = options === null || options === void 0 ? void 0 : options.bigquery) === null || _a === void 0 ? void 0 : _a.labels)) {
-            throw new Error("BigQuery job labels may not be set for interactive queries.");
-        }
-        if (!statement) {
-            throw new Error("Query string cannot be empty");
-        }
-        return this.pool
-            .addSingleTask({
-            generator: () => {
-                var _a, _b, _c, _d, _e, _f;
-                return (options === null || options === void 0 ? void 0 : options.interactive) ? this.runQuery(statement, options === null || options === void 0 ? void 0 : options.params, options === null || options === void 0 ? void 0 : options.rowLimit, options === null || options === void 0 ? void 0 : options.byteLimit, (_a = options.bigquery) === null || _a === void 0 ? void 0 : _a.location)
-                    : this.createQueryJob(statement, options === null || options === void 0 ? void 0 : options.params, options === null || options === void 0 ? void 0 : options.rowLimit, options === null || options === void 0 ? void 0 : options.byteLimit, options === null || options === void 0 ? void 0 : options.onCancel, (_b = options === null || options === void 0 ? void 0 : options.bigquery) === null || _b === void 0 ? void 0 : _b.labels, (_c = options === null || options === void 0 ? void 0 : options.bigquery) === null || _c === void 0 ? void 0 : _c.location, (_d = options === null || options === void 0 ? void 0 : options.bigquery) === null || _d === void 0 ? void 0 : _d.jobPrefix, (_e = options === null || options === void 0 ? void 0 : options.bigquery) === null || _e === void 0 ? void 0 : _e.dryRun, (_f = options === null || options === void 0 ? void 0 : options.bigquery) === null || _f === void 0 ? void 0 : _f.reservation);
-            }
-        })
-            .promise();
-    }
-    async executeRaw(statement, options = { rowLimit: 1000 }) {
-        if (!statement) {
-            throw new Error("Query string cannot be empty");
-        }
-        return this.pool
-            .addSingleTask({
-            generator: async () => {
-                var _a, _b;
-                const [rows, , apiResponse] = await this.getClient().query(Object.assign(Object.assign({}, this.prepareQueryOptions(statement, options.rowLimit, options.bigquery, options.params)), { skipParsing: true }));
-                const schema = (_b = (_a = apiResponse === null || apiResponse === void 0 ? void 0 : apiResponse.schema) === null || _a === void 0 ? void 0 : _a.fields) === null || _b === void 0 ? void 0 : _b.map((field) => convertField(field));
-                return { rows, schema, metadata: {} };
-            }
-        })
-            .promise();
-    }
-    async withClientLock(callback) {
-        return await callback(this);
-    }
-    async evaluate(queryOrAction) {
-        const validationQueries = collectEvaluationQueries(queryOrAction, true);
-        return await Promise.all(validationQueries.map(async ({ query, incremental }) => {
-            try {
-                await this.pool
-                    .addSingleTask({
-                    generator: () => this.getClient().query({
-                        useLegacySql: false,
-                        query,
-                        dryRun: true
-                    })
-                })
-                    .promise();
-                return sqlanvil.QueryEvaluation.create({
-                    status: sqlanvil.QueryEvaluation.QueryEvaluationStatus.SUCCESS,
-                    incremental,
-                    query
-                });
-            }
-            catch (e) {
-                return {
-                    status: sqlanvil.QueryEvaluation.QueryEvaluationStatus.FAILURE,
-                    error: parseBigqueryEvalError(e),
-                    incremental,
-                    query
-                };
-            }
-        }));
-    }
-    async tables(database, schema) {
-        const datasetIds = schema ? [schema] : await this.schemas(database);
-        const tablesMetadata = [];
-        await Promise.all(datasetIds.map(async (datasetId) => {
-            const [tables] = await this.getClient(database)
-                .dataset(datasetId)
-                .getTables();
-            await Promise.all(tables.map(async (table) => {
-                const metadata = await this.table({
-                    database,
-                    schema: datasetId,
-                    name: table.id
-                });
-                if (metadata) {
-                    tablesMetadata.push(metadata);
-                }
-            }));
-        }));
-        return tablesMetadata;
-    }
-    async search(searchText, options = { limit: 1000 }) {
-        const results = await this.execute(`select table_catalog, table_schema, table_name
-       from region-${this.bigQueryCredentials.location}.INFORMATION_SCHEMA.COLUMN_FIELD_PATHS
-       where regexp_contains(table_schema, @searchText) or regexp_contains(table_name, @searchText) or regexp_contains(field_path, @searchText)
-       group by 1, 2, 3`, {
-            params: {
-                searchText: `(?i)${searchText}`
-            },
-            interactive: true,
-            rowLimit: options.limit
-        });
-        return await Promise.all(results.rows.map(row => this.table({
-            database: row.table_catalog,
-            schema: row.table_schema,
-            name: row.table_name
-        })));
-    }
-    async table(target) {
-        var _a;
-        const metadata = await this.getMetadata(target);
-        if (!metadata) {
-            return null;
-        }
-        if (metadata.tableReference.datasetId !== target.schema ||
-            metadata.tableReference.tableId !== target.name) {
-            const metadataTarget = {
-                database: metadata.tableReference.projectId,
-                schema: metadata.tableReference.datasetId,
-                name: metadata.tableReference.tableId
-            };
-            throw new Error(`Target ${JSON.stringify(metadataTarget)} does not match requested target ${JSON.stringify(target)}.`);
-        }
-        return sqlanvil.TableMetadata.create({
-            type: metadata.type === "TABLE"
-                ? sqlanvil.TableMetadata.Type.TABLE
-                : metadata.type === "VIEW"
-                    ? sqlanvil.TableMetadata.Type.VIEW
-                    : sqlanvil.TableMetadata.Type.UNKNOWN,
-            target,
-            fields: (_a = metadata.schema.fields) === null || _a === void 0 ? void 0 : _a.map(field => convertField(field)),
-            lastUpdatedMillis: Long__default["default"].fromString(metadata.lastModifiedTime),
-            description: metadata.description,
-            labels: metadata.labels,
-            bigquery: {
-                hasStreamingBuffer: !!metadata.streamingBuffer
-            }
-        });
-    }
-    async deleteTable(target) {
-        await this.getClient(target.database)
-            .dataset(target.schema)
-            .table(target.name)
-            .delete({ ignoreNotFound: true });
-    }
-    async schemas(database) {
-        const data = await this.getClient(database).getDatasets();
-        return data[0].map(dataset => dataset.id);
-    }
-    async createSchema(database, schema) {
-        await this.execute(`create schema if not exists \`${database || this.bigQueryCredentials.projectId}.${schema}\``, { bigquery: { location: this.bigQueryCredentials.location } });
-    }
-    async setMetadata(action) {
-        const { target, actionDescriptor } = action;
-        const metadata = await this.getMetadata(target);
-        const schemaWithDescription = addDescriptionToMetadata(actionDescriptor.columns, metadata.schema.fields);
-        await this.getClient(target.database)
-            .dataset(target.schema)
-            .table(target.name)
-            .setMetadata({
-            description: actionDescriptor.description,
-            schema: schemaWithDescription,
-            labels: actionDescriptor.bigqueryLabels
-        });
-    }
-    async getMetadata(target) {
-        var _a, _b;
-        try {
-            const table = await this.getClient(target.database)
-                .dataset(target.schema)
-                .table(target.name)
-                .getMetadata();
-            return table === null || table === void 0 ? void 0 : table[0];
-        }
-        catch (e) {
-            if (((_b = (_a = e === null || e === void 0 ? void 0 : e.errors) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.reason) === "notFound") {
-                return null;
-            }
-            throw coerceAsError(e);
-        }
-    }
-    getClient(projectId) {
-        if (this.bigqueryClient) {
-            return this.bigqueryClient;
-        }
-        projectId = projectId || this.bigQueryCredentials.projectId;
-        if (!this.clients.has(projectId)) {
-            this.clients.set(projectId, new bigquery.BigQuery({
-                projectId,
-                scopes: EXTRA_GOOGLE_SCOPES,
-                location: this.bigQueryCredentials.location,
-                credentials: this.bigQueryCredentials.credentials && JSON.parse(this.bigQueryCredentials.credentials)
-            }));
-        }
-        return this.clients.get(projectId);
-    }
-    async runQuery(query, params, rowLimit, byteLimit, location) {
-        const results = await new Promise((resolve, reject) => {
-            const allRows = new LimitedResultSet({
-                rowLimit,
-                byteLimit
-            });
-            const stream = this.getClient().createQueryStream({
-                query,
-                params,
-                location
-            });
-            stream
-                .on("error", e => reject(coerceAsError(e)))
-                .on("data", row => {
-                if (!allRows.push(row)) {
-                    stream.end();
-                }
-            })
-                .on("end", () => {
-                resolve(allRows.rows);
-            });
-        });
-        return { rows: cleanRows(results), metadata: {} };
-    }
-    prepareQueryOptions(query, rowLimit, bigqueryOptions, params) {
-        return {
-            query,
-            useLegacySql: false,
-            jobPrefix: "sqlanvil-" + ((bigqueryOptions === null || bigqueryOptions === void 0 ? void 0 : bigqueryOptions.jobPrefix) ? `${bigqueryOptions.jobPrefix}-` : ""),
-            location: bigqueryOptions === null || bigqueryOptions === void 0 ? void 0 : bigqueryOptions.location,
-            maxResults: rowLimit,
-            labels: bigqueryOptions === null || bigqueryOptions === void 0 ? void 0 : bigqueryOptions.labels,
-            dryRun: bigqueryOptions === null || bigqueryOptions === void 0 ? void 0 : bigqueryOptions.dryRun,
-            reservation: bigqueryOptions === null || bigqueryOptions === void 0 ? void 0 : bigqueryOptions.reservation,
-            params
-        };
-    }
-    async createQueryJob(query, params, rowLimit, byteLimit, onCancel, labels, location, jobPrefix, dryRun, reservation) {
-        let isCancelled = false;
-        onCancel === null || onCancel === void 0 ? void 0 : onCancel(() => (isCancelled = true));
-        return retry(async () => {
-            try {
-                const job = await this.getClient().createQueryJob(this.prepareQueryOptions(query, rowLimit, {
-                    labels,
-                    location,
-                    jobPrefix,
-                    dryRun,
-                    reservation
-                }, params));
-                const resultStream = job[0].getQueryResultsStream();
-                return new Promise((resolve, reject) => {
-                    if (isCancelled) {
-                        resultStream.end();
-                        reject(new Error("Query cancelled."));
-                        return;
-                    }
-                    onCancel === null || onCancel === void 0 ? void 0 : onCancel(() => {
-                        resultStream.end();
-                        reject(new Error("Query cancelled."));
-                    });
-                    const results = new LimitedResultSet({
-                        rowLimit,
-                        byteLimit
-                    });
-                    resultStream
-                        .on("error", async (e) => {
-                        var _a, _b;
-                        if (dryRun && ((_a = e.message) === null || _a === void 0 ? void 0 : _a.includes("Not found: Job"))) {
-                            resolve({ rows: [], metadata: {} });
-                            return;
-                        }
-                        try {
-                            const [jobMetadata] = await job[0].getMetadata();
-                            if (!!((_b = jobMetadata.status) === null || _b === void 0 ? void 0 : _b.errorResult)) {
-                                const error = createBigQueryError(jobMetadata);
-                                reject(error);
-                            }
-                        }
-                        catch (metadataError) {
-                            reject(metadataError);
-                        }
-                        reject(e);
-                    })
-                        .on("data", row => {
-                        if (!results.push(row)) {
-                            resultStream.end();
-                        }
-                    })
-                        .on("end", async () => {
-                        var _a;
-                        try {
-                            const [jobMetadata] = await job[0].getMetadata();
-                            if (!!((_a = jobMetadata.status) === null || _a === void 0 ? void 0 : _a.errorResult)) {
-                                const error = createBigQueryError(jobMetadata);
-                                reject(error);
-                                return;
-                            }
-                            resolve({
-                                rows: results.rows,
-                                metadata: {
-                                    bigquery: {
-                                        jobId: jobMetadata.jobReference.jobId,
-                                        totalBytesBilled: jobMetadata.statistics.query.totalBytesBilled
-                                            ? Long__default["default"].fromString(jobMetadata.statistics.query.totalBytesBilled)
-                                            : Long__default["default"].ZERO,
-                                        totalBytesProcessed: jobMetadata.statistics.query.totalBytesProcessed
-                                            ? Long__default["default"].fromString(jobMetadata.statistics.query.totalBytesProcessed)
-                                            : Long__default["default"].ZERO,
-                                    }
-                                }
-                            });
-                        }
-                        catch (e) {
-                            reject(e);
-                        }
-                    });
-                });
-            }
-            catch (e) {
-                throw coerceAsError(e);
-            }
-        }, BIGQUERY_INTERNAL_ERROR_JOB_MAX_ATTEMPTS, e => { var _a; return (_a = e.message) === null || _a === void 0 ? void 0 : _a.includes("Retrying the job may solve the problem"); });
-    }
-}
-function cleanRows(rows) {
-    if (rows.length === 0) {
-        return rows;
-    }
-    const sampleData = rows[0];
-    const fieldsWithBigQueryDates = Object.keys(sampleData).filter(key => sampleData[key] &&
-        sampleData[key].constructor &&
-        BIGQUERY_DATE_RELATED_FIELDS.includes(sampleData[key].constructor.name));
-    fieldsWithBigQueryDates.forEach(dateField => {
-        rows.forEach(row => (row[dateField] = row[dateField] ? row[dateField].value : row[dateField]));
-    });
-    return rows;
-}
-function convertField(field) {
-    const result = {
-        name: field.name,
-        flags: field.mode === "REPEATED" ? [sqlanvil.Field.Flag.REPEATED] : [],
-        description: field.description
-    };
-    if (field.type === "RECORD" || field.type === "STRUCT") {
-        result.struct = sqlanvil.Fields.create({
-            fields: field.fields.map(innerField => convertField(innerField))
+            kind: "table",
+            type: tableType(table.enumType),
+            target: table.target,
+            table,
+            action: table
         });
     }
-    else {
-        result.primitive = convertFieldType$2(field.type);
+    for (const assertion of compiledGraph.assertions || []) {
+        nodes.push({
+            key: targetKey(assertion.target),
+            dependencyKeys: depKeys(assertion.dependencyTargets),
+            kind: "assertion",
+            type: "assertion",
+            target: assertion.target,
+            action: assertion
+        });
     }
-    return sqlanvil.Field.create(result);
-}
-function convertFieldType$2(type) {
-    switch (String(type).toUpperCase()) {
-        case "FLOAT":
-        case "FLOAT64":
-            return sqlanvil.Field.Primitive.FLOAT;
-        case "INTEGER":
-        case "INT64":
-            return sqlanvil.Field.Primitive.INTEGER;
-        case "NUMERIC":
-            return sqlanvil.Field.Primitive.NUMERIC;
-        case "BOOL":
-        case "BOOLEAN":
-            return sqlanvil.Field.Primitive.BOOLEAN;
-        case "STRING":
-            return sqlanvil.Field.Primitive.STRING;
-        case "DATE":
-            return sqlanvil.Field.Primitive.DATE;
-        case "DATETIME":
-            return sqlanvil.Field.Primitive.DATETIME;
-        case "TIMESTAMP":
-            return sqlanvil.Field.Primitive.TIMESTAMP;
-        case "TIME":
-            return sqlanvil.Field.Primitive.TIME;
-        case "BYTES":
-            return sqlanvil.Field.Primitive.BYTES;
-        case "GEOGRAPHY":
-            return sqlanvil.Field.Primitive.GEOGRAPHY;
-        case "BIGNUMERIC":
-            return sqlanvil.Field.Primitive.BIGNUMERIC;
-        case "JSON":
-            return sqlanvil.Field.Primitive.JSON;
-        case "INTERVAL":
-            return sqlanvil.Field.Primitive.INTERVAL;
-        default:
-            return sqlanvil.Field.Primitive.UNKNOWN;
+    for (const operation of compiledGraph.operations || []) {
+        if (!operation.target) {
+            continue;
+        }
+        nodes.push({
+            key: targetKey(operation.target),
+            dependencyKeys: depKeys(operation.dependencyTargets),
+            kind: "operation",
+            type: "operation",
+            target: operation.target,
+            action: undefined
+        });
     }
-}
-function addDescriptionToMetadata(columnDescriptions, metadataArray) {
-    if (!columnDescriptions) {
-        return metadataArray;
+    for (const imp of compiledGraph.imports || []) {
+        if (!imp.target) {
+            continue;
+        }
+        nodes.push({
+            key: targetKey(imp.target),
+            dependencyKeys: depKeys(imp.dependencyTargets),
+            kind: "import",
+            type: "import",
+            target: imp.target,
+            action: undefined
+        });
     }
-    const findDescription = (path) => columnDescriptions.find(column => column.path.join("") === path.join(""));
-    const mapDescriptionToMetadata = (metadata, path) => {
-        var _a;
-        const description = findDescription(path);
-        if (description) {
-            metadata.description = description.description;
-            if (((_a = description.bigqueryPolicyTags) === null || _a === void 0 ? void 0 : _a.length) > 0) {
-                metadata.policyTags = {
-                    names: description.bigqueryPolicyTags
-                };
-            }
+    const ordered = topoOrder(nodes);
+    const shadowSchemas = Array.from(new Set(nodes.filter(n => n.kind === "table").map(n => n.target.schema)));
+    const statusByKey = new Map();
+    const results = [];
+    try {
+        for (const schema of shadowSchemas) {
+            await deps.execute(deps.createSchemaSql(schema));
         }
-        if (metadata.fields) {
-            metadata.fields = metadata.fields.map(nestedMetadata => mapDescriptionToMetadata(nestedMetadata, [...path, nestedMetadata.name]));
+        for (const node of ordered) {
+            if (node.kind === "operation" || node.kind === "import") {
+                statusByKey.set(node.key, "SKIPPED");
+                results.push({ target: node.target, type: node.type, status: "SKIPPED", errors: [] });
+                continue;
+            }
+            if (dependencyBlocked(node.dependencyKeys, statusByKey)) {
+                statusByKey.set(node.key, "BLOCKED");
+                results.push({ target: node.target, type: node.type, status: "BLOCKED", errors: [] });
+                continue;
+            }
+            const evaluations = await deps.evaluate(node.action);
+            const failed = evaluations.some(e => e.status === sqlanvil.QueryEvaluation.QueryEvaluationStatus.FAILURE);
+            const status = failed ? "FAILURE" : "PASS";
+            statusByKey.set(node.key, status);
+            results.push({ target: node.target, type: node.type, status, errors: evaluations });
+            if (status === "PASS" && node.kind === "table") {
+                try {
+                    await deps.execute(deps.validationStubSql(node.table));
+                }
+                catch (e) {
+                }
+            }
         }
-        return metadata;
-    };
-    const newMetadata = metadataArray.map(metaItem => mapDescriptionToMetadata(metaItem, [metaItem.name]));
-    return newMetadata;
-}
-function createBigQueryError(jobMetadata) {
-    const error = new Error(jobMetadata.status.errorResult.message);
-    if (jobMetadata.jobReference && jobMetadata.jobReference.jobId) {
-        error.metadata = {
-            bigquery: {
-                jobId: jobMetadata.jobReference.jobId,
+    }
+    finally {
+        if (!options.keepShadow) {
+            for (const schema of shadowSchemas.slice().reverse()) {
+                try {
+                    await deps.execute(deps.dropSchemaCascadeSql(schema));
+                }
+                catch (e) {
+                }
             }
-        };
+        }
     }
-    return error;
+    return results;
 }
 
 class MySqlPoolExecutor {
@@ -48935,7 +50594,7 @@ class MySqlPoolExecutor {
         await this.pool.end();
     }
 }
-function convertFieldType$1(type) {
+function convertFieldType(type) {
     switch (String(type).toUpperCase()) {
         case "FLOAT":
         case "DOUBLE":
@@ -49017,7 +50676,7 @@ function defaultClause(col, extra) {
     return ` DEFAULT '${escapeMysqlString(d)}'`;
 }
 
-const INTERNAL_SCHEMAS$1 = new Set([
+const INTERNAL_SCHEMAS = new Set([
     "information_schema",
     "mysql",
     "performance_schema",
@@ -49162,7 +50821,7 @@ class MySqlDbAdapter {
                 const comment = String((_b = (_a = row.column_comment) !== null && _a !== void 0 ? _a : row.COLUMN_COMMENT) !== null && _b !== void 0 ? _b : "");
                 return sqlanvil.Field.create({
                     name: ((_c = row.column_name) !== null && _c !== void 0 ? _c : row.COLUMN_NAME),
-                    primitive: convertFieldType$1(((_d = row.data_type) !== null && _d !== void 0 ? _d : row.DATA_TYPE)),
+                    primitive: convertFieldType(((_d = row.data_type) !== null && _d !== void 0 ? _d : row.DATA_TYPE)),
                     description: comment || undefined
                 });
             })
@@ -49184,7 +50843,7 @@ class MySqlDbAdapter {
         });
         return result.rows
             .map(row => { var _a; return ((_a = row.schema_name) !== null && _a !== void 0 ? _a : row.SCHEMA_NAME); })
-            .filter(name => !INTERNAL_SCHEMAS$1.has(name));
+            .filter(name => !INTERNAL_SCHEMAS.has(name));
     }
     async createSchema(_database, schema) {
         await this.execute(`create database if not exists \`${schema}\``, {
@@ -49248,372 +50907,6 @@ class MySqlDbAdapter {
     }
 }
 
-const maybeInitializePg = (() => {
-    let initialized = false;
-    return () => {
-        if (!initialized) {
-            initialized = true;
-            pg__namespace.types.setTypeParser(20, Number);
-        }
-    };
-})();
-class PgPoolExecutor {
-    constructor(clientConfig, options) {
-        maybeInitializePg();
-        this.pool = new pg__namespace.Pool(Object.assign(Object.assign({}, clientConfig), { max: options === null || options === void 0 ? void 0 : options.concurrencyLimit }));
-        this.pool.on("error", err => {
-            console.error("pg.Pool idle client error", err.message, err.stack);
-        });
-    }
-    async verifyConnection() {
-        const client = await this.pool.connect();
-        try {
-            await client.query("select 1");
-        }
-        finally {
-            client.release();
-        }
-    }
-    async withClientLock(callback) {
-        const client = await this.pool.connect();
-        let released = false;
-        const releaseOnce = (err) => {
-            if (released) {
-                return;
-            }
-            released = true;
-            try {
-                client.release(err);
-            }
-            catch (e) {
-                console.error("Error thrown when releasing pg.Client", e.message, e.stack);
-            }
-        };
-        try {
-            client.on("error", err => {
-                console.error("pg.Client client error", err.message, err.stack);
-                releaseOnce(err);
-            });
-            return await callback({
-                execute: async (statement, options = { rowLimit: 1000, byteLimit: 1024 * 1024 }) => {
-                    return await new Promise((resolve, reject) => {
-                        var _a;
-                        const query = client.query(new QueryStream__default["default"](statement, options === null || options === void 0 ? void 0 : options.params));
-                        const results = new LimitedResultSet({
-                            rowLimit: options === null || options === void 0 ? void 0 : options.rowLimit,
-                            byteLimit: options === null || options === void 0 ? void 0 : options.byteLimit
-                        });
-                        (_a = options === null || options === void 0 ? void 0 : options.onCancel) === null || _a === void 0 ? void 0 : _a.call(options, () => query.destroy(new Error("Query cancelled.")));
-                        query.on("data", (row) => {
-                            try {
-                                verifyUniqueColumnNames(query.cursor._result.fields);
-                            }
-                            catch (e) {
-                                query.destroy(e);
-                                return;
-                            }
-                            if (!results.push(row)) {
-                                query.cursor.close();
-                            }
-                        });
-                        query.on("error", err => {
-                            releaseOnce(err);
-                            reject(err);
-                        });
-                        query.on("end", () => {
-                            resolve(results.rows);
-                        });
-                    });
-                }
-            });
-        }
-        finally {
-            releaseOnce();
-        }
-    }
-    async close() {
-        await this.pool.end();
-    }
-}
-function verifyUniqueColumnNames(fields) {
-    const colNames = new Set();
-    fields.forEach(field => {
-        if (colNames.has(field.name)) {
-            throw new Error(`Ambiguous column name: ${field.name}`);
-        }
-        colNames.add(field.name);
-    });
-}
-function convertFieldType(type) {
-    switch (String(type).toUpperCase()) {
-        case "FLOAT":
-        case "FLOAT4":
-        case "FLOAT8":
-        case "DOUBLE PRECISION":
-        case "REAL":
-            return sqlanvil.Field.Primitive.FLOAT;
-        case "INTEGER":
-        case "INT":
-        case "INT2":
-        case "INT4":
-        case "INT8":
-        case "BIGINT":
-        case "SMALLINT":
-            return sqlanvil.Field.Primitive.INTEGER;
-        case "DECIMAL":
-        case "NUMERIC":
-            return sqlanvil.Field.Primitive.NUMERIC;
-        case "BOOLEAN":
-        case "BOOL":
-            return sqlanvil.Field.Primitive.BOOLEAN;
-        case "STRING":
-        case "VARCHAR":
-        case "CHAR":
-        case "CHARACTER":
-        case "CHARACTER VARYING":
-        case "NVARCHAR":
-        case "TEXT":
-        case "NCHAR":
-        case "BPCHAR":
-            return sqlanvil.Field.Primitive.STRING;
-        case "DATE":
-            return sqlanvil.Field.Primitive.DATE;
-        case "TIMESTAMP":
-        case "TIMESTAMPZ":
-        case "TIMESTAMP WITHOUT TIME ZONE":
-        case "TIMESTAMP WITH TIME ZONE":
-            return sqlanvil.Field.Primitive.TIMESTAMP;
-        default:
-            return sqlanvil.Field.Primitive.UNKNOWN;
-    }
-}
-
-const INTERNAL_SCHEMAS = new Set(["information_schema", "pg_catalog", "pg_internal", "pg_toast"]);
-class PostgresDbAdapter {
-    constructor(queryExecutor) {
-        this.queryExecutor = queryExecutor;
-    }
-    static async create(credentials, options) {
-        const sslMode = (credentials.sslMode || "").toLowerCase();
-        const sslEnabled = !(options === null || options === void 0 ? void 0 : options.disableSslForTestsOnly) && sslMode !== "disable";
-        const clientConfig = {
-            host: credentials.host,
-            port: credentials.port,
-            database: credentials.database,
-            user: credentials.user,
-            password: credentials.password,
-            ssl: sslEnabled
-                ? {
-                    rejectUnauthorized: sslMode === "verify-ca" || sslMode === "verify-full"
-                }
-                : false
-        };
-        const queryExecutor = new PgPoolExecutor(clientConfig, options);
-        try {
-            await queryExecutor.verifyConnection();
-        }
-        catch (e) {
-            await queryExecutor.close().catch(() => undefined);
-            throw new ErrorWithCause(`Could not connect to Postgres at ${credentials.host}:${credentials.port} ` +
-                `as "${credentials.user}": ${e.message}`, e);
-        }
-        return new PostgresDbAdapter(queryExecutor);
-    }
-    async execute(statement, options = { rowLimit: 1000, byteLimit: 1024 * 1024 }) {
-        return await this.withClientLock(client => client.execute(statement, options));
-    }
-    async executeRaw(statement, options = { rowLimit: 1000 }) {
-        const result = await this.execute(statement, options);
-        return Object.assign(Object.assign({}, result), { schema: [] });
-    }
-    async withClientLock(callback) {
-        return await this.queryExecutor.withClientLock(client => callback({
-            execute: async (stmt, opts = { rowLimit: 1000, byteLimit: 1024 * 1024 }) => {
-                try {
-                    const rows = await client.execute(stmt, opts);
-                    return { rows, metadata: {} };
-                }
-                catch (e) {
-                    if (opts.includeQueryInError) {
-                        throw new Error(`Error encountered while running "${stmt}": ${e.message}`);
-                    }
-                    throw new ErrorWithCause(`Error executing postgres query: ${e.message}`, e);
-                }
-            },
-            executeRaw: async (stmt, opts = { rowLimit: 1000 }) => {
-                const positional = opts.params ? Object.values(opts.params) : undefined;
-                const rows = await client.execute(stmt, { params: positional, rowLimit: opts.rowLimit });
-                return { rows, schema: [], metadata: {} };
-            }
-        }));
-    }
-    async evaluate(queryOrAction) {
-        const validationQueries = collectEvaluationQueries(queryOrAction, false, (query) => !!query ? `explain ${query}` : "").map((validationQuery, index) => ({ index, validationQuery }));
-        const validationQueriesWithoutWrappers = collectEvaluationQueries(queryOrAction, false);
-        const queryEvaluations = new Array();
-        for (const { index, validationQuery } of validationQueries) {
-            let evaluationResponse = {
-                status: sqlanvil.QueryEvaluation.QueryEvaluationStatus.SUCCESS
-            };
-            try {
-                await this.execute(validationQuery.query);
-            }
-            catch (e) {
-                evaluationResponse = {
-                    status: sqlanvil.QueryEvaluation.QueryEvaluationStatus.FAILURE,
-                    error: parsePostgresEvalError(validationQuery.query, e)
-                };
-            }
-            queryEvaluations.push(sqlanvil.QueryEvaluation.create(Object.assign(Object.assign({}, evaluationResponse), { incremental: validationQuery.incremental, query: validationQueriesWithoutWrappers[index].query })));
-        }
-        return queryEvaluations;
-    }
-    async tables(_database, schema) {
-        const params = [];
-        let schemaClause = "";
-        let matviewSchemaClause = "";
-        if (schema) {
-            schemaClause = "and table_schema = $1";
-            matviewSchemaClause = "and schemaname = $1";
-            params.push(schema);
-        }
-        const queryResult = await this.execute(`select table_name, table_schema
-       from information_schema.tables
-       where table_schema not in ('information_schema', 'pg_catalog', 'pg_internal', 'pg_toast')
-       ${schemaClause}
-       union
-       select matviewname as table_name, schemaname as table_schema
-       from pg_matviews
-       where schemaname not in ('information_schema', 'pg_catalog', 'pg_internal', 'pg_toast')
-       ${matviewSchemaClause}`, { params, rowLimit: 10000, includeQueryInError: true });
-        const targets = queryResult.rows.map(row => ({
-            schema: row.table_schema,
-            name: row.table_name
-        }));
-        return await Promise.all(targets.map(target => this.table(target)));
-    }
-    async search(searchText, options = { limit: 1000 }) {
-        const results = await this.execute(`select tables.table_schema as table_schema, tables.table_name as table_name
-       from information_schema.tables as tables
-       left join information_schema.columns columns
-         on tables.table_schema = columns.table_schema
-         and tables.table_name = columns.table_name
-       where tables.table_schema ilike $1
-          or tables.table_name ilike $1
-          or columns.column_name ilike $1
-       group by 1, 2`, {
-            params: [`%${searchText}%`],
-            rowLimit: options.limit
-        });
-        return await Promise.all(results.rows.map(row => this.table({
-            schema: row.table_schema,
-            name: row.table_name
-        })));
-    }
-    async table(target) {
-        const params = [target.schema, target.name];
-        const [tableResults, columnResults, descriptionResults, matviewResults, matviewColumns] = await Promise.all([
-            this.execute(`select table_type from information_schema.tables where table_schema = $1 and table_name = $2`, { params, includeQueryInError: true }),
-            this.execute(`select column_name, data_type, is_nullable, ordinal_position
-           from information_schema.columns
-           where table_schema = $1 and table_name = $2`, { params, includeQueryInError: true }),
-            this.execute(`select objsubid as column_number, description
-           from pg_description
-           where objoid = (
-             select oid from pg_class where relname = $2 and relnamespace = (
-               select oid from pg_namespace where nspname = $1
-             )
-           )`, { params, includeQueryInError: true }),
-            this.execute(`select 1 from pg_matviews where schemaname = $1 and matviewname = $2`, { params, includeQueryInError: true }),
-            this.execute(`select a.attname as column_name, format_type(a.atttypid, a.atttypmod) as data_type,
-                  a.attnum as ordinal_position
-           from pg_attribute a
-           join pg_class c on c.oid = a.attrelid
-           join pg_namespace n on n.oid = c.relnamespace
-           where n.nspname = $1 and c.relname = $2 and a.attnum > 0 and not a.attisdropped
-           order by a.attnum`, { params, includeQueryInError: true })
-        ]);
-        const findDescription = (columnNumber) => { var _a; return (_a = descriptionResults.rows.find(row => row.column_number === columnNumber)) === null || _a === void 0 ? void 0 : _a.description; };
-        if (tableResults.rows.length > 0) {
-            return sqlanvil.TableMetadata.create({
-                target,
-                type: tableResults.rows[0].table_type === "VIEW"
-                    ? sqlanvil.TableMetadata.Type.VIEW
-                    : sqlanvil.TableMetadata.Type.TABLE,
-                fields: columnResults.rows.map(row => sqlanvil.Field.create({
-                    name: row.column_name,
-                    primitive: convertFieldType(row.data_type),
-                    description: findDescription(row.ordinal_position)
-                })),
-                description: findDescription(0)
-            });
-        }
-        if (matviewResults.rows.length > 0) {
-            return sqlanvil.TableMetadata.create({
-                target,
-                type: sqlanvil.TableMetadata.Type.MATERIALIZED_VIEW,
-                fields: matviewColumns.rows.map(row => sqlanvil.Field.create({
-                    name: row.column_name,
-                    primitive: convertFieldType(String(row.data_type).replace(/\(.*\)/, "")),
-                    description: findDescription(row.ordinal_position)
-                })),
-                description: findDescription(0)
-            });
-        }
-        return null;
-    }
-    async deleteTable(target) {
-        const metadata = await this.table(target);
-        if (!metadata) {
-            return;
-        }
-        const kind = metadata.type === sqlanvil.TableMetadata.Type.VIEW ? "view" : "table";
-        await this.execute(`drop ${kind} if exists "${target.schema}"."${target.name}" cascade`, { includeQueryInError: true });
-    }
-    async schemas(_database) {
-        const result = await this.execute(`select nspname from pg_namespace`, {
-            includeQueryInError: true
-        });
-        return result.rows
-            .map(row => row.nspname)
-            .filter(name => !INTERNAL_SCHEMAS.has(name) && !name.startsWith("pg_"));
-    }
-    async createSchema(_database, schema) {
-        await this.execute(`create schema if not exists "${schema}"`, {
-            includeQueryInError: true
-        });
-    }
-    async setMetadata(action) {
-        var _a;
-        const { target, actionDescriptor, tableType } = action;
-        const actualMetadata = await this.table(target);
-        if (!actualMetadata) {
-            return;
-        }
-        const relationKind = actualMetadata.type === sqlanvil.TableMetadata.Type.MATERIALIZED_VIEW
-            ? "materialized view"
-            : tableType === "view"
-                ? "view"
-                : "table";
-        const queries = [];
-        if (actionDescriptor === null || actionDescriptor === void 0 ? void 0 : actionDescriptor.description) {
-            queries.push(this.execute(`comment on ${relationKind} "${target.schema}"."${target.name}" is '${actionDescriptor.description.replace(/'/g, "''")}'`));
-        }
-        if (((_a = actionDescriptor === null || actionDescriptor === void 0 ? void 0 : actionDescriptor.columns) === null || _a === void 0 ? void 0 : _a.length) > 0) {
-            actionDescriptor.columns
-                .filter(column => column.path.length === 1 &&
-                actualMetadata.fields.some(field => field.name === column.path[0]))
-                .forEach(column => {
-                queries.push(this.execute(`comment on column "${target.schema}"."${target.name}"."${column.path[0]}" is '${column.description.replace(/'/g, "''")}'`));
-            });
-        }
-        await Promise.all(queries);
-    }
-    async close() {
-        await this.queryExecutor.close();
-    }
-}
-
 class SupabaseDbAdapter extends PostgresDbAdapter {
     static async create(credentials, options) {
         const sslMode = (credentials.sslMode || "").toLowerCase();