Model relation reusable=>false not working

[nilsm]

Expected and Actual Behavior

I have a model with a relation set to 'reusable' => false.
I would expect the relation to be fetched from the database every time it is accessed.
However the relation is cached after the first call, even though 'reusable' => false.
Using 'getRelated()' to access the relation works as intended.

Note: 'reusable' => false is the default setting, so models do not work as intended by default.

Here is some sample code:

class Robots extends \Phalcon\Mvc\Model
{
    public $id;
    public $name;
    public function initialize()
    {
        $this->hasMany("id", "Parts", "robot_id", ['reusable' => false]);
    }
}

class Parts extends \Phalcon\Mvc\Model
{
    public $id;
    public $robot_id;
    public $name;
    public static function find($parameters = NULL)
    {
    	echo 'find';
    	return parent::find($parameters);
    }
    public function initialize()
    {
        $this->belongsTo("robot_id", "Robots", "id", ['alias' => 'robot']);
    }
}

// actual code to test
$robot = new Robot();
$robot->name = 'Bob';
$robot->save();

$robot->parts; // first query - echos 'find'
$robot->parts; // 2nd query - no echo, even though it should re-query
$robot->getRelated('parts'); // echo 'find', as intended
$robot->getRelated('parts'); // echo 'find', as intended

Severity

Critical - this is stopping us from upgrading to Phalcon 3 + model relations do not work as documented.

Details

• Phalcon version: 3.4.1
• PHP Version: 5.6
• Operating System: n/a
• Installation type: Compiling from source
• Zephir version (if any): n/a
• Server: n/a
• Other related info

CREATE TABLE `robots` (
    `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
    `name` varchar(70) NOT NULL,
    PRIMARY KEY (`id`)
);
CREATE TABLE `parts` (
    `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
    `robot_id` int(10) unsigned NOT NULL,
    `name` varchar(70) NOT NULL,
    PRIMARY KEY (`id`),
    FOREIGN KEY (robot_id) references robots(id)
);

[nilsm]

I've dug around in the source code and am pretty sure that this is the cause of the problem:

https://github.com/phalcon/cphalcon/pull/11983/files

Once accessed, the related records are stored as an instance property and returned every time, regardless of what 'reusable' is set to.

[Jurigag]

Why it should requery? After first getting it it adds as a property, this is intended to keep behavior with magic properties. You can use getParts for example(and you imh should).

[nilsm]

@Jurigag I would expect it to requery because reusable is false. I do not see from the documentation that some access methods are intended to behave differently to others. Also in Phalcon 2 it does requery when using the magic getter and I suspect the change in behaviour was an unintended consequence of the pull request I linked to?

[nilsm]

Just to add more info:

getParts() and getRelated('Parts') both respect the 'reusable' setting in the relation.
$robot->Parts does not - it never refetches after first access

This is a change compared to behaviour in Phalcon 2. It was introduced by, I think, #11983 - and I think it's most likely unintentional and undocumented.

[Jurigag]

I think this is intentional to keep behavior with magic properties etc.

[nilsm]

Thanks Jurigag - what do you think about the way it's changed from Phalcon 2 to Phalcon 3? It does requery (depending on the reusable setting) in Phalcon 2, even when using ->Parts. This is causing lots of upgrade problems for us - but it also makes me think that it's a bug, as the behaviour has changed without being documented.

[Jurigag]

I think as i already wrote, this change was made to keep behavior how magic properties works in php world, like in 90% of magic properties stuff, when first access them __get is fired and on later accessing the same property we already use property we added in __get.

[CameronHall]

I disagree @Jurigag. I noticed this when I created the PR for the isRelationshipLoaded method. Perhaps I misunderstand what the reusable attribute is meant to do on relationships, but my assumption would be that instance of the relationship would never be cached if "reusable" is false.

[CameronHall]

@niden this is a bug

[niden]

Resolved in #14035