Tecnicas para mejora de eficiencia en consultas

Hola:
hace un tiempo lei un articulo (para Oracle) que entre otras cosas decía:
-------------------
Es frecuente el uso de sentencias en las que se pregunta por un campo
nulo, para actualizarlo a continuación. Si la tabla es
muy grande y van a recuperarse pocos registros, interesa que ese campo
tenga inicialmente un valor por defecto (no nulo), y
se pregunte luego por ese valor. Por ejemplo, una tabla CLIENTES con un
campo TELEFONO. Este campo se deja
inicialmente con NULL y se ejecutan sentencias del tipo

select * from clientes where telefono is null;

Esta sentencia siempre hara un recorrido secuencial

-------------------

es esto cierto para PostgreSQL tambien?

Otra:

cito:
---------------------------
La clave del buen rendimiento de una operación NESTED LOOPS es el orden
en que se realiza el join de las tablas. El
número de repeticiones del bucle es el producto del número de registros
resultante de la primera tabla por el número de
registros de la segunda tabla a los que se accede después. Si se añaden
más tablas en el join, la elección de la primera tabla
es aún más crítica. Lo conveniente es minimizar el número de registros
leídos en los primeros pasos del bucle.
Consideremos un ejemplo. Tenemos una sentencia en la que aparecen 4
tablas (A, B, C y D), todas ellas del mismo tamaño,
con las siguientes cláusulas FROM y WHERE:

from D, C, B, A
where A.cod = B.cod
and B.cod = C.cod
and C.cod = D.cod
and A.cod = 123
and D.val = 'VALOR'

Si las tablas A, B, C y D tienen índices para sus columnas cod, un
NESTED LOOP será la operación que usará Oracle para
resolver la sentencia. Se hará un join de A con B, del resultado de este
join con C y del resultado de este último con D.
Finalmente, se aplicará la condición que hay sobre D.val.
Si D.val es una columna selectiva, el rendimiento de la sentencia será
mejor si hacemos que D entre en el primer NESTED
LOOP de la ejecución. De esta forma, menos registros serán devueltos al
siguiente NESTED LOOP y así sucesivamente. La
anterior cláusula WHERE puede reescribirse así:
from D, C, B, A
where A.cod = B.cod
and B.cod = C.cod
and C.cod = D.cod
and D.cod = 123
and D.val = 'VALOR'
Ahora, se hará un join de D con C, del resultado con B y, finalmente, con A.
-----------------------------------------------------------------

aplica esto tambien a postgreSQL

y uno último

iamgina que tenemos una consulta

SELECT *
FROM una_tabla
WHERE
campo_a = un_valor AND cambo_b = otro_valor

imaginense que tengo un indice en cada uno de esos campo
si index_a es mas selectivo que index_b
entonces hay alguna diferencia si ejecuto:

campo_a = un_valor AND cambo_b = otro_valor

o sie ejecuto

cambo_b = otro_valor AND campo_a = un_valor

Bueno eas son mis dudas, ahora quien pueda reponderme parcialmente o
totalmente gracias
seguire investigando