What do we call the equivalent of CSS "Specificity" in SQL?
In CSS, the more HTML elements you specify, the more precedence the selector gets. This is known as &quot;specificity.&quot; For example,

That's not true. CSS specificity is very complex because it's trying to apply conflicting rules rather simply disambiguate. While I understand what you're talking about SQL suffers no such problem with identifiers as queries are either executed with certainty or an error is thrown.

Is there a proper term in SQL for being more specific in queries, or is it just called &quot;specificity&quot; like in CSS?

The intent here is different, &quot;specifity&quot; doesn't exist.

In CSS, the goal is to establish a ruleset to apply conflicting rules.
In SQL, the goal with the syntax you've mentioned is to merely disambiguate.

In the context given we would say &lt;catalog&gt;.&lt;schema&gt;.&lt;table&gt;.&lt;column&gt; is &quot;fully qualified&quot;, as in it leaves no further room for ambiguity. This definition comes from ISO9075-1.,

fully qualified (of a name of some SQL object) With all optional components specified explicitly
NOTE 3 — A fully qualified name does not necessarily identify an object uniquely. For example, although a fully qualified specific name, consisting of a catalog name, a schema name and a specific name, uniquely identifies a routine, a fully qualified routine name doesn't necessarily do so.

NOTE 3 is referring to routines being typed, catalog.schema.myRoutine(text,text) can be different from catalog.schema.myRoutine(int,int).
This is massively different from &quot;specificity&quot; which implies cascading mutability -- if we say &quot;show all animals&quot; and &quot;hide all dogs&quot; and &quot;show collies&quot; what should happen?
&lt;div class=&quot;animals&quot;&gt;
  &lt;div class=&quot;dogs&quot;&gt;
    &lt;div class=&quot;collies&quot; id=&quot;Lassie&quot;&gt;

.animals { display: block }
.dogs { display: none }
.collies { display: block }

In CSS, you have to know if multiple rules can apply to the same identifier, which one has precedence in the event they conflict. In SQL, the rule-set is much simpler. If there is any ambiguity, things will throw a fatal error. All databases that I can think of forgo any attempt at guesswork. Preventing that fatal error from being thrown requires qualification of your &quot;identifiers&quot;.
For instance, the following creates a result set that returns two x (some databases would likely throw an error here),
SELECT *
FROM ( VALUES (1) ) AS t(x)
CROSS JOIN ( VALUES (2) ) AS g(x);
 x | x 
---+---
 1 | 2
(1 row)

but the second you say you want x with SELECT x rather than SELECT * all databases that I know of throw an error,
ERROR:  column reference &quot;x&quot; is ambiguous
LINE 1: SELECT x FROM ( VALUES (1) ) AS t(x) CROSS JOIN ( VALUES (2)...

Logically you may ask what the equivalent of SQL &quot;fully qualified&quot; identifiers in CSS. That would be a simple identifier (id attribute selectors). The spec requires identifiers be absolute, thus there is no ambiguity when you specify
#Lassie { color: blue }

It's infinitely (fully-) (globally-) &quot;specific&quot; (qualified), and far more specific than
.animals.dogs.collies { color: white }

Actually there is a small rabbit hole I'm excluding and that's XHTML namespaces and Foreign Elements. which do in fact provide for multiple #Lassies (that is to say identifiers aren't always globally unique)