netsuite
Zoekopdrachten met groot aantal resultaten

Invoering

De methode Search.ResultSet.each gebruiken

Dit is de kortste, gemakkelijkste en meest gebruikte methode. Helaas heeft het een belangrijke beperking - kan niet worden gebruikt bij zoekopdrachten met meer dan 4000 resultaten (rijen).

    // 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;  

    });

De methode ResultSet.getRange gebruiken

Om getRange te kunnen gebruiken voor het verwerken van het grote aantal resultaten, moeten we het volgende in overweging nemen:

1. getRange heeft 2 parameters: begin en einde . Altijd positief, altijd (start <einde)
2. start is de inclusieve index van het eerste resultaat dat moet worden geretourneerd
3. einde is de exclusieve index van het laatst te retourneren resultaat
4. Als er minder resultaten beschikbaar zijn dan gevraagd, bevat de array minder dan eindbeginitems. Als er bijvoorbeeld slechts 25 zoekresultaten zijn, retourneert getRange (20, 30) een array van 5 search.Result-objecten.
5. Hoewel de bovenstaande Help-zin het niet rechtstreeks zegt, kunnen zowel het begin als het einde buiten het bereik van de beschikbare resultaten vallen. In hetzelfde voorbeeld - als er slechts 25 zoekresultaten zijn, retourneert getRange (100, 200) een lege array []
6. Maximaal 1000 rijen tegelijk. (einde - start) <= 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
            });
        }
    }

Laten we de governance berekenen. We hebben 1 + count / 1000 getRange-oproepen van elk 10 eenheden, dus:

G = (1 + telling / 1000) * 10

Voorbeeld: 9500 rijen duren 100 eenheden

Gebruik van de methode Search.PagedData.fetch

PagedData is een object dat wordt geretourneerd door de methode Search.runPaged (opties). Het werkt precies zoals de UI-zoekopdrachten doen. PagedData-object bevat 2 belangrijke eigenschappen, die u aan de rechterkant van de resultatenkop kunt zien op de pagina met zoekresultaten in de gebruikersinterface van Netsuite:

• count (het totale aantal resultaten)
• pageRanges (lijst met pagina's, beschikbaar in UI als keuzelijst met keuzelijst)
  

options.pageSize parameter is opnieuw beperkt tot 1000 resultaatrijen.
De methode PagedData.fetch wordt gebruikt om het gewenste resultaatgedeelte op te halen (geïndexeerd door de parameter pageIndex). Met een beetje meer code ontvangt u dezelfde handige callback-functie als Search.ResultSet.each, zonder de beperking van 4000 rijen.

    // 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');

        });

    }

Laten we de governance berekenen. We hebben 5 eenheden voor runPaged () en 1 + count / 1000 pagedData.fetch-oproepen van elk 5 eenheden, dus:

G = 5 + plafond (count / 1000) * 5

Voorbeeld: 9500 rijen duren 55 eenheden. Ongeveer de helft van de bestuurseenheden van getRange.

Met behulp van het speciale Map / Reduce-script

Voor zeer grote zoekresultaten kunt u het speciale Map / Reduce-script gebruiken. Het is veel onhandiger, maar soms onvermijdelijk. En soms kan het erg handig zijn.
De truc hier is dat u in de fase Invoergegevens ophalen de NS-engine niet de feitelijke gegevens (dwz scriptresultaat) kunt geven, maar alleen de definitie van de zoekopdracht. NS zal de zoekopdracht voor u uitvoeren zonder de bestuurseenheden te tellen. Vervolgens wordt elke afzonderlijke resultaatrij doorgegeven aan de kaartfase.
Natuurlijk is er een beperking: de totale hoeveelheid gegevens voor een script voor map / verkleinen mag niet groter zijn dan 50 MB. In een zoekresultaat worden elke sleutel en de geserialiseerde grootte van elke waarde meegeteld voor de totale grootte. "Serialized" betekent dat de rij met zoekresultaten wordt geconverteerd naar tekenreeks met JSON.stringify. De waarde is dus evenredig met het aantal kolommen met zoekresultaten in een resultatenset. Als u problemen ondervindt met de STORAGE_SIZE_EXCEEDED-fout, overweeg dan om de kolommen te verkleinen, te combineren tot formules, het resultaat te groeperen of zelfs de zoekopdracht op te splitsen in meerdere sub-zoekopdrachten, die zouden kunnen worden uitgevoerd in Kaart of Fasen verkleinen.

    /**
     * @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
    };
});

Natuurlijk is het voorbeeld hier vereenvoudigd, zonder foutafhandeling en wordt het alleen ter vergelijking gegeven. Meer voorbeelden zijn beschikbaar in Map / Reduce Script Type-voorbeelden in NS Helpcentrum