netsuite
बड़ी संख्या में परिणामों के साथ खोज करता है

परिचय

Search.ResultSet.each विधि का उपयोग करना

यह सबसे छोटा, सबसे आसान और सबसे अधिक इस्तेमाल किया जाने वाला तरीका है। दुर्भाग्य से, इसकी एक प्रमुख सीमा है - 4000 से अधिक परिणामों (पंक्तियों) वाली खोजों पर इसका उपयोग नहीं किया जा सकता है।

    // Assume that 'N/search' module is included as 'search'
    
    var s = search.create({
        type : search.Type.TRANSACTION,
        columns : ['entity','amount'],
        filters : [  ['mainline', 'is', 'T'],
              'and', ['type', 'is', 'CustInvc'],
              'and', ['status', 'is', 'open']
            ]
    });

    var resultSet = s.run();
    
    // you can use "each" method on searches with up to 4000 results    
    resultSet.each( function(result) {
        
        // you have the result row. use it like this....
        var transId = result.id;
        var entityId = result.getValue('entity'); 
        var entityName = result.getText('entity');
        var amount = result.getValue('amount');
        
        // don't forget to return true, in order to continue the loop
        return true;  

    });

ResultSet.getRange पद्धति का उपयोग करना

बड़ी संख्या में परिणामों को संभालने के लिए getRange का उपयोग करने के लिए, हमें निम्नलिखित पर विचार करना होगा:

1. getRange के 2 पैरामीटर हैं: प्रारंभ और समाप्ति । हमेशा सकारात्मक, हमेशा (शुरू <अंत)
2. प्रारंभ , वापसी के पहले परिणाम का समावेशी सूचकांक है
3. अंत अंतिम परिणाम के अनन्य सूचकांक वापस जाने के लिए है
4. यदि अनुरोध से कम परिणाम उपलब्ध हैं, तो सरणी में अंत से कम प्रविष्टियाँ होंगी। उदाहरण के लिए, यदि केवल 25 खोज परिणाम हैं, तो getRange (20, 30) 5 खोज की एक सरणी लौटाएगा। परिणाम ऑब्जेक्ट्स।
5. यद्यपि उपरोक्त सहायता वाक्य इसे सीधे नहीं कहते हैं, प्रारंभ और अंत दोनों उपलब्ध परिणामों की सीमा के बाहर हो सकते हैं। उसी उदाहरण में - यदि केवल 25 खोज परिणाम हैं, तो getRange (100, 200) एक खाली सरणी लौटा देगा []
6. एक बार में अधिकतम 1000 पंक्तियाँ। (अंत - प्रारंभ) <= 1000

    // Assume that 'N/search' module is included as 'search'
    
    // this search will return a lot of results (not having any filters) 
    var s = search.create({
        type: search.Type.TRANSACTION,
        columns : ['entity','amount'],
        filters: [] 
    });
    
    var resultSet = s.run();

    // now take the first portion of data.
    var currentRange = resultSet.getRange({
            start : 0,
            end : 1000
    });
    
    var i = 0;  // iterator for all search results
    var j = 0;  // iterator for current result range 0..999

    while ( j < currentRange.length ) {
        
        // take the result row
        var result = currentRange[j];
        // and use it like this....
        var transId = result.id;
        var entityId = result.getValue('entity'); 
        var entityName = result.getText('entity');
        var amount = result.getValue('amount');
        
        // finally:
        i++; j++;
        if( j==1000 ) {   // check if it reaches 1000
            j=0;          // reset j an reload the next portion
            currentRange = resultSet.getRange({
                start : i,
                end : i+1000
            });
        }
    }

शासन की गणना करें। हमारे पास 1 + गिनती / 1000 getRange कॉल है, जिसमें से प्रत्येक में 10 यूनिट हैं, इसलिए:

जी = (1 + गिनती / 1000) * 10

उदाहरण: 9500 पंक्तियों में 100 इकाइयाँ लगेंगी

Search.PagedData.fetch विधि का उपयोग करना

PagedData एक ऑब्जेक्ट है, जो Search.runPaged (विकल्प) विधि द्वारा लौटाया गया है। यह ठीक वैसे ही काम करता है जैसे UI खोज करता है। PagedData ऑब्जेक्ट में 2 महत्वपूर्ण गुण हैं, जो कि आप नेटस्केप यूआई में खोज परिणाम पृष्ठ में परिणाम शीर्ष लेख के दाईं ओर देख सकते हैं:

• गणना (परिणामों की कुल संख्या)
• pageRanges (पृष्ठ की सूची, UI में कॉम्बो-बॉक्स चयनकर्ता के रूप में उपलब्ध)
  

Options.pageSize पैरामीटर फिर से 1000 परिणाम पंक्तियों तक सीमित है।
PagedData.fetch विधि का उपयोग उस परिणाम भाग को लाने के लिए किया जाता है जिसे आप चाहते हैं (पेजइंडेक्स पैरामीटर द्वारा अनुक्रमित)। थोड़ा और अधिक कोड के साथ, आपको 4000 पंक्तियों की सीमा के बिना Search.ResultSet.each के समान सुविधाजनक कॉलबैक फ़ंक्शन प्राप्त होता है।

    // Assume that 'N/search' module is included as 'search'

    // this search will return a lot of results (not having any filters)  
    var s = search.create({
        type: search.Type.TRANSACTION,
        columns : ['entity','amount'],
        filters : [] 
    });
    
    var pagedData = s.runPaged({pa​g​e​S​i​z​e : 1000});
    
    // iterate the pages
    for( var i=0; i < pagedData.pageRanges.length; i++ ) {

        // fetch the current page data
        var currentPage = pagedData.fetch(i);

        // and forEach() thru all results
        currentPage.data.forEach( function(result) {

            // you have the result row. use it like this....
            var transId = result.id;
            var entityId = result.getValue('entity'); 
            var entityName = result.getText('entity');
            var amount = result.getValue('amount');

        });

    }

शासन की गणना करें। हमारे पास रनपेड के लिए 5 इकाइयाँ हैं (), और 1 + गिनती / 1000 pagedData.fetch कॉल के लिए 5 इकाइयाँ लेते हैं, इसलिए:

जी = 5 + छत (गिनती / 1000) * 5

उदाहरण: 9500 पंक्तियों में 55 इकाइयाँ लगेंगी। GetRange शासन इकाइयों का लगभग आधा हिस्सा।

समर्पित मानचित्र / स्क्रिप्ट को कम करना

वास्तव में विशाल खोज परिणामों के लिए, आप समर्पित मानचित्र / स्क्रिप्ट को कम कर सकते हैं। यह बहुत अधिक असुविधाजनक है, लेकिन कभी-कभी अपरिहार्य है। और कभी-कभी बहुत काम आ सकता है।
यहाँ ट्रिक यह है कि गेट इनपुट डेटा स्टेज में, आप NS इंजन को वास्तविक डेटा (यानी स्क्रिप्ट परिणाम) नहीं, बल्कि खोज की परिभाषा प्रदान कर सकते हैं। एनएस शासन इकाइयों की गिनती के बिना आपके लिए खोज निष्पादित करेगा। फिर प्रत्येक एकल परिणाम पंक्ति को मानचित्र चरण में पारित किया जाएगा।
बेशक, एक सीमा है: एक नक्शा / कम स्क्रिप्ट के लिए डेटा का कुल निरंतर आकार 50 एमबी से अधिक की अनुमति नहीं है। एक खोज परिणाम में, प्रत्येक कुंजी और प्रत्येक मूल्य का क्रमबद्ध आकार कुल आकार की ओर गिना जाता है। "सीरियलाइज्ड" का अर्थ है, खोज परिणाम पंक्ति स्ट्रिंग के साथ JSON.stringify में परिवर्तित हो जाती है। इस प्रकार, मान आकार एक परिणाम सेट में खोज परिणाम कॉलम की संख्या के लिए आनुपातिक है। यदि आप STORAGE_SIZE_EXCEEDED त्रुटि से परेशान हैं, तो कॉलम को कम करने, फॉर्मूलों के साथ संयोजन करने, परिणाम को समूहीकृत करने या यहां तक कि खोज को कई उप-खोजों में विभाजित करने पर विचार करें, जिसे मैप या कम चरणों में निष्पादित किया जा सकता है।

    /**
     * @NApiVersion 2.0
     * @NScriptType MapReduceScript
     */
    define(['N/search'], function(search) {

    function getInputData()
    {
        return search.create({
            type: search.Type.TRANSACTION,
            columns : ['entity','amount'],
            filters : [] 
        });
    }

    function map(context)
    {
        var searchResult = JSON.parse(context.value);
        // you have the result row. use it like this....
        var transId = searchResult.id;
        var entityId = searchResult.values.entity.value;
        var entityName = searchResult.values.entity.text;
        var amount = searchResult.values.amount.value;
        
        // if you want to pass some part of the search result to the next stage
        // write it to context:
        context.write(entityId, transId);
    }

    function reduce(context)
    {
       // your code here ...
    }

    function summarize(summary)
    {
        // your code here ...
    }

    return {
        getInputData: getInputData,
        map: map,
        reduce: reduce,
        summarize: summarize
    };
});

बेशक उदाहरण यहां सरल है, त्रुटि से निपटने के बिना और दूसरों के साथ तुलना करने के लिए बस दिया जाता है। NS सहायता केंद्र में मैप / कम स्क्रिप्ट प्रकार के उदाहरणों पर अधिक उदाहरण उपलब्ध हैं