Ticket #4761: dojox.data.QueryReadStore_20071026.patch

data/tests/stores/QueryReadStore.js

@@ -239 +239 @@
                         //      description:
                         var store = dojox.data.tests.stores.QueryReadStore.getStore();
 
-                        var lastRequestTimestamp = null;
+                        var lastRequestHash = null;
                         var firstItems = [];
                         var d = new doh.Deferred();
                         function onComplete(items, request) {
                                 t.assertEqual(5, items.length);
-                                lastRequestTimestamp = store.lastRequestTimestamp;
+                                lastRequestHash = store.lastRequestHash;
                                 firstItems = items;
                                 
                                 // Do the next request AFTER the previous one, so we are sure its sequential.
                                 // We need to be sure so we can compare to the data from the first request.
                                 function onComplete1(items, request) {
                                         t.assertEqual(5, items.length);
-                                        t.assertEqual(lastRequestTimestamp, store.lastRequestTimestamp);
+                                        t.assertEqual(lastRequestHash, store.lastRequestHash);
                                         t.assertEqual(firstItems[1], items[0]);
                                         d.callback(true);
                                 }
@@ -268 +268 @@
                         return d; //Object
                 },
                 
-                function testReadApi_fetch_serverQuery(t) {
-                        // TODO verify serverQuery vs. query 
-                        t.assertTrue(true);
+                function testReadApi_fetch_server_paging(t) {
+                        // Verify that the paging on the server side does work.
+                        // This is the test for http://trac.dojotoolkit.org/ticket/4761
+                        //
+                        // How? We request 10 items from the server, start=0, count=10.
+                        // The second request requests 5 items: start=5, count=5 and those
+                        // 5 items should have the same values as the last 5 of the first
+                        // request.
+                        // This tests if the server side paging does work.
+                        var store = dojox.data.tests.stores.QueryReadStore.getStore();
+
+                        var lastRequestHash = null;
+                        var d = new doh.Deferred();
+                        function onComplete(items, request) {
+                                t.assertEqual(10, items.length);
+                                lastRequestHash = store.lastRequestHash;
+                                firstItems = items;
+                                
+                                // Do the next request AFTER the previous one, so we are sure its sequential.
+                                // We need to be sure so we can compare to the data from the first request.
+                                function onComplete1(items, request) {
+                                        t.assertEqual(5, items.length);
+                                        // Compare the timestamp of the last request, they must be different,
+                                        // since another server request was issued.
+                                        t.assertTrue(lastRequestHash!=store.lastRequestHash);
+                                        t.assertEqual(store.getValue(firstItems[5], "name"), store.getValue(items[0], "name"));
+                                        t.assertEqual(store.getValue(firstItems[6], "name"), store.getValue(items[1], "name"));
+                                        t.assertEqual(store.getValue(firstItems[7], "name"), store.getValue(items[2], "name"));
+                                        t.assertEqual(store.getValue(firstItems[8], "name"), store.getValue(items[3], "name"));
+                                        t.assertEqual(store.getValue(firstItems[9], "name"), store.getValue(items[4], "name"));
+                                        d.callback(true);
+                                }
+                                // Init a new store, or it will use the old data, since the query has not changed.
+                                store.doClientPaging = false;
+                                store.fetch({start:5, count:5, onComplete: onComplete1, onError: onError});
+                        }
+                        function onError(error, request) {
+                                d.errback(error);
+                        }
+                        store.fetch({query:{}, start:0, count:10, onComplete: onComplete, onError: onError});
+                        return d; //Object
                 },
                 
                 function testReadApi_getFeatures(t) {

data/tests/module.js

@@ -7 +7 @@
         dojo.requireIf(dojo.isBrowser, "dojox.data.tests.stores.XmlStore");
         dojo.requireIf(dojo.isBrowser, "dojox.data.tests.stores.FlickrStore");
         dojo.requireIf(dojo.isBrowser, "dojox.data.tests.stores.FlickrRestStore");
+        dojo.requireIf(dojo.isBrowser, "dojox.data.tests.stores.QueryReadStore");
         dojo.requireIf(dojo.isBrowser, "dojox.data.tests.dom");
 }catch(e){
         doh.debug(e);

data/tests/QueryReadStore.html

@@ -15 +15 @@
         <script type="text/javascript" src="../../../dojox/data/QueryReadStore.js"></script>
         <script type="text/javascript">
                 dojo.require("dijit.form.ComboBox");
+                dojo.require("dijit.form.FilteringSelect");
                 dojo.require("dojox.data.QueryReadStore");
 
                 dojo.provide("ComboBoxReadStore");
@@ -62 +63 @@
                         }
                 });
 
-                var testStore = new ComboBoxReadStore({url:'stores/QueryReadStore.php'});;
+                var testStore = new dojox.data.QueryReadStore({url:'stores/QueryReadStore.php'});;
                 function doSearch() {
                         var queryOptions = {};
                         if (dojo.byId("ignoreCaseEnabled").checked) {
@@ -73 +74 @@
                         }
                     
                         var query = {};
-                        query.name = dojo.byId("searchText").value;
+                        query.q = dojo.byId("searchText").value;
                         var request = {query:query, queryOptions:queryOptions};
                         request.start = dojo.query("#fetchForm")[0].pagingStart.value;
                         request.count = dojo.query("#fetchForm")[0].pagingCount.value;
@@ -84 +85 @@
                                 if (radioButtons[i].checked) {
                                         requestMethod = radioButtons[i].value;
                                 }
-                        }       
-                
+                        }
+                        
                         testStore.requestMethod = requestMethod;
                         testStore.doClientPaging = dojo.query("#fetchForm")[0].doClientPaging.checked;
-                        function onComplete(items) {
+                        
+                        if (!testStore.doClientPaging) {
+                                // We have to fill the serverQuery, since we also want to send the
+                                // paging data "start" and "count" along with what is in query.
+                                request.serverQuery = {q:request.query.name, start:request.start, count:request.count};
+                        }
+                        
+                        request.onComplete = function (items) {
                                 var s = "number of items: "+items.length+"<br /><br />";
                                 for (var i=0; i<items.length; i++) {
                                         s += i+": name: '"+testStore.getValue(items[i], "name")+"'<br />";
@@ -96 +104 @@
                                 //s += "<pre>"+dojo.toJson(items)+"</pre>";
                                 dojo.byId("fetchOutput").innerHTML = s;
                         };
-                        request.onComplete = onComplete;
+
                         testStore.fetch(request);
                 }
         </script>
 </head>
 <body class="tundra" style="margin:20px;">
         <div dojoType="ComboBoxReadStore" jsId="store" url="stores/QueryReadStore.php" requestMethod="get"></div>
-        <input dojoType="dijit.form.ComboBox" store="store" pageSize="5" />
+        This is a ComboBox: <input id="cb" dojoType="dijit.form.ComboBox" store="store" pageSize="5" />
         <br /><br /><hr />
 
+        This is a FilteringSelect: <input id="fs" dojoType="dijit.form.FilteringSelect" store="store" pageSize="5" />
+        <br />
+        <form id="fetchForm">
+                <input id="selectById" value="0" size="3" />
+                <input type="button" value="set by id" onclick="dijit.byId('fs').setValue(dojo.byId('selectById').value)" />
+        </form>
+        
+        <br /><br /><hr />
+
         This ComboBox uses a customized QueryReadStore, it prepares the query-string for the URL that
         way that the paging parameters "start" and "count" are also send.<br />
         <div dojoType="ServerPagingReadStore" jsId="serverPagingStore" url="stores/QueryReadStore.php" requestMethod="get" doClientPaging="false"></div>
@@ -119 +136 @@
 &lt;div dojoType="ServerPagingReadStore" jsId="serverPagingStore" url="stores/QueryReadStore.php" requestMethod="get" doClientPaging="false"&gt;&lt;/div&gt;
 &lt;input dojoType="dijit.form.ComboBox" store="serverPagingStore" pageSize="10" /&gt;
         </pre>
-        <pre>dojo.require("dojox.data.QueryReadStore");
-
-        dojo.provide("ServerPagingReadStore");
-        dojo.declare("ServerPagingReadStore", dojox.data.QueryReadStore, {
-                fetch:function(request) {
-                        request.query = {q:request.query.name, start:request.start, count:request.count};
-                        return this.inherited("fetch", arguments);
-                }
-        });</pre>
+        <pre>
+                dojo.require("dojox.data.QueryReadStore");
+                dojo.provide("ServerPagingReadStore");
+                dojo.declare("ServerPagingReadStore", dojox.data.QueryReadStore, {
+                        fetch:function(request) {
+                                request.serverQuery = {q:request.query.name, start:request.start, count:request.count};
+                                return this.inherited("fetch", arguments);
+                        }
+                });
+        </pre>
 </div>
         <br /><br />
         

data/QueryReadStore.js

@@ -61 +61 @@
         _lastServerQuery:null,
         
         
-        // Store a timestamp of the last server request. Actually I introduced this
+        // Store a hash of the last server request. Actually I introduced this
         // for testing, so I can check if no unnecessary requests were issued for
-        // client-side-paging. But I am sure people will find uses for it.
-        lastRequestTimestamp:null,
+        // client-side-paging.
+        lastRequestHash:null,
         
         // If this is false, every request is sent to the server.
         // If it's true a second request with the same query will not issue another
         // request, but use the already returned data. This assumes that the server
         // does not do the paging.
         doClientPaging:true,
+
+        // Items by identify for Identify API
+        _itemsByIdentity:null,
         
+        // Identifier used
+        _identifier:null,
+
+        _features: {'dojo.data.api.Read':true, 'dojo.data.api.Identity':true},
+        
         constructor: function(/* Object */ params){
                 this.url = params.url;
                 this.requestMethod = typeof params.requestMethod=="undefined" ? this.requestMethod : params.requestMethod;
@@ -79 +87 @@
                 //this.useCache = typeof params.useCache=="undefined" ? this.useCache : params.useCache;
         },
         
-        getValue: function(     /* item */ item, /* attribute-name-string */ attribute, /* value? */ defaultValue){
+        getValue: function(/* item */ item, /* attribute-name-string */ attribute, /* value? */ defaultValue){
                 this._assertIsItem(item);
                 if(!this.hasAttribute(item, attribute)){
                         // read api says: return defaultValue "only if *item* does not have a value for *attribute*." 
@@ -162 +170 @@
                 // Actually we have nothing to do here, or at least I dont know what to do here ...
         },
 
+        fetch:function(/* Object? */ request){
+                //      summary:
+                //              See dojo.data.util.simpleFetch.fetch() this is just a copy and I adjusted
+                //              only the paging, since it happens on the server if doClientPaging is
+                //              false, thx to http://trac.dojotoolkit.org/ticket/4761 reporting this.
+                //              Would be nice to be able to use simpleFetch() to reduce copied code,
+                //              but i dont know how yet. Ideas please!
+                request = request || {};
+                if(!request.store){
+                        request.store = this;
+                }
+                var self = this;
+        
+                var _errorHandler = function(errorData, requestObject){
+                        if(requestObject.onError){
+                                var scope = requestObject.scope || dojo.global;
+                                requestObject.onError.call(scope, errorData, requestObject);
+                        }
+                };
+        
+                var _fetchHandler = function(items, requestObject){
+                        var oldAbortFunction = requestObject.abort || null;
+                        var aborted = false;
+                        
+                        var startIndex = requestObject.start?requestObject.start:0;
+                        if (self.doClientPaging==false) {
+                                // For client paging we dont need no slicing of the result.
+                                startIndex = 0;
+                        }
+                        var endIndex   = requestObject.count?(startIndex + requestObject.count):items.length;
+        
+                        requestObject.abort = function(){
+                                aborted = true;
+                                if(oldAbortFunction){
+                                        oldAbortFunction.call(requestObject);
+                                }
+                        };
+        
+                        var scope = requestObject.scope || dojo.global;
+                        if(!requestObject.store){
+                                requestObject.store = self;
+                        }
+                        if(requestObject.onBegin){
+                                requestObject.onBegin.call(scope, items.length, requestObject);
+                        }
+                        if(requestObject.sort){
+                                items.sort(dojo.data.util.sorter.createSortFunction(requestObject.sort, self));
+                        }
+                        if(requestObject.onItem){
+                                for(var i = startIndex; (i < items.length) && (i < endIndex); ++i){
+                                        var item = items[i];
+                                        if(!aborted){
+                                                requestObject.onItem.call(scope, item, requestObject);
+                                        }
+                                }
+                        }
+                        if(requestObject.onComplete && !aborted){
+                                var subset = null;
+                                if (!requestObject.onItem) {
+                                        subset = items.slice(startIndex, endIndex);
+                                }
+                                requestObject.onComplete.call(scope, subset, requestObject);   
+                        }
+                };
+                this._fetchItems(request, _fetchHandler, _errorHandler);
+                return request; // Object
+        },
+
         getFeatures: function(){
                 return {
                         'dojo.data.api.Read': true
@@ -211 +287 @@
                 //
 
                 var serverQuery = typeof request["serverQuery"]=="undefined" ? request.query : request.serverQuery;
+                request = request || {};
+                if(!request.store){
+                        request.store = this;
+                }
+                
+                //Need to add start and count
+                if(!request.store.doClientPaging){
+                        serverQuery = serverQuery||{};
+                        serverQuery.start = request.start?request.start:0;
+                        // Count might not be sent if not given.
+                        if (request.count) {
+                                serverQuery.count = request.count;
+                        }
+                }
                 // Compare the last query and the current query by simply json-encoding them,
                 // so we dont have to do any deep object compare ... is there some dojo.areObjectsEqual()???
                 if(this.doClientPaging && this._lastServerQuery!==null &&
@@ -220 +310 @@
                 }else{
                         var xhrFunc = this.requestMethod.toLowerCase()=="post" ? dojo.xhrPost : dojo.xhrGet;
                         var xhrHandler = xhrFunc({url:this.url, handleAs:"json-comment-optional", content:serverQuery});
-                        var self = this;
-                        xhrHandler.addCallback(function(data){
-                                self._items = [];
+                        xhrHandler.addCallback(dojo.hitch(this, function(data){
+                                this._items = [];
                                 // Store a ref to "this" in each item, so we can simply check if an item
                                 // really origins form here (idea is from ItemFileReadStore, I just don't know
                                 // how efficient the real storage use, garbage collection effort, etc. is).
                                 for(var i in data.items){
-                                        self._items.push({i:data.items[i], r:self});
+                                        this._items.push({i:data.items[i], r:this});
                                 }
-        // TODO actually we should do the same as dojo.data.ItemFileReadStore._getItemsFromLoadedData() to sanitize
-        // (does it really sanititze them) and store the data optimal. should we? for security reasons???
-                                fetchHandler(self._items, request);
-                        });
+                                
+                                var identifier = data.identifier;
+                                this._itemsByIdentity = {};
+                                if(identifier){
+                                        this._identifier = identifier;
+                                        for(i = 0; i < this._items.length; ++i){
+                                                var item = this._items[i].i;
+                                                var identity = item[identifier];
+                                                if(!this._itemsByIdentity[identity]){
+                                                        this._itemsByIdentity[identity] = item;
+                                                }else{
+                                                        throw new Error("dojo.data.QueryReadStore:  The json data as specified by: [" + this._url + "] is malformed.  Items within the list have identifier: [" + identifier + "].  Value collided: [" + identity + "]");
+                                                }
+                                        }
+                                }else{
+                                        this._identifier = Number;
+                                        for(i = 0; i < this._items.length; ++i){
+                                                this._items[i].n = i;
+                                        }
+                                }
+                                
+                                // TODO actually we should do the same as dojo.data.ItemFileReadStore._getItemsFromLoadedData() to sanitize
+                                // (does it really sanititze them) and store the data optimal. should we? for security reasons???
+                                fetchHandler(this._items, request);
+                        }));
                         xhrHandler.addErrback(function(error){
                                 errorHandler(error, request);
                         });
-                        this.lastRequestTimestamp = new Date().getTime();
+                        // Generate the hash using the time in milliseconds and a randon number.
+                        // Since Math.randon() returns something like: 0.23453463, we just remove the "0."
+                        // probably just for esthetic reasons :-).
+                        this.lastRequestHash = new Date().getTime()+"-"+String(Math.random()).substring(2);
                         this._lastServerQuery = serverQuery;
                 }
         },
@@ -260 +373 @@
                 if(typeof attribute !== "string"){ 
                         throw new dojox.data.QueryReadStore.InvalidAttributeError(this._className+": '"+attribute+"' is not a valid attribute identifier.");
                 }
+        },
+
+        fetchItemByIdentity: function(/* Object */ keywordArgs){
+                //      summary: 
+                //              See dojo.data.api.Identity.fetchItemByIdentity()
+
+                // See if we have already loaded the item with that id
+                if(this._itemsByIdentity){
+                        item = this._itemsByIdentity[keywordArgs.identity];
+                        if(item === undefined){
+                                item = null;
+                        }
+                        if(item != null){
+                                if(keywordArgs.onItem){
+                                        var scope =  keywordArgs.scope?keywordArgs.scope:dojo.global;
+                                        keywordArgs.onItem.call(scope, item);
+                                }
+                                return;
+                        }
+                }
+
+                // Otherwise we need to go remote
+                // Set up error handler
+                var _errorHandler = function(errorData, requestObject){
+                        var scope =  keywordArgs.scope?keywordArgs.scope:dojo.global;
+                        if(keywordArgs.onError){
+                                keywordArgs.onError.call(scope, error);
+                        }
+                };
+                
+                // Set up fetch handler
+                var _fetchHandler = function(items, requestObject){
+                        var scope =  keywordArgs.scope?keywordArgs.scope:dojo.global;
+                        try{
+                                // There is supposed to be only one result
+                                var item = null;
+                                if(items && items.length == 1){
+                                        item = items[0];
+                                }
+                                
+                                if(keywordArgs.onItem){
+                                        keywordArgs.onItem.call(scope, item);
+                                }
+                        }catch(error){
+                                if(keywordArgs.onError){
+                                        keywordArgs.onError.call(scope, error);
+                                }
+                        }
+                };
+                
+                // Construct query
+                var request = {serverQuery:{id:keywordArgs.identity}};
+                
+                // Dispatch query
+                this._fetchItems(request, _fetchHandler, _errorHandler);
+        },
+        
+        getIdentity: function(/* item */ item){
+                //      summary: 
+                //              See dojo.data.api.Identity.getIdentity()
+                var identifier = null;
+                if(this._identifier === Number){
+                        identifier = item.n; // Number
+                }else{
+                        identifier = item.i[this._identifier];
+                }
+                return identifier;
+        },
+        
+        getIdentityAttributes: function(/* item */ item){
+                //      summary:
+                //              See dojo.data.api.Identity.getIdentityAttributes()
+                return [this._identifier];
         }
 });
-dojo.extend(dojox.data.QueryReadStore, dojo.data.util.simpleFetch);
 
 dojo.declare("dojox.data.QueryReadStore.InvalidItemError", Error, {});
 dojo.declare("dojox.data.QueryReadStore.InvalidAttributeError", Error, {});