Tabelle Geschätzten Parameter im Knoten/Langweilig Beispiel

Habe ich eine Funktion, dass funktioniert wirklich gut für die Ausführung gespeicherte Prozeduren und SQL snippets. Ich Frage mich, ob jemand in der Lage wäre, mir zu helfen, machen die äquivalente callProcedure für Tabelle Geschätzten Parameter?

Meine aktuelle Funktion ist wie folgt.

`var exec = function (sql, callback) {

    var request = new Request(sql, function (err, rowCount) {
        if (err) {
            console.log('Statement failed: ' + err);
        } else {
            console.log(rowCount + ' rows');
        }

        callback(err, obj);

    });

    var obj = [];

    request.on('row', function (columns) {
    var values = {};
    columns.forEach(function (column) {
        if (column.isNull) {
            values[column.metadata.colName] = null;
        } else {
            values[column.metadata.colName] = column.value;
        }
    });
    obj.push(values);
    //console.log(obj);
    //console.log(" this is the obj in the row function");
});
conn.execSql(request);
//console.log('obj: ' + obj);
return obj;
function columnMetadata(columnsMetadata) {
    columnsMetadata.forEach(function (column) {
    //console.log(column);
    });

}`

Ich habe dies in SQL zu machen Tabelle Typ:

`--Create the data type
CREATE TYPE dbo.inventoryRequestType AS TABLE
(
    ItemNo int NULL
    , Qty int NULL
    , Department nvarchar(50) NULL
    , RequestedBy nvarchar(100) NULL
)
GO`

Und diese gespeicherte Prozedur wird verwendet, um einfügen mit dem neuen Tabelle Typ:

`Create PROCEDURE [dbo].[create_purchasing_list]
    -- Add the parameters for the stored procedure here
    @purchaseList inventoryRequestType ReadOnly

    AS
    BEGIN
       SET NOCOUNT ON;
       INSERT INTO [Inventory Requests]
       (
         ItemNo
         , Qty
         , Department
         , RequestedBy
        )
       SELECT 
         ItemNo
         , Qty
         , Department
         , RequestedBy
        FROM @purchaseList
    END`

In SQL, die folgenden verwendet werden kann zum ausführen der gespeicherte Prozedur:

`DECLARE @purchaseList inventoryRequestType

 INSERT INTO @purchaseList

 SELECT 4444, 1, 'layup', 'marc'

 EXEC Purchasing.dbo.create_purchasing_list @purchaseList

`

—> dies ist, wo ich verloren gehen. Ich bin mir nicht sicher, wie dieser Letzte Teil der Arbeit mit Knoten/langweilig

hier ist ein Beispiel, wie ich möchte in einer Tabelle definieren mit der Funktion “ ich brauche Hilfe mit dem.

Spalten und Zeilen Variablen definiert werden würde durch die mit-Funktion.

var table = {
columns: [
Columns
//{name: 'id', type: Types.Int},
//{name: 'firstName', type: Types.nvarchar, length: 50}
//{name: 'option', type: Types.Bit}
],
rows: [
Rows
//[15, 'Bob', true],
//[16, 'Rob', false]
]
};

Vielen Dank im Voraus,

Marc

  • Ich habe jetzt eine Funktion, die tut alles was ich brauche auf der Datenbank-Seite,
  • jedoch ist es versagt mit Fehler,
  • net::ERR_EMPTY_RESPONSE
  • Im folgenden ist die Funktion, die ich habe kommen mit, bitte helfen Sie, wenn möglich.
InformationsquelleAutor Marc D | 2016-01-07



2 Replies
  1. 1
    `var storedProcedures = {
    'purchasing_list':
        {
            'fullName': 'Purchases.dbo.purchasing_list',
            'variable': 'purchaseList',
            'Columns' : [
                { 'name': 'ItemNo', 'type': Types.Int }
                , { 'name': 'ProductName', 'type': Types.NVarChar }
                , { 'name': 'ProductDescription', 'type': Types.NVarChar }
                , { 'name': 'UnitOfMeasure', 'type': Types.NVarChar }
                , { 'name': 'Qty', 'type': Types.Int }
                , { 'name': 'Department', 'type': Types.NVarChar }
                , { 'name': 'RequestedBy', 'type': Types.NVarChar }
            ]
        }
    }
    
    var callProc = function (procedureName, Rows,callback) {
    
    var usefulData = storedProcedures[procedureName];
    
    var table = {
        columns: usefulData['Columns'],
        rows: Rows          //insert an array of arrays with values defined by storedProcedure
    };
    
    var request = new Request(usefulData['fullName'], function (err, rowCount) {
        if (err) {
            console.log('Statement failed: ' + err);
            callback = err;
        } else {
            console.log('No errors in TVP')
            callback = 'Success';
        }
    
    });
    
    request.addParameter(usefulData['variable'], Types.TVP, table);
    
    conn.callProcedure(request);
    
    };`
    • Dies schließt die stecken aber Fehler mit net::ERR_EMPTY_RESPONSE
  2. 1

    Habe ich nun eine voll funktionsfähige Lösung. Es ist sehr dynamisch, so will ich es teilen, da ich nicht in der Lage war, eine Lösung zu finden in den Beispielen hier.

    Dies ist mein db-functions.js Datei, die aufgerufen wird, die durch meine app.js

    var express = require('express');
    var tds = require('tedious');
    var Request = require('tedious').Request;
    var Types = require('tedious').TYPES;
    var ConnectionPool = require('tedious-connection-pool');
    
    
    
    var poolConfig = {
        min: 10,
        log: true
    };
    
    var config = {
        userName: "User",
        password: "password",
    server: "192.168.1.123", //--------------------{  Production Server }        
    options: 
    {
        requestTimeout: 30 * 1000,
        instanceName: '\InstanceOnServer', 
        //instanceName: '\SQLServer', //Name of SQL Instance
        rowCollectionOnRequestCompletion: true,
        database: 'PlantDB',
        encrypt: true,
        debug: {
            data: true, //lots of info generated in console when true
            payload: false,
            token: false,
            packet: true, //was on true
            log: true
        }
      }
    };
    
    var pool = new ConnectionPool(poolConfig, config);//multiple connections
    
    pool.acquire(function (err, connection) {
        if (err) {
            console.log(err);
        } else {
            console.log('connected');
        }
    })
    
    //var conn = new tds.Connection(config);
    
    pool.on('error', function (err) {
        console.log(err);
    });
    
    var conn = new tds.Connection(Config);
    
    function requestDone(rowCount, more) {
        console.log(rowCount + "rows------");
        console.log(column);
    }
    
    function infoError(info) {
        console.log(info.number + ' : ' + info.message);
    }
    
    function debug(message) {
        console.log(message);
    }
    
    var exec = function (sql, callback) { 
    //use this function to execute SELECT statements and Stored Procedures
    
    var request = new Request(sql, function (err, rowCount) {
        if (err) {
            console.log('Statement failed: ' + err);
        } else {
            console.log(rowCount + ' rows');
        }
    
        callback(err, obj);
    
    });
    
    var obj = []; //holds the data generated by the SQL statement when applicable
    
    request.on('row', function (columns) { //identify individual rows
        var values = {};                   //insert a value
        columns.forEach(function (column) {  //identify the column
            if (column.isNull) { /*adds a key to the value so that each item in
                               the object is broken into "Column: Value" pairs*/
                values[column.metadata.colName] = null; 
            } else {
                values[column.metadata.colName] = column.value;
            }
        });
        obj.push(values);
    });
    conn.execSql(request);
    //console.log('obj: ' + obj);
    return obj;
    function columnMetadata(columnsMetadata) {
        columnsMetadata.forEach(function (column) {
        //console.log(column);
        });
    }
    };
    
    
    var storedProcedures = {
      'purchasing_list':  //This is an actual stored procedure that exists in my
                       //Purchases Database which is used to identify this object
       {
          'fullName': 'Purchases.dbo.purchasing_list',
                     //fullname of stored procedure
          'variable': 'purchaseList', 
                     //the name of my "Table Type" Variable created in SQL
          'Columns' : [                                   
                { 'name': 'ItemNo', 'type': Types.Int }
                , { 'name': 'ProductName', 'type': Types.NVarChar }
                , { 'name': 'ProductDescription', 'type': Types.NVarChar }
                , { 'name': 'UnitOfMeasure', 'type': Types.NVarChar }
                , { 'name': 'Qty', 'type': Types.Int }
                , { 'name': 'Department', 'type': Types.NVarChar }
                , { 'name': 'RequestedBy', 'type': Types.NVarChar }
            ]
        },
        'another_stored_procedure': 
        {
            'fullName': 'Purchases.dbo.another_stored_procedure',    
            'variable': 'purchaseList',                     
            'Columns' : [                                   
                { 'name': 'ItemNo', 'type': Types.Int }
                , { 'name': 'ProductName', 'type': Types.NVarChar }
                , { 'name': 'ProductDescription', 'type': Types.NVarChar }
                , { 'name': 'UnitOfMeasure', 'type': Types.NVarChar }
                , { 'name': 'Qty', 'type': Types.Int }
                , { 'name': 'Department', 'type': Types.NVarChar }
                , { 'name': 'RequestedBy', 'type': Types.NVarChar }
            ]
        }
    
     }
    
    var callProc = function (procedureName, Rows, callback) {
    
    var usefulData = storedProcedures[procedureName]; 
    var message = '';
    
    var table = {
        columns: usefulData['Columns'],
        rows: Rows 
         //insert an array of arrays with values defined by storedProcedure
    };
    
    var request = new Request(usefulData['fullName'], function (err, rowCount) {
        if (err) {
            console.log('Statement failed: ' + err);
            message = 'There was a problem submitting your request!';
    
        } else {
            console.log(rowCount + 'No errors in TVP') 
            //this will likely return an undefined rowCount since this function
            //is generally used to insert and update
            message = 'Success'
        }
        callback(err, message);
    
    });
    
    request.on('doneProc', function (rowCount, more, returnStatus, rows) {
        //console.log('Row Count' + rowCount);
        //console.log('More? ' + more);
        //console.log('Return Status: ' + returnStatus);
        //console.log('Rows:' + rows);
    })
    
    request.addParameter(usefulData['variable'], Types.TVP, table); 
    //Add a table type set of parameters to the request to complete the 
    //transaction
    
    conn.callProcedure(request);
    };
    
    var insert = function (sql, callback) {
    
        var request = new Request(sql, function (err, rowCount) {
          if (err) {
            console.log('Statement failed: ' + err);
            callback = err;
          } else {
            console.log('Insert Statement succeeded');
            callback = 'Success';
          }
    
        });
    
    conn.execSql(request);
    
    };
    
    var update = function (sql, callback) {
        var insert = '';
        var request = new Request(sql, function (err, rowCount) {
          if (err) {
    
            insert = ('Statement failed: ' + err)
    
          } else {
    
            insert = ('Insert Statement succeeded');
    
          }
          callback(err, insert);
        });
    
    
        conn.execSql(request);
    
    };
    
    
    exports.conn = conn
    exports.exec = exec
    exports.callProc = callProc
    exports.insert = insert
    exports.update = update

    `

    Innerhalb der App.js Datei, die ich geladen hab meine Datenbank wie diese:

    var db = require('./public/javascripts/db-functions');

    Einen callProcedure, die erlaubt, mehrere Zeilen eingefügt oder aktualisiert werden können
    das wie folgt getan werden:

    app.route('/update_purchasing')
         .post(function (req, res) {  
    
         var Rows = req.body.Rows;
    
        db.callProc('create_purchasing_list', Rows, function (err, success) {
            if (err) {
                res.json('Error creating purchasing list: ' + err);
            } else {
                res.json('Successfully updated your purchase list');
            }
        })
    })

    Den Zeilen könnte wie folgt Aussehen, basierend auf den Spalten in der gespeicherten Prozedur:

    Rows = [
        [0101, 'hair gel', 'makes your hair stick up', 'vat', 1, 'house', 'Bob'],
        [0102, 'carbon', 'makes light boats', 'roll', 1, 'Layup', 'Rob']
     ]`

    Ein Beispiel zum ausführen einer gespeicherten Prozedur mit EXEC mein Aussehen:

    app.get('/start', function (req, res) {   
         var sess = req.session;
    
         db.exec("dbo.populate_shipping_schedule" + "parameter1", function(err, schedule) {
            if (!err) {
    
                    sess.schedule = schedule;
                    res.render('start', { title: 'Start' });
    
            } else {
                    console.log('This is an Error: ' + err)
            }
          })
     })

    `

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.