Tedious: अनुरोध केवल LoggedIn स्थिति में किए जा सकते हैं, SentClientRequest स्थिति में नहीं (कोड: 'EINVALIDSTATE')

एक 'कॉलबैक' संपत्ति है जिसे आप अनुरोध पर सेट कर सकते हैं और अनुरोध पर एक 'अनुरोध पूर्ण' घटना है, दोनों काम लगते हैं। और वे दो चीजें हैं जिनकी हमने कोशिश नहीं की :)

इस पर कुछ सफाई और दस्तावेज़ीकरण की आवश्यकता हो सकती है।

इन्हें आजमाएं और देखें कि यह काम करता है या नहीं।

'कॉलबैक' का उपयोग करना:

  request.callback = function (err, rowCount, rows) {
      // rows is not being set but rowCount is. May be a bug.
      if (err) {
        // Error handling.
      } else {
        // Next SQL statement.
      }
  };

'अनुरोध पूर्ण' का उपयोग करना:

  request.on('requestCompleted', function () {
      // Next SQL statement.
  });

मैं वास्तव में इस नोट को https://github.com/tediousjs/tedious/issues/61 में डालूंगा और इसे बंद कर दूंगा क्योंकि यह वही मुद्दा है।

मुद्दे को फिर से खोलना। https://github.com/tediousjs/tedious/issues/61 पूरी तरह से असंबंधित है। @SaloniSonpal द्वारा बताए गए मुद्दे वास्तव में बंद हैं। इसलिए ट्रैकिंग के लिए इसे फिर से खोल रहे हैं।

इसके लिए कुछ सफाई और दस्तावेज़ीकरण की आवश्यकता है।

धन्यवाद @tvrprasad। ये दोनों काम करते हैं, और साफ-सुथरे हैं। callback दृष्टिकोण त्रुटि को संभालने का लाभ देता है। Event: 'requestCompleted' को निश्चित रूप से प्रलेखित करने की आवश्यकता है।

(मेरे फोन से भेज रहे हैं, संक्षिप्तता के लिए क्षमा करें)।

कॉलबैक गुण सेट करना आपके द्वारा पारित कॉलबैक को अधिलेखित कर देगा
अनुरोध निर्माता के लिए। इसके बजाय, आपको कॉलबैक को कॉल करना चाहिए
कॉलबैक के अंदर async अनुरोध निर्माता को दिया गया। इस तरह आप
त्रुटियों को सही ढंग से async पर अग्रेषित भी कर सकता है।

आह, याद आया कि कॉलबैक पास किए गए कॉलबैक पर सेट है। तो सही तरीका होगा:

  request = new Request(sqlQuery, function (err, rowCount, rows) {
    if (err) {
      // Error handling.
    } else {
      // Next SQL statement.
    }
  });

@arthurschreiber 'अनुरोध पूर्ण' घटना का कोई कारण? अनावश्यक लगता है। एक और चीज जो मैंने नोटिस की है वह है कि कॉलबैक में पास की गई पंक्तियाँ पैरामीटर हमेशा खाली होती हैं। क्या कोई ऐसा परिदृश्य है जहां उसके पास वैध डेटा होगा? मैं दस्तावेज़ीकरण अपडेट करूंगा।

एक और चीज जो मैंने नोटिस की है वह है कि कॉलबैक में पास की गई पंक्तियाँ पैरामीटर हमेशा खाली होती हैं। क्या कोई ऐसा परिदृश्य है जहां उसके पास वैध डेटा होगा? मैं दस्तावेज़ीकरण अपडेट करूंगा।

rowCollectionOnRequestCompletion विकल्प है जिसे कनेक्ट करते समय निर्दिष्ट किया जा सकता है। इसे वैश्विक विकल्प के रूप में रखना थोड़ा अजीब है, मुझे लगता है कि यह प्रति-अनुरोध करने के लिए और अधिक समझ में आता है।

इसके पीछे मुख्य विचार निम्नलिखित है: यदि rowCollectionOnRequestCompletion विकल्प सक्षम है तो पंक्तियों को स्मृति में तब तक संग्रहीत किया जाता है जब तक कि संबंधित Request पूरा नहीं हो जाता (और वर्तमान में, मुझे लगता है कि उन्हें Request तक भी रखा जाता है। है । पसंदीदा तरीका केवल rows कॉलबैक का उपयोग करना है, और यदि आपको सभी पंक्तियों को एक सरणी में एकत्र करने की आवश्यकता है, तो आप स्वयं ऐसा कर सकते हैं।

मुझे नहीं लगता कि यह इष्टतम है, प्रति-कनेक्शन के बजाय यह कॉन्फ़िगर करने योग्य प्रति-अनुरोध शायद बेहतर होगा - लेकिन Request कन्स्ट्रक्टर अभी तक कोई विकल्प नहीं लेता है, इसलिए विधि हस्ताक्षर होना चाहिए बदला हुआ।

'अनुरोध पूर्ण' घटना का कोई कारण?

मुझे यकीन नहीं है - थकाऊ पर काम करना शुरू करने से पहले इसे जोड़ा गया था।

RowCollectionOnRequestCompletion समस्या को ट्रैक करने के लिए #459 खोला गया। मुझे यकीन है कि हम इसे जोड़ और संभाल सकते हैं
पिछड़े संगत तरीके से।

कॉलबैक गुण सेट करना आपके द्वारा पारित कॉलबैक को अधिलेखित कर देगा
अनुरोध निर्माता के लिए। इसके बजाय, आपको कॉलबैक को कॉल करना चाहिए
कॉलबैक के अंदर async अनुरोध निर्माता को दिया गया। इस तरह आप
त्रुटियों को सही ढंग से async पर अग्रेषित भी कर सकता है।

@arthurschreiber आप सही कह रहे हैं। परिणामों/त्रुटियों को ओवरराइड न करने का यह सही तरीका है। जादू की तरह काम करता है :-)

Event: 'requestCompleted' . पर दस्तावेज़ीकरण में सुधार के लिए #464 बनाया गया

Google से यहां आने वाले लोगों के लिए (जैसे मैंने किया): थकाऊ-कनेक्शन-पूल इस समस्या से निपटने का एक शानदार तरीका प्रदान करता है। समवर्ती मुद्दों को रोकने के लिए pool.acquire((err, connection) => ...) और connection.release() का उपयोग करना एक आसान तरीका है। यदि आप एकाधिक कनेक्शन नहीं चाहते हैं, तो प्रश्नों को प्रभावी ढंग से क्रमबद्ध करने के लिए पूल को {min: 1, max: 1} के साथ कॉन्फ़िगर करें।

कृपया कोई भी सुझाव दें, विंडोज़ प्रमाणीकरण मोड nodejs2Sql कनेक्टिविटी के लिए काम नहीं कर रहा है।

@wafaabbass tedious अभी तक विंडोज़ एकीकृत प्रमाणीकरण का समर्थन नहीं करता है। हम इस पर काम कर रहे हैं, आप इसे #415 में ट्रैक कर सकते हैं।

अरे, सब लोग, मुझे एक ही समस्या है।

डिबग:

अनुरोध केवल LoggedIn स्थिति में किया जा सकता है, SentClientRequest स्थिति में नहीं
(नोड: 5180) UnhandledPromiseRejectionWarning: अनचाहे वादा अस्वीकृति (अस्वीकृति आईडी: 1): RequestError: अनुरोध केवल LoggedIn स्थिति में किए जा सकते हैं, SentClientRequest स्थिति नहीं
(नोड: 5180) [डीईपी0018] बहिष्करण चेतावनी: बिना क्रिया के वादे को अस्वीकार कर दिया जाता है। भविष्य में, वादा अस्वीकरण जो संभाला नहीं जाता है, गैर-शून्य निकास कोड के साथ Node.js प्रक्रिया को समाप्त कर देगा।

क्या यह अभी तक हल हो गया है? यह मेरा कोड है।

function createAsPromiseWithTransaction(callback, data, connection) {

  const transactionReady = (err) => {
    if (err) {
      return callback(err)
    }
    return callback(null)
  }

  const transactionFailed = (originalErr) =>
    (err) => {
      if (err) {
        return callback(err)
      }
      return callback(originalErr)
    }

  const willIGetArea = new Promise(
    (resolve, reject) => {
      const create = function(data, connection) {
        let areaIdInserted = null
        const request = new Request(CONSTANTS.SPNames.Area,
          (err, rowCount, rows) => err ? reject(err) : resolve(areaIdInserted))

        request.addParameter('IUser', TYPES.UniqueIdentifier, data.iUser)
        request.addParameter('ParentArea', TYPES.Int, data.parentArea)
        request.addParameter('Name', TYPES.VarChar, data.nameArea)
        request.addParameter('ShortName', TYPES.VarChar, data.shortNameArea)
        request.addParameter('Description', TYPES.VarChar, data.descriptionArea)
        request.addParameter('Gender', TYPES.Bit, data.gender)
        request.addParameter('Colour', TYPES.VarChar, data.colour)
        request.addParameter('X', TYPES.Int, data.x)
        request.addParameter('Y', TYPES.Int, data.y)
        request.addParameter('Active', TYPES.Int, data.active)

        request.on('row', function(columns) {
          areaIdInserted = columns[1].value
        });

        connection.callProcedure(request)
      }

      const transactionStarted = function(err) {
        if (err) return callback(err)
        create(data, connection)
      }

      connection.beginTransaction(transactionStarted)
    })

  const willIGetSymptom = function(areaId) {

    return new Promise(function(resolve, reject) {

      const create = function(data, connection, areaId) {
        let symptomIdInserted = null
        const request = new Request(CONSTANTS.SPNames.Symptom,
          (err, rowCount, rows) => err ? reject(err) : resolve(symptomIdInserted))

        request.addParameter('IUser', TYPES.UniqueIdentifier, data.iUser)
        request.addParameter('AreaId', TYPES.BigInt, areaId)
        request.addParameter('Code', TYPES.VarChar, data.code)
        request.addParameter('Name', TYPES.VarChar, data.nameSymptom)
        request.addParameter('ShortName', TYPES.VarChar, data.shortNameSymptom)
        request.addParameter('Description', TYPES.VarChar, data.descriptionSymptom)
        request.addParameter('Gender', TYPES.Bit, data.gender)
        request.addParameter('Active', TYPES.Bit, data.active)

        request.on('row', function(columns) {
          symptomIdInserted = columns[1].value
        });


        connection.callProcedure(request)
      }

      create(data, connection, areaId)

    })
  }

  const willIGetModifier = new Promise(function(resolve, reject) {

    const request = new Request(
      CONSTANTS.SPNames.Modifier,
      function(err, rowCount, rows) {
        if (err) {
          reject(err)
        } else {
          resolve(rowCount,rows)
        }
      })

    request.addParameter('IUser', TYPES.UniqueIdentifier, data.iUser)
    request.addParameter('Name', TYPES.VarChar, data.nameModifier)
    request.addParameter('Order', TYPES.SmallInt, data.order)
    request.addParameter('Active', TYPES.Bit, data.active)

    connection.callProcedure(request)

  })

  const runPromise = () =>
    willIGetArea
    .then( (areaId) =>
      willIGetSymptom(areaId)
      .then( (symptomId) =>
        willIGetModifier
        .then((rowCount,rows) => connection.commitTransaction(transactionReady))
        .catch((err) => connection.rollbackTransaction(transactionFailed(err)))
      )
      .catch((err) => connection.rollbackTransaction(transactionFailed(err)))
    )it 
    .catch((err) => connection.rollbackTransaction(transactionFailed(err)))

  runPromise()

}

अगर मैं willIGetArea और willIGetSymptom को कॉल करता हूं, तो यह सब काम करता है, लेकिन अगर मैं इसे willGetModifier से कॉल करता हूं, तो मुझे भी यही समस्या है। बहुत - बहुत धन्यवाद।

यदि किसी को यह मददगार लगता है, क्योंकि Google इस त्रुटि-संदेश के लिए पहले इस पृष्ठ को लौटाता है।
इसने कनेक्शन के लिए एक वादा-आधारित आवरण बनाने के लिए मेरी एकल-कनेक्शन-आधारित सेवा के लिए काम किया। सुनिश्चित नहीं है कि यह सामान्य रूप से एक अच्छा समाधान है, क्योंकि मैं एक अनुभवी जेएस-डेवलपर नहीं हूं:

class PromisedConnection {
    constructor(config) {
        // this.connection always points to a promise resolving after the last assigned request
        // initial setting is either resolved once a new connection is established or rejected if an error occurs
        this.connection = new Promise((resolve, reject) => {
            const dbConnection = new Connection(config);
            dbConnection.on("connect", function (err) {
                if (err) {
                    reject(err);
                }
                else {
                    resolve(dbConnection);
                }
            });
        });
    }

    execute(request) {
        const nextConnection = new Promise((resolve, reject) => {
            // after scheduling new request this.connection should be reassigned to be the last in promise queue
            this.connection
                .catch( (reason) => {
                    reject(reason);
                } )
                .then( (dbConnection) => { // a new request can be executed only within the connection is free again (resolved after the last request)
                    request.on("requestCompleted", () => { // add an additional event listener in order to release connection after the request is done
                        resolve(dbConnection);
                    });
                    dbConnection.execSql(request);
                });
        } );
        this.connection = nextConnection;
    }
}

और क्वेरी को स्वयं इस प्रकार निष्पादित किया जा सकता है:

const dbConnection = new PromisedConnection(config);

function getObjList(query, parameters = []) {
    return new Promise((resolve, reject) => {
        const objList = [];
        let request = new Request(
            query,
            function (err, rowCount, rows) {
                if (err) {
                    reject(err);
                } else if (rowCount < 1) {
                    reject(new Error("0 rows returned from DB"));
                }
            }
        );
        for (const {name, type, value} of parameters) {
            request.addParameter(name, type, value);
        };

        request.on("row", (columns) => {
            objList.push(Obj.fromColumns(columns)); // here I just make a specific object from each row
        });

        request.on("requestCompleted", () => {
            resolve(objList);
        });

        dbConnection.execute(request);
    });
}

तो getObjList अब कनेक्शन स्थिति की जांच किए बिना किसी भी समय निष्पादित किया जा सकता है।

यहां चिंता अच्छी है। मेरे कोड में मैं एक कनेक्शन अनुरोध, एक एसक्यूएल अनुरोध, और फिर एक सम्मिलित अनुरोध करता हूं। जब तक मैं एसक्यूएल अनुरोध के बाद requestCompleted की प्रतीक्षा करने के बाद भी एसक्यूएल और सम्मिलित अनुरोध के बीच एक और कनेक्शन अनुरोध नहीं करता, तब तक यह सम्मिलित अनुरोध पर त्रुटियां करता है।

इस त्रुटि का एक सामान्य कारण यह है कि _एक समय में कनेक्शन पर केवल एक क्वेरी निष्पादित की जा सकती है। आपको अनुरोध कॉलबैक निष्पादित होने तक प्रतीक्षा करने की आवश्यकता है, या तो एक त्रुटि के साथ या कोई अन्य अनुरोध करने से पहले परिणाम के साथ। कृपया यहां अक्सर पूछे जाने वाले प्रश्न पृष्ठ पर जाएं

चूंकि इस मंच पर बहुत सारे विभिन्न मुद्दे प्रतीत होते हैं। त्रुटि Requests can only be made in the LoggedIn state, not the SentClientRequest state विभिन्न कारणों से हो सकती है। यदि आप इस त्रुटि का अनुभव करते हैं और आपको अक्सर पूछे जाने वाले प्रश्न पृष्ठ मददगार नहीं लगे, तो कृपया निम्नलिखित जानकारी के साथ अपनी समस्या स्वयं उठाएं ताकि हम आपकी समस्या का अधिक सटीकता के साथ समाधान कर सकें:

• थकाऊ संस्करण
• कनेक्शन के लिए आपका विन्यास
• एक प्रतिलिपि प्रस्तुत करने योग्य स्क्रिप्ट

धन्यवाद! मैं

इसे हल करने में सक्षम था, समस्या मेरी तरफ थी, यह नहीं पता था कि आपको प्रत्येक अनुरोध के लिए एक अलग कनेक्शन की आवश्यकता है

@mgarf आपका समाधान क्या था? मुझे यह भी नहीं पता था कि मुझे प्रत्येक अनुरोध के लिए एक अलग कनेक्शन की आवश्यकता है। मैं इस चर्चा में अन्य लोगों की तरह समवर्ती मुद्दों का सामना कर रहा हूं।

@mikebutak आपको प्रत्येक अनुरोध के लिए एक अलग कनेक्शन की आवश्यकता नहीं है। आपको केवल एक कनेक्शन की आवश्यकता है जो एक अनुरोध _at a time_ को संभालता है। एक कनेक्शन पर कई अनुरोधों को संभालने के लिए, आपको पिछले एक के कॉलबैक में एक नया अनुरोध निष्पादित करने की आवश्यकता है, इसके समाप्त होने के बाद। उदाहरण के लिए,

function executeStatement() {
  request = new Request("select 42, 'hello world'", function(err, rowCount) {
    if (err) {
      console.log(err);
    } else {
      console.log(rowCount + ' rows');
    }

    connection.execSql(new Request("select 42, 'hello world'", function(err, rowCount) {
      if (err) {
        console.log(err);
      } else {
        console.log(rowCount + ' rows');
      }
      connection.close();
    }))
  });
  connection.execSql(request);

मैं इस मुद्दे के लिए कॉलबैक का उपयोग करके एक पूर्ण समाधान पोस्ट कर रहा हूं। मुझे भी यही समस्या थी और जब मैं Google को देख रहा था तो मैं यहाँ समाप्त हो गया। मैंने इस कोड का परीक्षण एक स्क्रिप्ट के साथ किया है जिसमें हर सेकेंड में 1 http कॉल निष्पादित होता है और बिना किसी समस्या के आधा सेकेंड भी होता है।

const {Connection, Request} = require("tedious");

const executeSQL = (sql, callback) => {
  let connection = new Connection({
    "authentication": {
      "options": {
        "userName": "USERNAME",
        "password": "PASSWORD"
      },
      "type": "default"
    },
    "server": "SERVER",
    "options": {
      "validateBulkLoadParameters": false,
      "rowCollectionOnRequestCompletion": true,
      "database": "DATABASE",
      "encrypt": true
    }
  });

  connection.connect((err) => {
    if (err)
      return callback(err, null);

    const request = new Request(sql, (err, rowCount, rows) => {
      connection.close();

      if (err)
        return callback(err, null);

      callback(null, {rowCount, rows});
    });

    connection.execSql(request);
  });
};

executeSQL("SELECT * FROM users", (err, data) => {
  if (err)
    console.error(err);

  console.log(data.rowCount);
});

//or

executeSQL("SELECT * FROM users", (err, {rowCount, rows}) => {
  if (err)
    console.error(err);

  console.log(rowCount);
});

मैं इस मुद्दे के लिए कॉलबैक का उपयोग करके एक पूर्ण समाधान पोस्ट कर रहा हूं। मुझे भी यही समस्या थी और जब मैं Google को देख रहा था तो मैं यहाँ समाप्त हो गया। मैंने इस कोड का परीक्षण एक स्क्रिप्ट के साथ किया है जिसमें हर सेकेंड में 1 http कॉल निष्पादित होता है और बिना किसी समस्या के आधा सेकेंड भी होता है।

const {Connection, Request} = require("tedious");

const executeSQL = (sql, callback) => {
  let connection = new Connection({
    "authentication": {
      "options": {
        "userName": "USERNAME",
        "password": "PASSWORD"
      },
      "type": "default"
    },
    "server": "SERVER",
    "options": {
      "validateBulkLoadParameters": false,
      "rowCollectionOnRequestCompletion": true,
      "database": "DATABASE",
      "encrypt": true
    }
  });

  connection.connect((err) => {
    if (err)
      return callback(err, null);

    const request = new Request(sql, (err, rowCount, rows) => {
      connection.close();

      if (err)
        return callback(err, null);

      callback(null, {rowCount, rows});
    });

    connection.execSql(request);
  });
};

executeSQL("SELECT * FROM users", (err, data) => {
  if (err)
    console.error(err);

  console.log(data.rowCount);
});

//or

executeSQL("SELECT * FROM users", (err, {rowCount, rows}) => {
  if (err)
    console.error(err);

  console.log(rowCount);
});

यह समाधान काम करता है लेकिन क्या यह एक वैध कार्यान्वयन है? यह कितना व्यवहार्य है, यह देखते हुए कि सैकड़ों हजारों प्रविष्टियां/चयन हो सकते हैं और उनमें से प्रत्येक के लिए कनेक्शन बना सकते हैं? समाधान बीटीडब्ल्यू के लिए धन्यवाद, मैं सिर्फ यह समझने की कोशिश कर रहा हूं कि यह एक व्यवहार्य समाधान है या नहीं। विशेष रूप से यदि हम Azure फ़ंक्शन का उपयोग कर रहे हैं?