teradatasql 20.0.0

package/samples/FastLoadCSV.js

@@ -0,0 +1,116 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const teradatasql_1 = require("teradatasql");
+const fs = __importStar(require("fs"));
+const con = new teradatasql_1.TeradataConnection();
+con.connect({ host: "whomooz", user: "guest", password: "please" });
+const cur = con.cursor();
+const sTableName = "FastLoadCSV";
+let sRequest = "DROP TABLE " + sTableName;
+console.log(sRequest);
+cur.execute(sRequest, undefined, 3807);
+sRequest = "DROP TABLE " + sTableName + "_ERR_1";
+console.log(sRequest);
+cur.execute(sRequest, undefined, 3807);
+sRequest = "DROP TABLE " + sTableName + "_ERR_2";
+console.log(sRequest);
+cur.execute(sRequest, undefined, 3807);
+const records = ["c1,c2", "1,", "2,abc", "3,def", "4,mno", "5,", "6,pqr", "7,uvw", "8,xyz", "9,"];
+console.log("records", records);
+const csvFileName = "dataJs.csv";
+for (const record of records) {
+    fs.appendFileSync(csvFileName, record + "\n");
+}
+try {
+    sRequest = "CREATE TABLE " + sTableName + " (c1 INTEGER NOT NULL, c2 VARCHAR(10))";
+    console.log(sRequest);
+    cur.execute(sRequest);
+    try {
+        console.log("con.autocommit = false");
+        con.autocommit = false;
+        try {
+            const sInsert = "{fn teradata_require_fastload}{fn teradata_read_csv(" + csvFileName + ")}INSERT INTO " + sTableName + " (?, ?)";
+            console.log(sInsert);
+            cur.execute(sInsert);
+            sRequest = "{fn teradata_nativesql}{fn teradata_get_warnings}" + sInsert;
+            console.log(sRequest);
+            cur.execute(sRequest);
+            let rows = cur.fetchall();
+            for (const row of rows) {
+                console.log(row);
+            }
+            sRequest = "{fn teradata_nativesql}{fn teradata_get_errors}" + sInsert;
+            console.log(sRequest);
+            cur.execute(sRequest);
+            rows = cur.fetchall();
+            for (const row of rows) {
+                console.log(row);
+            }
+            sRequest = "{fn teradata_nativesql}{fn teradata_logon_sequence_number}" + sInsert;
+            console.log(sRequest);
+            cur.execute(sRequest);
+            rows = cur.fetchall();
+            for (const row of rows) {
+                console.log(row);
+            }
+            console.log("con.commit()");
+            con.commit();
+            sRequest = "{fn teradata_nativesql}{fn teradata_get_warnings}" + sInsert;
+            console.log(sRequest);
+            cur.execute(sRequest);
+            rows = cur.fetchall();
+            for (const row of rows) {
+                console.log(row);
+            }
+            sRequest = "{fn teradata_nativesql}{fn teradata_get_errors}" + sInsert;
+            console.log(sRequest);
+            cur.execute(sRequest);
+            rows = cur.fetchall();
+            for (const row of rows) {
+                console.log(row);
+            }
+        }
+        finally {
+            console.log("con.autocommit = true");
+            con.autocommit = true;
+        }
+        sRequest = "SELECT * FROM " + sTableName + " ORDER BY 1";
+        console.log(sRequest);
+        cur.execute(sRequest);
+        const rows = cur.fetchall();
+        for (const row of rows) {
+            console.log(row);
+        }
+    }
+    finally {
+        sRequest = "DROP TABLE " + sTableName;
+        console.log(sRequest);
+        cur.execute(sRequest);
+    }
+}
+finally {
+    console.log(`delete ${csvFileName}`);
+    fs.unlinkSync(csvFileName);
+}
+cur.close();
+con.close();
+//# sourceMappingURL=FastLoadCSV.js.map

package/samples/HelpSession.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const teradatasql_1 = require("teradatasql");
+const con = new teradatasql_1.TeradataConnection();
+con.connect({ host: "whomooz", user: "guest", password: "please" });
+const cur = con.cursor();
+cur.execute("help session");
+const row = cur.fetchone();
+if (row) {
+    for (let i = 0; i < row.length; i++) {
+        if (cur.description) {
+            console.log(`${cur.description[i][0].padEnd(40)}, ${row[i]}`);
+        }
+    }
+}
+cur.close();
+con.close();
+//# sourceMappingURL=HelpSession.js.map

package/samples/IgnoreErrors.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const teradatasql_1 = require("teradatasql");
+const con = new teradatasql_1.TeradataConnection();
+con.connect({ host: "whomooz", user: "guest", password: "please" });
+const cur = con.cursor();
+console.log("Demonstrating how to ignore caught exceptions:");
+console.log("drop user NonExistentUser");
+try {
+    cur.execute("drop user NonExistentUser");
+}
+catch (ex) {
+    if (ex instanceof teradatasql_1.OperationalError && ex.message.includes("[Error 3802]")) {
+        console.log("Ignoring", ex.message.split("\n")[0]);
+    }
+    else {
+        throw ex;
+    }
+}
+console.log("drop view NonExistentView");
+try {
+    cur.execute("drop view NonExistentView");
+}
+catch (ex) {
+    if (ex instanceof teradatasql_1.OperationalError && ex.message.includes("[Error 3807]")) {
+        console.log("Ignoring", ex.message.split("\n")[0]);
+    }
+    else {
+        throw ex;
+    }
+}
+console.log("drop macro NonExistentMacro");
+try {
+    cur.execute("drop macro NonExistentMacro");
+}
+catch (ex) {
+    if (ex instanceof teradatasql_1.OperationalError && ex.message.includes("[Error 3824]")) {
+        console.log("Ignoring", ex.message.split("\n")[0]);
+    }
+    else {
+        throw ex;
+    }
+}
+console.log("drop table NonExistentTable");
+try {
+    cur.execute("drop table NonExistentTable");
+}
+catch (ex) {
+    if (ex instanceof teradatasql_1.OperationalError && ex.message.includes("[Error 3807]")) {
+        console.log("Ignoring", ex.message.split("\n")[0]);
+    }
+    else {
+        throw ex;
+    }
+}
+console.log("drop database NonExistentDbase");
+try {
+    cur.execute("drop database NonExistentDbase");
+}
+catch (ex) {
+    if (ex instanceof teradatasql_1.OperationalError && ex.message.includes("[Error 3802]")) {
+        console.log("Ignoring", ex.message.split("\n")[0]);
+    }
+    else {
+        throw ex;
+    }
+}
+console.log("drop procedure NonExistentProc");
+try {
+    cur.execute("drop procedure NonExistentProc");
+}
+catch (ex) {
+    if (ex instanceof teradatasql_1.OperationalError && ex.message.includes("[Error 5495]")) {
+        console.log("Ignoring", ex.message.split("\n")[0]);
+    }
+    else {
+        throw ex;
+    }
+}
+console.log();
+console.log("Demonstrating how to ignore a single error:");
+console.log("drop table NonExistentTable");
+cur.execute("drop table NonExistentTable", undefined, 3807);
+console.log();
+console.log("Demonstrating how to ignore several different errors:");
+const nonExistenceErrors = [
+    3526,
+    3802,
+    3807,
+    3824,
+    3913,
+    4322,
+    5322,
+    5495,
+    5589,
+    5620,
+    5623,
+    5653,
+    5901,
+    6808,
+    6831,
+    6834,
+    6849,
+    6863,
+    6934,
+    6938,
+    7972,
+    9213,
+    9403,
+];
+console.log("drop user NonExistentUser");
+cur.execute("drop user NonExistentUser", undefined, nonExistenceErrors);
+console.log("drop view NonExistentView");
+cur.execute("drop view NonExistentView", undefined, nonExistenceErrors);
+console.log("drop macro NonExistentMacro");
+cur.execute("drop macro NonExistentMacro", undefined, nonExistenceErrors);
+console.log("drop table NonExistentTable");
+cur.execute("drop table NonExistentTable", undefined, nonExistenceErrors);
+console.log("drop database NonExistentDbase");
+cur.execute("drop database NonExistentDbase", undefined, nonExistenceErrors);
+console.log("drop procedure NonExistentProc");
+cur.execute("drop procedure NonExistentProc", undefined, nonExistenceErrors);
+cur.close();
+con.close();
+//# sourceMappingURL=IgnoreErrors.js.map

package/samples/InsertLob.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const teradatasql_1 = require("teradatasql");
+function byte(s, encoding) {
+    return Uint8Array.from(Buffer.from(s, encoding));
+}
+function FormatValue(oValue) {
+    let s;
+    if (typeof oValue === "string") {
+        s = oValue;
+        if (s.length > 20) {
+            s = s.slice(0, 20) + " ...";
+        }
+        return s + ` (len=${oValue.length})`;
+    }
+    else if (oValue instanceof Uint8Array) {
+        s = Buffer.from(oValue).toString();
+        if (s.length > 20) {
+            s = s.slice(0, 20) + " ...";
+        }
+        return `byte('${s}')` + ` (len=${oValue.length})`;
+    }
+    else {
+        return oValue;
+    }
+}
+const con = new teradatasql_1.TeradataConnection();
+con.connect({ host: "whomooz", user: "guest", password: "please", log: "8" });
+const cur = con.cursor();
+let sSQL = "create volatile table voltab (c1 integer, c2 blob, c3 clob) on commit preserve rows";
+console.log(sSQL);
+cur.execute(sSQL);
+const abySmallBlob = byte("abc");
+const abyLargeBlob = byte("ABC".repeat(75000));
+const sSmallClob = "xyz";
+const sLargeClob = "XYZ".repeat(25000);
+sSQL = "insert into voltab values (?, ?, ?)";
+console.log(sSQL);
+cur.execute(sSQL, [1, abySmallBlob, sSmallClob]);
+console.log(sSQL);
+cur.execute(sSQL, [2, abyLargeBlob, sLargeClob]);
+sSQL = "select * from voltab order by 1";
+console.log(sSQL);
+cur.execute(sSQL);
+let nRow = 0;
+let row = null;
+while (true) {
+    row = cur.fetchone();
+    if (!row) {
+        break;
+    }
+    nRow += 1;
+    if (cur.description) {
+        for (let iColumn = 0; iColumn < row.length; iColumn++) {
+            console.log(`Row ${nRow} Column ${iColumn + 1} "${cur.description[iColumn][0]}" = ${FormatValue(row[iColumn])}`);
+        }
+    }
+}
+console.log(`Fetched ${nRow} rows`);
+cur.close();
+con.close();
+//# sourceMappingURL=InsertLob.js.map

package/samples/InsertXML.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const teradatasql_1 = require("teradatasql");
+const con = new teradatasql_1.TeradataConnection();
+con.connect({ host: "whomooz", user: "guest", password: "please" });
+const cur = con.cursor();
+cur.execute("create volatile table voltab (c1 integer, c2 xml) on commit preserve rows");
+cur.execute("{fn teradata_parameter(2,XML)}insert into voltab values (?, ?)", [
+    [1, "<hello>world</hello>"],
+    [2, "<hello>moon</hello>"],
+]);
+cur.execute("{fn teradata_fake_result_sets}select * from voltab order by 1");
+const asTypeNames = [];
+let row = cur.fetchone();
+if (row) {
+    const json = JSON.parse(row[7].toString());
+    for (const elem of json) {
+        for (const k in elem) {
+            if (k === "TypeName") {
+                asTypeNames.push(elem[k]);
+            }
+        }
+    }
+}
+cur.nextset();
+const rows = cur.fetchall();
+for (let nRow = 0; nRow < rows.length; nRow++) {
+    row = rows[nRow];
+    if (row && cur.description) {
+        for (let iColumn = 0; iColumn < row.length; iColumn++) {
+            console.log(`Row ${nRow + 1} Column ${cur.description[iColumn][0]} ${asTypeNames[iColumn].padEnd(7)} ${row[iColumn]}`);
+        }
+    }
+}
+cur.close();
+con.close();
+//# sourceMappingURL=InsertXML.js.map

package/samples/LoadCSVFile.js

@@ -0,0 +1,41 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const sync_1 = require("csv-parse/sync");
+const teradatasql_1 = require("teradatasql");
+const con = new teradatasql_1.TeradataConnection();
+con.connect({ host: "whomooz", user: "guest", password: "please" });
+const cur = con.cursor();
+cur.execute("create volatile table Airports (City varchar(100), Airport varchar(100), AirportCode varchar(10)) on commit preserve rows");
+console.log("Slower approach - use a cvs module to parse data values from a CSV file");
+const records = sync_1.parse(fs.readFileSync("airports.csv", { encoding: "utf-8" }));
+cur.execute("insert into Airports (?, ?, ?)", records);
+cur.execute("select AirportCode, Airport, City from Airports order by AirportCode");
+console.log(cur.fetchall());
+cur.execute("delete from Airports");
+console.log("Faster approach - the driver loads data values from a CSV file");
+cur.execute("{fn teradata_read_csv(airports.csv)}insert into Airports (?, ?, ?)");
+cur.execute("select AirportCode, Airport, City from Airports order by AirportCode");
+console.log(cur.fetchall());
+cur.close();
+con.close();
+//# sourceMappingURL=LoadCSVFile.js.map

package/samples/LobLocators.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const teradatasql_1 = require("teradatasql");
+function byte(s, encoding) {
+    return Uint8Array.from(Buffer.from(s, encoding));
+}
+function ReadLobValueFromLobLocator(con, abyLocator, sTypeName) {
+    if (!(abyLocator instanceof Uint8Array)) {
+        throw TypeError("abyLocator must be Unint8Array");
+    }
+    const cur = con.cursor();
+    sSQL = "{fn teradata_parameter(1," + sTypeName + ")}select ?";
+    console.log(sSQL);
+    cur.execute(sSQL, [abyLocator]);
+    const row = cur.fetchone();
+    let result = null;
+    if (row) {
+        result = row[0];
+    }
+    cur.close();
+    return result;
+}
+const con = new teradatasql_1.TeradataConnection();
+con.connect({ host: "whomooz", user: "guest", password: "please" });
+const cur = con.cursor();
+let sSQL = "create volatile table voltab (c1 integer, c2 blob, c3 clob, c4 xml, c5 st_geometry, c6 json) on commit preserve rows";
+console.log(sSQL);
+cur.execute(sSQL);
+const sXML = '<?xml version="1.0" encoding="UTF-8"?><foo>bar</foo>';
+const sJSON = '{"foo":"bar"}';
+sSQL =
+    "insert into voltab values (1, '" + Buffer.from(byte("ABC")).toString("hex") + "'xbv, 'clobval', '" + sXML + "', 'point(1 2)', '" + sJSON + "')";
+console.log(sSQL);
+cur.execute(sSQL);
+sSQL = "{fn teradata_lobselect(S)}{fn teradata_fake_result_sets}select * from voltab order by 1";
+console.log(sSQL);
+cur.execute(sSQL);
+const aoFakeResultSetRow = cur.fetchone();
+if (aoFakeResultSetRow) {
+    const sResultSetColumnMetadataJSON = aoFakeResultSetRow[7].toString();
+    const amapResultSetColumnMetadata = JSON.parse(sResultSetColumnMetadataJSON);
+    cur.nextset();
+    const aoRealResultSetRow = cur.fetchone();
+    if (aoRealResultSetRow) {
+        for (let iColumn = 0; iColumn < aoRealResultSetRow.length; iColumn++) {
+            let oValue = aoRealResultSetRow[iColumn];
+            const sTypeName = amapResultSetColumnMetadata[iColumn]["TypeName"];
+            if (sTypeName.startsWith("LOCATOR(")) {
+                oValue = ReadLobValueFromLobLocator(con, oValue, sTypeName);
+            }
+            console.log(`Column ${iColumn + 1} ${sTypeName} value: ${oValue}`);
+        }
+    }
+}
+cur.close();
+con.close();
+//# sourceMappingURL=LobLocators.js.map

package/samples/MetadataFromPrepare.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const teradatasql_1 = require("teradatasql");
+const con = new teradatasql_1.TeradataConnection();
+con.connect({ host: "whomooz", user: "guest", password: "please" });
+const cur = con.cursor();
+cur.execute("{fn teradata_rpo(S)}{fn teradata_fake_result_sets}select * from dbc.dbcinfo where infokey=?");
+const row = cur.fetchone();
+if (row && cur.description) {
+    console.log("SQL statement metadata from prepare operation:");
+    console.log();
+    for (let i = 0; i < cur.description.length; i++) {
+        console.log(`   Column [${i}] ${cur.description[i][0].padEnd(18)} : ${row[i]}`);
+    }
+    console.log("Result set column metadata as JSON:");
+    console.log(JSON.parse(row[7]));
+    console.log();
+    console.log("Parameter marker metadata as JSON:");
+    console.log(JSON.parse(row[8]));
+}
+cur.close();
+con.close();
+//# sourceMappingURL=MetadataFromPrepare.js.map

package/samples/ParamDataTypes.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const teradatasql_1 = require("teradatasql");
+function byte(s, encoding) {
+    return Uint8Array.from(Buffer.from(s, encoding));
+}
+const con = new teradatasql_1.TeradataConnection();
+con.connect({ host: "whomooz", user: "guest", password: "please" });
+const cur = con.cursor();
+const aao = [
+    ["BYTEINT", 1n],
+    ["SMALLINT", 2n],
+    ["INTEGER", 3n],
+    ["BIGINT", 4n],
+    ["FLOAT", "5"],
+    ["NUMBER", "6"],
+    ["DECIMAL(18)", "7"],
+    ["DECIMAL(38)", "8"],
+    ["PERIOD(DATE)", "0009-09-09,0909-09-09"],
+    ["PERIOD(TIME)", "10:10:10.101000,10:10:10.101010"],
+    ["PERIOD(TIME WITH TIME ZONE)", "11:11:11.111110+11:11,11:11:11.111111+11:11"],
+    ["PERIOD(TIMESTAMP)", "1212-01-12 12:12:12.121212,1212-02-12 12:12:12.121212"],
+    ["PERIOD(TIMESTAMP WITH TIME ZONE)", "1313-01-13 13:13:13.131313+13:13,1313-02-13 13:13:13.131313+13:13"],
+    ["INTERVAL YEAR(4)", "-1414"],
+    ["INTERVAL YEAR(4) TO MONTH", "-1515-11"],
+    ["INTERVAL MONTH(4)", "-1616"],
+    ["INTERVAL DAY(4)", "-1717"],
+    ["INTERVAL DAY(4) TO HOUR", "-1818 18"],
+    ["INTERVAL DAY(4) TO MINUTE", "-1919 19:19"],
+    ["INTERVAL DAY(4) TO SECOND", "-2020 20:20:20.202020"],
+    ["INTERVAL HOUR(4)", "-2121"],
+    ["INTERVAL HOUR(4) TO MINUTE", "-2222:22"],
+    ["INTERVAL HOUR(4) TO SECOND", "-2323:23:23.232323"],
+    ["INTERVAL MINUTE(4)", "-2424"],
+    ["INTERVAL MINUTE(4) TO SECOND", "-2525:25.252525"],
+    ["INTERVAL SECOND(4)", "-2626.262626"],
+    ["BYTE(2)", byte("27")],
+    ["CHAR(2)", "28"],
+];
+console.log("   teradata_parameter bind type      Result from TYPE function            Round-trip data value");
+console.log("   --------------------------------  -----------------------------------  ---------------------");
+for (let n = 0; n < aao.length; n++) {
+    const ao = aao[n];
+    const sDataType = ao[0];
+    const oValue = ao[1];
+    cur.execute("{fn teradata_parameter(1," + sDataType + ")}select trim(type(?))", [null]);
+    const row = cur.fetchone();
+    const sTypeFuncResult = row ? row[0] : "";
+    let oOutput;
+    if (sDataType.startsWith("PERIOD")) {
+        cur.execute("create volatile table volatiletable (c1 " + sDataType + ") no primary index on commit preserve rows");
+        cur.execute("{fn teradata_parameter(1," + sDataType + ")}insert into volatiletable values (?)", [oValue]);
+        cur.execute("select * from volatiletable");
+        const row = cur.fetchone();
+        oOutput = row ? row[0] : null;
+        cur.execute("drop table volatiletable");
+    }
+    else if (sDataType.startsWith("BYTE(")) {
+        oOutput = 'byte("' + Buffer.from(oValue).toString() + '")';
+    }
+    else {
+        cur.execute("{fn teradata_parameter(1," + sDataType + ")}select ?", [oValue]);
+        const row = cur.fetchone();
+        oOutput = row ? row[0] : null;
+    }
+    console.log(`${(n + 1).toString().padEnd(2)} ${sDataType.padEnd(33)} ${sTypeFuncResult.padEnd(36)} ${oOutput}`);
+}
+cur.close();
+con.close();
+//# sourceMappingURL=ParamDataTypes.js.map

package/samples/ShowCommand.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const teradatasql_1 = require("teradatasql");
+function ShowCommand(cur, s) {
+    console.log("-- " + s);
+    cur.execute(s);
+    let n = 1;
+    while (true) {
+        console.log(`-- result set ${n}`);
+        const rows = cur.fetchall();
+        for (const row of rows) {
+            const s = JSON.stringify(row).split("\\r").join("\n");
+            console.log(s.slice(2, s.length - 2));
+        }
+        if (cur.nextset()) {
+            n += 1;
+        }
+        else {
+            break;
+        }
+    }
+}
+const con = new teradatasql_1.TeradataConnection();
+con.connect({ host: "whomooz", user: "guest", password: "please" });
+const cur = con.cursor();
+ShowCommand(cur, "show view DBC.DBCInfo");
+console.log();
+ShowCommand(cur, "show select * from DBC.DBCInfo");
+cur.close();
+con.close();
+//# sourceMappingURL=ShowCommand.js.map

package/samples/StoredProc.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const teradatasql_1 = require("teradatasql");
+function DisplayResults(cur) {
+    while (true) {
+        console.log(" === metadata ===");
+        console.log("  cur.rowcount:", cur.rowcount);
+        console.log("  cur.description:", cur.description);
+        console.log(" === result ===");
+        console.log(cur.fetchall());
+        if (!cur.nextset()) {
+            break;
+        }
+    }
+}
+function cur_execute(cur, sSQL, params) {
+    console.log();
+    console.log("cur.execute", sSQL, "bound values", params);
+    cur.execute(sSQL, params);
+    DisplayResults(cur);
+}
+function cur_callproc(cur, sProcName, params) {
+    console.log();
+    console.log("cur.callproc", sProcName, "bound values", params);
+    cur.callproc(sProcName, params);
+    DisplayResults(cur);
+}
+const con = new teradatasql_1.TeradataConnection();
+con.connect({ host: "whomooz", user: "guest", password: "please" });
+const cur = con.cursor();
+cur.execute("replace procedure examplestoredproc (in p1 integer, inout p2 integer) begin set p2 = p1 + p2 ; end ;");
+try {
+    cur_execute(cur, "{call examplestoredproc (3, 5)}");
+    cur_execute(cur, "{call examplestoredproc (?, ?)}", [10, 7]);
+    cur_callproc(cur, "examplestoredproc", [20, 4]);
+    cur.execute("replace procedure examplestoredproc (out p1 varchar(100)) begin set p1 = 'foobar' ; end ;");
+    cur_execute(cur, "{call examplestoredproc (?)}");
+    cur.execute(`replace procedure examplestoredproc ()
+                dynamic result sets 1
+                begin
+                    declare cur1 cursor with return for select * from dbc.dbcinfo order by 1 ;
+                    open cur1 ;
+                end ;`);
+    cur_execute(cur, "{call examplestoredproc}");
+    cur_callproc(cur, "examplestoredproc");
+    cur.execute(`replace procedure examplestoredproc (in p1 integer, inout p2 integer, inout p3 integer)
+            dynamic result sets 2
+            begin
+                declare cur1 cursor with return for select * from dbc.dbcinfo order by 1 ;
+                declare cur2 cursor with return for select infodata, infokey from dbc.dbcinfo order by 1 ;
+                open cur1 ;
+                open cur2 ;
+                set p2 = p1 + p2 ;
+                set p3 = p1 * p3 ;
+            end ;`);
+    cur_execute(cur, "{call examplestoredproc (2, 1, 3)}");
+    cur_execute(cur, "{call examplestoredproc (?, ?, ?)}", [3, 2, 4]);
+    cur_callproc(cur, "examplestoredproc", [10, 3, 2]);
+    cur.execute(`replace procedure examplestoredproc (in p1 integer, inout p2 integer, out p3 varchar(100))
+                dynamic result sets 2
+                begin
+                    declare cur1 cursor with return for select * from dbc.dbcinfo order by 1 desc ;
+                    declare cur2 cursor with return for select infodata, infokey from dbc.dbcinfo order by 1 ;
+                    open cur1 ;
+                    open cur2 ;
+                    set p2 = p1 + p2 ;
+                    set p3 = 'hello' ;
+                end ;`);
+    cur_execute(cur, "{call examplestoredproc (10, 5, ?)}");
+    cur_execute(cur, "{call examplestoredproc (?, ?, ?)}", [20, 7]);
+}
+finally {
+    cur.execute("drop procedure examplestoredproc");
+}
+cur.close();
+con.close();
+//# sourceMappingURL=StoredProc.js.map