amcostestimate�ؿ��ˤϡ�����ǥå����ȤȤ�˻Ȥ��뤳�Ȥ���ޤäƤ���WHERE��Υꥹ�Ȥ�Ϳ�����ޤ��� ���δؿ��ϥ���ǥå����˥����������륳���Ȥγ�����WHERE��������١ʤĤޤꥤ��ǥå����������ˤ���Ф����Ԥοƥơ��֥�ˤ�������ˤ��֤��ʤ��ƤϤʤ�ޤ��� ñ��ʾ����ȡ��ۤȤ�����ƤΥ����ȳ����κ�Ȥϡ����ץƥ��ޥ�����ɸ��롼�����ƤӽФ����ȤǹԤ��ޤ��� amcostestimate�ؿ�����Ĥ��Ȥΰ�̣�ϡ�ɸ��Ū������������뤳�Ȥ���ǽ�ʾ��ˡ�����ǥå�������������åɤ�����ǥå�������ͭ���μ��ηϤ뤹�뤳�Ȥ��Ǥ���Ȥ������ȤǤ���
���줾���amcostestimate�ؿ��ϰʲ��Υ����ͥ��������ʤ���Ф����ޤ���
void
amcostestimate (PlannerInfo *root,
IndexOptInfo *index,
List *indexQuals,
RelOptInfo *outer_rel,
Cost *indexStartupCost,
Cost *indexTotalCost,
Selectivity *indexSelectivity,
double *indexCorrelation);�ǽ��4�ĤΥѥ��������ϤǤ���
��������Ƥ����䤤��碌�˴ؤ���ץ��ʤξ���
�оݤΥ���ǥå�����
����ǥå��������Υꥹ�ȡʰ���Ū�������Ѥ���ޤ��ˡ� NIL�ꥹ�Ȥϻ��Ѳ�ǽ�����ʤ����Ȥ�ɽ���ޤ��� �ꥹ�Ȥ˼��ĥ���ޤޤ�뤳�Ȥ����դ��Ƥ�����������������ǤϤ���ޤ���
����ǥå�������������ǥå����������ǻ��Ѥ�����ΤȤߤʤ���Ƥ����硢���γ�¦�˴ؤ���ץ��ʤξ���Ǥ��� ����ʤ���NULL�Ǥ��� ��NULL�ʤ�С�����ΰ�����ñ�ʤ����¶�ǤϤʤ������Υ�졼�����Ȥη���Ȥʤ�ޤ��� �ޤ��������ȿ����ϡ�����ǥå����������¦�Υ�졼�����γƹԤ��Ф��Ʒ����֤�����Τ����ꤷ�ʤ���Фʤ�ޤ���
�Ǹ��4�ĤΥѥ����ϻ����Ϥ��ν��ϤǤ���
����ǥå����ε�ư�����ˤ����륳���Ȥ����ꤵ��ޤ���
����ǥå������������ΤΥ����Ȥ����ꤵ��ޤ���
����ǥå����������٤����ꤵ��ޤ���
����ǥå����������ν��֤��ظ�Υơ��֥�ν��ִ֤���ط��������ꤵ��ޤ���
�����ȳ����ؿ��ϡ�SQL�䤽��¾�μ�³������ǤϤʤ���C����ǽ�ʤ���Ф����ʤ����Ȥ����դ��Ƥ��������� ��ͳ�ϥץ���/���ץƥ��ޥ����������ǡ�����¤�˥����������ʤ���Ф����ʤ�����Ǥ���
����ǥå����������������Ȥ�src/backend/optimizer/path/costsize.c�ǻȤ��롢���֤��¤���ǥ������֥��å��μ��Ф��ˤ�seq_page_cost�Υ����Ȥ�������Ʊ�μ��Ф��ˤ�random_page_cost�Υ����Ȥ��������ơ�1�ĤΥ���ǥå����Ԥν����ˤ��̾� cpu_index_tuple_cost�Ȥ��������Ȥ������롢�Ȥ����ѥ����Ƿ�����ʤ���Фʤ�ޤ��� ����ˡ�����ǥå����������ä�indexQuals���Ȥ�ɾ���ˤδ֤˸ƤӽФ������ӱ黻���Ƥ��Ф��ơ�cpu_operator_cost��Ŭ���ʷ������������Ȥ�������ޤ���
�������������Ȥϡ�����ǥå������ȤΥ������ȴط��������ƤΥǥ�������CPU�����Ȥ�ޤ�٤��Ǥ���������ǥå����Ǽ��̤����ƥơ��֥�ιԤν�������Фˤ����륳���Ȥϴޤ�Ƥ������ޤ�����
"��ư�ѥ�����"�ϡ��ǽ�ιԤ���Ф��Ϥ�뤳�Ȥ��Ǥ���褦�ˤʤ�������䤵��ʤ���Фʤ�ʤ�����������Ȥΰ����Ǥ��� �ۤȤ�ɤΥ���ǥå����Ǥϡ������0�Ȥ��뤳�Ȥ��Ǥ��ޤ��� ���������⤤��ư�ѥ����Ȥ���ĥ���ǥå�������ǤϤ������0�ˤ��뤳�Ȥ�ޤ���
indexSelectivity�ϡ�����ǥå����������δ֤���Ф����ƥơ��֥�ιԤγ������줿���Ȥ������ꤵ���٤��Ǥ��� ̵�̤�¿������ǥå����ξ��Ϥ����ͤ���Ϳ����줿�������ºݤ��̲᤹��Ԥγ�����⤯�ʤ뤳�Ȥ��褯����ޤ���
indexCorrelation�ϡ�����ǥå����ν��֤ȥơ��֥�ν��֤δ֤Ρ�-1.0����1.0�ޤǤδ֤��ͤ������ؤȤ������ꤵ���٤��Ǥ��� �����ͤϡ��ᥤ��ơ��֥뤫��Ԥ���Ф�����Υ����ȳ�����Ĵ�����뤿��˻��Ѥ���ޤ���
���ξ�硢�֤������ϥ���ǥå�����1�����������ꤵ���ʿ���ͤǤʤ���Фʤ�ޤ���
�����ȳ���
ŵ��Ū�ʥ����ȳ����ϼ��Τ褦�˿ʤ���ޤ���
Ϳ����줿������˴�Ť���ˬ�����ᥤ��ơ��֥�ιԤγ��������֤��ޤ���
����ǥå�������ͭ���μ��ηϤ�����ʤ���硢ɸ��Υ��ץƥ��ޥ����δؿ��Ǥ���clauselist_selectivity()����Ѥ��Ƥ���������
*indexSelectivity = clauselist_selectivity(root, indexQuals,
index->rel->relid, JOIN_INNER);
����������ˬ����륤��ǥå����ιԿ������ޤ��� ¿���Υ���ǥå������Ǥϡ������indexSelectivity�ȥ���ǥå�������ˤ���Կ���ݤ�����Τ��������Ǥ�����������¿�����⤢��ޤ� �ʥڡ�������ӹ���Υ���ǥå����Υ�������IndexOptInfo��¤�Τ������뤳�Ȥ��Ǥ��ޤ��ˡ�
������������Ф���륤��ǥå����ڡ����������ޤ��� �����ñ��indexSelectivity�˥ڡ�����Υ���ǥå����Υ�������ݤ�����Τˤʤ�Ǥ��礦��
����ǥå����������������Ȥ�����ޤ��� ����Ū�ʳ����ˤ����Ƥϰʲ��Τ褦�˹Ԥ��Ǥ��礦��
/*
* Our generic assumption is that the index pages will be read
* sequentially, so they cost seq_page_cost each, not random_page_cost.
* sequentially, so they have cost 1.0 each, not random_page_cost.
* Also, we charge for evaluation of the indexquals at each index row.
* All the costs are assumed to be paid incrementally during the scan.
*/
cost_qual_eval(&index_qual_cost, indexQuals);
*indexStartupCost = index_qual_cost.startup;
*indexTotalCost = seq_page_cost * numIndexPages +
(cpu_index_tuple_cost + index_qual_cost.per_tuple) * numIndexTuples;����������ǤϷ����η����֤���륤��ǥå����������ˤ����륤��ǥå����ɤ߹��ߤˤĤ��Ƴ����ۺѤ��θ���Ƥ��ޤ���
����ǥå�������ؤ����ޤ���1�ĤΥե�����ɤ��Ф���ñ��ʽ��֤Υ���ǥå����Ǥϡ������pg_statistic�������ꤹ�뤳�Ȥ��Ǥ��ޤ��� ��ؤ�̤�Τξ�硢�������ѿ������ͤ����0��̵��ءˤȤʤ�ޤ���
�����ȳ����ؿ������src/backend/utils/adt/selfuncs.c�ˤ���ޤ���