staticHTAB*createConnHash(void);

staticvoidcreateNewConnection(constchar*name,remoteConn*rconn);

staticvoiddeleteConnection(constchar*name);

staticchar**get_pkey_attnames(Relationrel,int16*indnkeyatts);

staticchar**get_pkey_attnames(Relationrel,int16*indnkeyatts);

staticchar**get_text_array_contents(ArrayType*array,int*numitems);

staticchar*get_sql_insert(Relationrel,int*pkattnums,intpknumatts,char**src_pkattvals,char**tgt_pkattvals);

staticchar*get_sql_delete(Relationrel,int*pkattnums,intpknumatts,char**tgt_pkattvals);

<synopsis>

CREATE [ UNIQUE ] INDEX [ CONCURRENTLY ] [ [ IF NOT EXISTS ] <replaceable class="parameter">name</replaceable> ] ON <replaceable class="parameter">table_name</replaceable> [ USING <replaceable class="parameter">method</replaceable> ]

( { <replaceable class="parameter">column_name</replaceable> | ( <replaceable class="parameter">expression</replaceable> ) } [ COLLATE <replaceable class="parameter">collation</replaceable> ] [ <replaceable class="parameter">opclass</replaceable> ] [ ASC | DESC ] [ NULLS { FIRST | LAST } ] [, ...] )

[ INCLUDING ({<replaceable class="parameter">column_name</replaceable>| ( <replaceable class="parameter">expression</replaceable> ) } [ COLLATE <replaceable class="parameter">collation</replaceable> ] [ ASC | DESC ] [ NULLS { FIRST | LAST } ] [, ...] )

[ INCLUDING ( <replaceable class="parameter">column_name</replaceable>[, ...] ) ]

[ WITH ( <replaceable class="PARAMETER">storage_parameter</replaceable> = <replaceable class="PARAMETER">value</replaceable> [, ... ] ) ]

[ TABLESPACE <replaceable class="parameter">tablespace_name</replaceable> ]

[ WHERE <replaceable class="parameter">predicate</replaceable> ]

<para>

An optional <literal>INCLUDING</> clause allows a list of columns to be

specified which will be included in the index, in the non-key portion of

the index. Columns which are part of this clause cannot also exist in the

key columns portion of the index, and vice versa. The

<literal>INCLUDING</> columns exist solely to allow more queries to benefit

from <firstterm>index-only scans</> by including certain columns in the

index, the value of which would otherwise have to be obtained by reading

the table's heap. Having these columns in the <literal>INCLUDING</> clause

in some cases allows <productname>PostgreSQL</> to skip the heap read

completely. This also allows <literal>UNIQUE</> indexes to be defined on

one set of columns, which can include another set of column in the

<literal>INCLUDING</> clause, on which the uniqueness is not enforced upon.

It's the same with other constraints (PRIMARY KEY and EXCLUDE). This can

also can be used for non-unique indexes as any columns which are not required

for the searching or ordering of records can be included in the

<literal>INCLUDING</> clause, which can slightly reduce the size of the index,

due to storing included attributes only in leaf index pages.

Currently, only the B-tree access method supports this feature.

the index. Columns which are part of this clause cannot also exist in

the key columns portion of the index, and vice versa. The

<literal>INCLUDING</> columns exist solely to allow more queries to

benefit from <firstterm>index-only scans</> by including certain

columns in the index, the value of which would otherwise have to be

obtained by reading the table's heap. Having these columns in the

<literal>INCLUDING</> clause in some cases allows

<productname>PostgreSQL</> to skip the heap read completely. This

also allows <literal>UNIQUE</> indexes to be defined on one set of

columns, which can include another set of column in the

<literal>INCLUDING</> clause, on which the uniqueness is not enforced

upon. It's the same with other constraints (PRIMARY KEY and EXCLUDE).

This can also can be used for non-unique indexes as any columns which

are not required for the searching or ordering of records can be

included in the <literal>INCLUDING</> clause, which can slightly reduce

the size of the index, due to storing included attributes only in leaf

index pages. Currently, only the B-tree access method supports this

feature. Expressions as included columns are not supported since

they cannot be used in index-only scan.

</para>

</listitem>

</varlistentry>

Optional clause <literal>INCLUDING</literal> allows to add into the index

a portion of columns on which the uniqueness is not enforced upon.

Note, that althogh constraint is not enforced upon included columns, it still

depends on them. Consequently, some operations on these columns (e.g. <literal>DROP COLUMN<literal>)

depends on them. Consequently, some operations on these columns (e.g. <literal>DROP COLUMN</literal>)

can cause cascade constraint and index deletion.

See paragraph about <literal>INCLUDING</literal> in

<xref linkend="SQL-CREATEINDEX"> for more information.

Optional clause <literal>INCLUDING</literal> allows to add into the index

a portion of columns on which the constraint is not enforced upon.

Note, that althogh constraint is not enforced upon included columns, it still

depends on them. Consequently, some operations on these columns (e.g. <literal>DROP COLUMN<literal>)

depends on them. Consequently, some operations on these columns (e.g. <literal>DROP COLUMN</literal>)

can cause cascade constraint and index deletion.

See paragraph about <literal>INCLUDING</literal> in

<xref linkend="SQL-CREATEINDEX"> for more information.

index_reform_tuple(Relationidxrel,IndexTupleolditup,intnatts,intnkeyatts)

index_truncate_tuple(Relationidxrel,IndexTupleolditup)

{

TupleDescitupdesc=RelationGetDescr(idxrel);

Datumvalues[INDEX_MAX_KEYS];

boolisnull[INDEX_MAX_KEYS];

IndexTuplenewitup;

intindnatts=IndexRelationGetNumberOfAttributes(idxrel);

intindnkeyatts=IndexRelationGetNumberOfKeyAttributes(idxrel);

Assert(natts <=INDEX_MAX_KEYS);

Assert(nkeyatts>0);

Assert(nkeyatts <=natts);

Assert(indnatts <=INDEX_MAX_KEYS);

Assert(indnkeyatts>0);

Assert(indnkeyatts <=indnatts);

index_deform_tuple(olditup,itupdesc,values,isnull);

itupdesc->natts=nkeyatts;

itupdesc->natts=indnkeyatts;

newitup=index_form_tuple(itupdesc,values,isnull);

newitup->t_tid=olditup->t_tid;

itupdesc->natts=natts;

itupdesc->natts=indnatts;

Assert(IndexTupleSize(newitup) <=IndexTupleSize(olditup));

returnnewitup;

}

elog(ERROR,"cannot insert to incompletely split page %u",

BufferGetBlockNumber(buf));

if (rel->rd_index->indnatts!=rel->rd_index->indnkeyatts

&& !P_ISLEAF(lpageop))

{

itup=index_reform_tuple(rel,itup,

rel->rd_index->indnatts,rel->rd_index->indnkeyatts);

}

itemsz=IndexTupleDSize(*itup);

itemsz=MAXALIGN(itemsz);/* be safe, PageAddItem will do this but we

if (indnatts!=indnkeyatts&&P_ISLEAF(lopaque))

{

lefthikey=index_reform_tuple(rel,item,indnatts,indnkeyatts);

lefthikey=index_truncate_tuple(rel,item);

itemsz=IndexTupleSize(lefthikey);

itemsz=MAXALIGN(itemsz);

}

right_item_sz=ItemIdGetLength(itemid);

item= (IndexTuple)PageGetItem(lpage,itemid);

if (rel->rd_index->indnatts!=rel->rd_index->indnkeyatts)

right_item=index_reform_tuple(rel,item,rel->rd_index->indnatts,rel->rd_index->indnkeyatts);

right_item=CopyIndexTuple(item);

right_item=CopyIndexTuple(item);

ItemPointerSet(&(right_item->t_tid),rbkno,P_HIKEY);

keytup=index_reform_tuple(wstate->index,oitup,

indnatts,indnkeyatts);

keytup=index_truncate_tuple(wstate->index,oitup);

START_CRIT_SECTION();

PageIndexTupleDelete(opage,P_HIKEY);

if (!_bt_pgaddtup(opage,IndexTupleSize(keytup),keytup,P_HIKEY))

elog(ERROR,"failed to rewrite compressed item in index \"%s\"",

RelationGetRelationName(wstate->index));

END_CRIT_SECTION();

}

if (indnkeyatts!=indnatts&&P_ISLEAF(opageop))

state->btps_minkey=index_reform_tuple(wstate->index,oitup,

indnatts,indnkeyatts);

state->btps_minkey=index_truncate_tuple(wstate->index,oitup);

state->btps_minkey=CopyIndexTuple(oitup);

if (indnkeyatts<indnatts&&P_ISLEAF(pageop))

state->btps_minkey=index_reform_tuple(wstate->index,itup,

indnatts,indnkeyatts);

state->btps_minkey=index_truncate_tuple(wstate->index,itup);

state->btps_minkey=CopyIndexTuple(itup);}

if (!P_ISLEAF(pageop))

{

itup=index_reform_tuple(wstate->index,

itup,wstate->index->rd_index->indnatts,

wstate->index->rd_index->indnkeyatts);

itup=index_truncate_tuple(wstate->index,itup);

itupsz=IndexTupleDSize(*itup);

itupsz=MAXALIGN(itupsz);

}

externvoidindex_deform_tuple(IndexTupletup,TupleDesctupleDescriptor,

Datum*values,bool*isnull);

externIndexTupleCopyIndexTuple(IndexTuplesource);

externIndexTupleindex_reform_tuple(Relationidxrel,IndexTupleolditup,

intindnatts,intindnkeyatts);

externIndexTupleindex_truncate_tuple(Relationidxrel,IndexTupleolditup);