If we only have black-box access to the functions $f_i$ (they are provided as oracles), then yes, it takes $\Omega(n)$ time. For instance, suppose $f_i(1000+i)=0$ and $f_i(1000+j)=1$ for $j\ne i$. This does not constrain the behavior of $f_i$ for $x<1000$, so does not provide any useful information about the $f_i$'s. Then it is possible to prove a $\Omega(n)$ time bound for queries about $x$ (when $x<1000$) using an adversary argument.
However, don't mis-interpret this! Don't assume this means that $\Omega(n)$ time is needed when the algorithm has access to a description of the $f_i$'s. An algorithm that is provided circuits or code for the $f_i$'s might well be able to do better.
For instance, suppose all the $f_i$'s come from the class if affine functions ($f_i(x)=\alpha_i x + \beta_i$), and we are given a mathematical expression for each $f_i$ (we are given the $\alpha_i$'s and $\beta_i$'s). Then there is an algorithm that uses $o(1)$ time, in this scenario. In particular, we know that $f_i(x)=0$ if and only if $x_i = -\beta_i/\alpha_i$. Therefore, we can precompute the value of all $-\beta_i/\alpha_i$; either they are all equal to some value, say $c$, or they are not all equal. If they are not all equal, then the answer to any query about any particular $x$ is always "False". If they are all equal to $c$, then the answer to a query about a particular $x$ is always "True if $x=c$, False otherwise". In both cases, you can answer queries about a particular $x$ in $O(1)$ time.
So, the $\Omega(n)$ time bound I mentioned in the first paragraph probably will not apply to most real-world situations that arise in practice.