Getting Multiple Object Fields—FAST

In my previous articles, we discussed a fast way to get individual object fields in MODX Revolution with getValue(), but what if you need more than one field?

In this article, we’ll look at a very fast way to get multiple object fields and place them in a PHP array without retrieving the whole object.

The Method

This is an example that gets several Resource fields from the Resource with the ID 12:

$prefix = $modx->getVersionData()['version'] >= 3
  ? 'MODX\Revolution\\'
  : '';

$query = $modx->newQuery($prefix . 'modResource');
$query->where(array('id' => '12'));
$query->select(array(
    'ID'        => 'id',
    'Class'     => 'class_key',
    'Context'   => 'context_key',
    'Published' => 'published'
));
$results = array();
if ($query->prepare() && $query->stmt->execute()) {
    $results = $query->stmt->fetchAll(PDO::FETCH_ASSOC);
}

return print_r($results, true);

The code above will display something like this:

Array
(
    [0] => Array
        (
            [ID] => 12
            [Class] => modDocument
            [Context] => web
            [Published] => 1
        )
)

Note that the terms on the left side of the select() array are arbitrary “aliases”. You’re free to use the actual field names, but whatever you use will provide the keys for the $results array. That allows you to use them as captions in the output instead of the actual field names, as in the example below. The values on the right must be the actual field names.

Things to Remember

To use this method, you need to know the actual names of the fields you need. You can find the available fields for each MODX object here.

The results will always be in a nested array, even if there’s only one result. It will be an array where each member is an array of 'fieldname' => 'value' pairs representing one row of the table. If we had used the code below for the where clause, we’d get many results, each nested under the larger array:

$query->where(array(
    'published' => '1',
));

You also need to remember that, just like in the previous articles, you will be getting the raw field values because the data is not being passed through the xPDO get() method. Date fields will be in the form of Unix timestamps and fields like the modUser object’s extended field and the properties field for resources and elements will be returned as JSON strings. If you are getting a TV values, you’ll also get the raw, un-rendered values, which might be @INHERIT, for example.

Walking

Because we created our own array keys in the code above to use as captions, we can walk through and display the array with nested foreach loops, like this:

foreach ($results as $result) {
    foreach ($result as $key => $value) {
        echo "\n<br>" . $key . ': ' . $value;
    }
}

The output of that code for each object would look something like this:

<br>ID: 12
<br>Class: modDocument
<br />Context: web
<br>Published: 1

This double foreach loop will only work if you can display the raw field values without processing any of them.

Using Tpl Chunks

Rather than the double foreach loop shown above (which usually isn’t very practical), you can use a Tpl Chunk with placeholder tags to format the data, and still have very fast page-load times. Using our example query above, here’s an example using a simple Tpl Chunk.

MyChunk Tpl Chunk

ID: [[+ID]]
Class: [[+Class]]
Context: [[+Context]]
Publisher: [[+Published]]

Notice that the placeholders are from the left side of the array in the Snippet. They will be replaced by the corresponding values of the fields listed on the right site.

The PHP Code

This would replace the display code in the Snippet above. It’s a better practice because it separates the data from the code. Changes to the display can be made just by editing the Tpl Chunk, rather than editing the Snippet code (which can blow up on you for even trivial errors introduced into the code).

$output = '';
foreach ($results as $result) {
    $output .= $modx->getChunk('MyChunk', $result);
}
return $output;

At first glance, this looks like the standard way to process results using the Tpl Chunk, but it’s not. Notice that the placeholders are not the actual field names—they are the “captions” (more correctly, the “aliases”) from the left side of the $query->select()array we used above to get the data. In the standard Tpl Chunk usage, we call toArray() on the objects and the actual field names are the “keys” of the resulting array. In this case, we were able to create our own aliases in the select() call.

That said, it’s not a bad idea to use the actual field names (assuming that you know them) for both the select() call and for the placeholders just so that, when entering the placeholders, you don’t have to remember exactly what aliases you used. If you already have the Tpl Chunks and are converting to this method, you’ll definitely want to use the actual field names for the aliases—that way the Tpl Chunk won’t need to be changed.

---

Bob Ray is the author of the MODX: The Official Guide and dozens of MODX Extras including QuickEmail, NewsPublisher, SiteCheck, GoRevo, Personalize, EZfaq, MyComponent and many more. His website is Bob’s Guides. It not only includes a plethora of MODX tutorials but there are some really great bread recipes there, as well.