API Documentation

Choose a stylesheet:

dojox.data.QueryReadStore

dojo.require("dojox.data.QueryReadStore");

By default all the sorting is done serverside before the data is returned which is the proper place to be doing it for really large datasets.

Usage

var foo=new dojox.data.QueryReadStore(params: Object);

parameter	type	description
params	Object

Examples

Example 1

// The parameter "query" contains the data that are sent to the server.
var store = new dojox.data.QueryReadStore({url:'/search.php'});
store.fetch({query:{name:'a'}, queryOptions:{ignoreCase:false}});
 
 
// Since "serverQuery" is given, it overrules and those data are
// sent to the server.
var store = new dojox.data.QueryReadStore({url:'/search.php'});
store.fetch({serverQuery:{name:'a'}, queryOptions:{ignoreCase:false}});
 
 
<div dojoType="dojox.data.QueryReadStore"
    jsId="store2"
    url="../tests/stores/QueryReadStore.php"
    requestMethod="post"></div>
<div dojoType="dojox.grid.data.DojoData"
    jsId="model2"
    store="store2"
    sortFields="[{attribute: 'name', descending: true}]"
    rowsPerPage="30"></div>
<div dojoType="dojox.Grid" id="grid2"
    model="model2"
    structure="gridLayout"
    style="height:300px; width:800px;"></div>

FunctionsBack to top

close(request: dojo.data.api.Request)

constructor(params: Object)

containsValue(item: item, attribute: attribute-name-string, value: anything)

fetch(request: Object?): Object

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!

fetchItemByIdentity(keywordArgs: Object)

See dojo.data.api.Identity.fetchItemByIdentity()

getAttributes(item: item)

getFeatures()

getIdentity(item: item)

See dojo.data.api.Identity.getIdentity()

getIdentityAttributes(item: item)

See dojo.data.api.Identity.getIdentityAttributes()

getLabel(item: item): String | undefined

See dojo.data.api.Read.getLabel()

getLabelAttributes(item: item): Array | null

See dojo.data.api.Read.getLabelAttributes()

getValue(item: item, attribute: attribute-name-string, defaultValue: value?)

getValues(item: item, attribute: attribute-name-string)

hasAttribute(item: item, attribute: attribute-name-string)

See dojo.data.api.Read.hasAttribute()

isItem(something: anything)

isItemLoaded(something: anything)

loadItem(args: Object)

_assertIsAttribute(attribute: attribute-name-string)

This function tests whether the item passed in is indeed a valid 'attribute' like type for the store.

_assertIsItem(item: item)

It throws an error if item is not valid, so you can call it in every method that needs to throw an error when item is invalid.

_fetchItems(request, fetchHandler, errorHandler)

The request contains the data as defined in the Read-API. Additionally there is following keyword "serverQuery". The *serverQuery* parameter, optional. This parameter contains the data that will be sent to the server. If this parameter is not given the parameter "query"'s data are sent to the server. This is done for some reasons: - to specify explicitly which data are sent to the server, they might also be a mix of what is contained in "query", "queryOptions" and the paging parameters "start" and "count" or may be even completely different things. - don't modify the request.query data, so the interface using this store can rely on unmodified data, as the combobox dijit currently does it, it compares if the query has changed - request.query is required by the Read-API I.e. the following examples might be sent via GET: fetch({query:{name:"abc"}, queryOptions:{ignoreCase:true}}) the URL will become: /url.php?name=abc fetch({serverQuery:{q:"abc", c:true}, query:{name:"abc"}, queryOptions:{ignoreCase:true}}) the URL will become: /url.php?q=abc&c=true // The serverQuery-parameter has overruled the query-parameter // but the query parameter stays untouched, but is not sent to the server! // The serverQuery contains more data than the query, so they might differ!

_filterResponse(data: The)

If the data from servers needs to be processed before it can be processed by this store, then this function should be re-implemented in subclass. This default implementation just return the data unchanged.

_xhrFetchHandler(data, request, fetchHandler, errorHandler)

PropertiesBack to top

Navigating the Dojo API Tool

There are several different methods of navigating through the object structure of the Dojo Toolkit:

Use the namespace list (to the left). The simplest method would be to use the list of namespaces defined by the Dojo Toolkit, on the left side of every page.
Drill-down from where you are. The API Tool was designed to give you as much information via drill-down as possible. Everything defined in an object can be clicked on, for more information.
Use the search. At the top of the namespace list to the left is a search box; type in the terms you are looking for, and you will be taken to a result page that spans the entire toolkit.

In addition, objects with large numbers of contained types have a simple way of jumping to sections on a page; simply look at the right side of any heading, and you will see a set of quick navigation icons. Clicking a type icon will take you to that section; clicking the up arrow icon will return you to the top of the page.

Inherited and private members

The Dojo API Tool will show the full ancestry of an object's members (including how that member was defined and whether or not it overrides an original). By default, all members of an object that are inherited are shown with the object's API listing, and all private members are hidden.

To toggle either inherited or private members, look just beneath the breadcrumb bar (above the name of the object you are viewing) and click the appropriate link.

Switching styles

The Dojo API Tool was designed with several themes in mind; we know that some people prefer light on dark, while others might prefer dark on light. With this in mind, two themes (Noir and Blanc) are currently available, with more on the way.

To switch visual styles, click on the theme you want to use, near the top right corner of the page. The API Tool will remember which style you prefer and automatically load that theme on subsequent visits.

Key/Legend

Namespaces

A namespace in Dojo parlance is an object/property bag that can contain almost anything: constructors, methods, properties, etc. Usually is expressly defined to serve a particular purpose; for example, dojo.date.locale is a namespace defined to deal with locale-specific date handling.

Constructors

A constructor is a function designed to create instances of objects. With the Dojo Toolkit, there are two ways of creating constructors: the "old school" way (i.e. defining a function with the this keyword in the body) or using dojo.declare.

Singletons

A singleton is a constructor that is defined and then immediately executed so that only one instance may ever exist during an application's lifetime. Usually this is done to capture some information in the environment, or to ensure a set of private variables that cannot be accessed from outside of the declaration. Examples include dojox.encoding.crypto.Blowfish.

Data Types

Array

Arrays are ordered lists, native to Javascript.

Boolean

Native data type representing a simple "true/false" value.

Date

Native Javascript data type to handle common date and time representations.

Node

An object that represents any kind of element being referenced/used by Javascript code. Note that the type of element is not dictated by this data type; only that it is a node of some sort.

Error

A special, native Javascript object used to indicate an error in code. Can be subclassed and used in conjunction with the throw statement, i.e. throw new MySubError(...);

Function

Functions/methods are pieces of invocable code; in JavaScript, they are also considered data and can be passed around like any other object.

Number

A Number object is used to represent any kind of numeric value; note that Javascript does not guarentee the actual underlying datatype (though the most common is a 64-bit float).

Object

Objects are the base data type of Javascript. With the Dojo API Tool, a type that cannot be determined is usually marked with this icon, in addition to straight objects.

RegExp (Regular Expression)

A regular expression is an object used for fast string search and parsing.

String

A string is any sequence of characters.

Input formats

Filtered HTML:
- Web page addresses and e-mail addresses turn into links automatically.
- Allowed HTML tags: <a> <cite> <code> <ul> <ol> <li> <dl> <dt> <dd>
 
 This site allows HTML content. While learning all of HTML may feel intimidating, learning how to use a very small number of the most basic HTML "tags" is very easy.
 
 For more information see W3C's HTML Specifications or use your favorite search engine to find other sites that explain HTML.
 
 Most unusual characters can be directly entered without any problems.
 
 If you do encounter problems, try using HTML character entities. A common example looks like & for an ampersand & character. For a full list of entities see HTML's entities page.
- Lines and paragraphs are automatically recognized. The line break, paragraph and close paragraph tags are inserted automatically. If paragraphs are not recognized simply add a couple blank lines.
PHP code:
- Using custom PHP code
  
  If you know how to script in PHP, Drupal gives you the power to embed any script you like. It will be executed when the page is viewed and dynamically embedded into the page. This gives you amazing flexibility and power, but of course with that comes danger and insecurity if you do not write good code. If you are not familiar with PHP, SQL or with the site engine, avoid experimenting with PHP because you can corrupt your database or render your site insecure or even unusable! If you do not plan to do fancy stuff with your content then you are probably better off with straight HTML.
  
  Remember that the code within each PHP item must be valid PHP code - including things like correctly terminating statements with a semicolon. It is highly recommended that you develop your code separately using a simple test script on top of a test database before migrating to your production environment.
  
  Notes:
  - You can use global variables, such as configuration parameters, within the scope of your PHP code but remember that global variables which have been given values in your code will retain these values in the engine afterwards.
  - register_globals is now set to off by default. If you need form information you need to get it from the "superglobals" $_POST, $_GET, etc.
  - You can either use the print or return statement to output the actual content for your item.
  A basic example:
  You want to have a box with the title "Welcome" that you use to greet your visitors. The content for this box could be created by going:
```
print t("Welcome visitor, ... welcome message goes here ...");
								
```
  If we are however dealing with a registered user, we can customize the message by using:
```
global $user;
if ($user->uid) {
	print t("Welcome $user->name, ... welcome message goes here ...");
}
else {
	print t("Welcome visitor, ... welcome message goes here ...");
}
								
```
  For more in-depth examples, we recommend that you check the existing Drupal code and use it as a starting point, especially for sidebar boxes.
Full HTML:
- Web page addresses and e-mail addresses turn into links automatically.
- Lines and paragraphs are automatically recognized. The line break, paragraph and close paragraph tags are inserted automatically. If paragraphs are not recognized simply add a couple blank lines.
Markdown:
- Quick Tips:
  - Two or more spaces at a line's end = Line break
  - Double returns = Paragraph
  - *Single asterisks* or _single underscores_ = Emphasis
  - **Double** or __double__ = Strong
  - This is [a link](http://the.link.com "The optional title text")
  For complete details on the Markdown syntax, see the Markdown documentation.