Is it expected behavior for Make to not evaluate a target's timestamp on the first invocation when the rule has no recipe?

The Makefile documentation on force targets states the following:

> If a rule has no prerequisites or recipe, and the target of the rule
> is a nonexistent file, then make imagines this target to have been
> updated whenever its rule is run. This implies that all targets
> depending on this one will always have their recipe run.

My interpretation of the above claim is that the target of the rule must be a non-existent file for a target to be a Force target. Thus, I do not think the force target is what is happening in the example below, but I'm happy to learn of evidence to the contrary.

Consider the following Makefile:

.PHONY: update-db-type
.DEFAULT: run-only-if-env-var-updated

ifeq ("$(shell echo $$DB_TYPE)","mysql")
DB_TYPE := mysql
else
DB_TYPE := tidb
endif

run-only-if-env-var-updated: db_type
	echo "Do an expensive operation"
	sleep 1
	touch $@

# Note that db_type is a real file.
db_type: update-db-type

update-db-type:
	echo "DB_TYPE: $(DB_TYPE)"
ifneq ("$(shell cat db_type)","$(DB_TYPE)")
	echo "$(DB_TYPE)" > db_type
endif

Now consider the following commands and their output:

echo mysql > db_type
DB_TYPE=mysql make
# Output
# echo "DB_TYPE: mysql"
# DB_TYPE: mysql
# echo "Do an expensive operation"
# Do an expensive operation
# sleep 1
# touch run-only-if-env-var-updated

DB_TYPE=tidb make
# Output
# echo "DB_TYPE: tidb"
# DB_TYPE: tidb
# echo "tidb" > db_type

DB_TYPE=tidb make
# echo "DB_TYPE: tidb"
# DB_TYPE: tidb
# echo "Do an expensive operation"
# Do an expensive operation
# sleep 1
# touch run-only-if-env-var-updated

Observe that the expensive operation run-only-if-env-var-updated is only run on the second invocation of DB_TYPE=tidb make.

This implies that, in the first invocation, Make did not observe that the timestamp of the file db_type was updated, and newer than the file run-only-if-env-var-updated.

Note that this is NOT the behavior I was expecting; my mental model was that Make would always compare the timestamp of the dependency to timestamp of the target to determine whether the target needed to run.

Now, if we make a small modification to the Makefile, by giving the target db_type a non-empty recipe, as follows, then we get the expected behavior of running the expensive operation on the first invocation of DB_TYPE=tidb make.

db_type: update-db-type
	echo "Running DB_TYPE"

Is the behavior in the first example (without the extra echo) expected behavior for Make?
If so, is there documentation that explains why the updated timestamp is being ignored on the first execution?

GNU make it doesn't ever consider that some other target, other than the one it invoked, updates the target file. So, if it sees that there is no recipe for a given target then it assumes that the target cannot have been updated.

Only if there is a recipe for a given target, will make re-check the modification time on the target to see if it has changed or not. The recipe doesn't have to actually do anything, it just has to exist. For example, this is sufficient:

db_type: update-db-type ;

The semicolon here adds an empty recipe to this rule.

IMO your makefile is pretty confusing and I would definitely not write it like this. First, why do you use $(shell echo $$DB_TYPE)? Why not just use $(DB_TYPE)? Second, it's virtually always wrong (and at least very confusing) to use ifeq etc. inside a recipe. ifeq etc. are preprocessor-like statements and they are expanded directly when the makefile is parsed, not when the recipe is invoked.

IMO this makefile does what you want and is safer:

.PHONY: update-db-type
.DEFAULT: run-only-if-env-var-updated

ifneq ($(DB_TYPE),mysql)
DB_TYPE := tidb
endif

run-only-if-env-var-updated: db_type
        echo "Do an expensive operation"
        sleep 1
        touch $@

# Note that db_type is a real file.
db_type: update-db-type ;

update-db-type:
        echo "DB_TYPE: $(DB_TYPE)"
        [ "$$(cat db_type 2>/dev/null)" = '$(DB_TYPE)' ] \
            || echo "$(DB_TYPE)" > db_type

But, a more straightforward method that is IMO more understandable is to put the recipe in the target you want to be updated, rather than some other target, and force that recipe to always be invoked. So it would be this instead:

db_type: FORCE
        echo "DB_TYPE: $(DB_TYPE)"
        [ "$$(cat $@ 2>/dev/null)" = '$(DB_TYPE)' ] \
            || echo "$(DB_TYPE)" > $@

FORCE: