pgindent run on all C files. Java run to follow. initdb/regression

tests pass.

1 files changed, 538 insertions, 421 deletions

diff --git a/src/backend/access/gist/gist.c b/src/backend/access/gist/gist.c
index 4a702fe317..0c4e698f01 100644
--- a/src/backend/access/gist/gist.c
+++ b/src/backend/access/gist/gist.c
@@ -8,7 +8,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/gist/gist.c,v 1.84 2001/10/06 23:21:43 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/gist/gist.c,v 1.85 2001/10/25 05:49:20 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -36,26 +36,26 @@
 
 /* group flags ( in gistSplit ) */
 #define LEFT_ADDED	0x01
-#define RIGHT_ADDED	0x02
+#define RIGHT_ADDED 0x02
 #define BOTH_ADDED	( LEFT_ADDED | RIGHT_ADDED )
 
 /*
  * This defines only for shorter code, used in gistgetadjusted
  * and gistadjsubkey only
  */
-#define FILLITEM(evp, isnullkey, okey, okeyb, rkey, rkeyb)   do { \
-        if ( isnullkey ) {                                        \
-                gistentryinit((evp), rkey, r, (Page) NULL ,       \
-                        (OffsetNumber) 0, rkeyb, FALSE);          \
-        } else {                                                  \
-                gistentryinit((evp), okey, r, (Page) NULL,        \
-                        (OffsetNumber) 0, okeyb, FALSE);          \
-        }                                                         \
+#define FILLITEM(evp, isnullkey, okey, okeyb, rkey, rkeyb)	 do { \
+		if ( isnullkey ) {										  \
+				gistentryinit((evp), rkey, r, (Page) NULL ,		  \
+						(OffsetNumber) 0, rkeyb, FALSE);		  \
+		} else {												  \
+				gistentryinit((evp), okey, r, (Page) NULL,		  \
+						(OffsetNumber) 0, okeyb, FALSE);		  \
+		}														  \
 } while(0)
 
 #define FILLEV(isnull1, key1, key1b, isnull2, key2, key2b) do { \
-	FILLITEM(*ev0p, isnull1, key1, key1b, key2, key2b);     \
-	FILLITEM(*ev1p, isnull2, key2, key2b, key1, key1b);     \
+	FILLITEM(*ev0p, isnull1, key1, key1b, key2, key2b);		\
+	FILLITEM(*ev1p, isnull2, key2, key2b, key1, key1b);		\
 } while(0);
 
 /* Working state for gistbuild and its callback */
@@ -69,11 +69,11 @@ typedef struct
 
 /* non-export function prototypes */
 static void gistbuildCallback(Relation index,
-							  HeapTuple htup,
-							  Datum *attdata,
-							  char *nulls,
-							  bool tupleIsAlive,
-							  void *state);
+				  HeapTuple htup,
+				  Datum *attdata,
+				  char *nulls,
+				  bool tupleIsAlive,
+				  void *state);
 static void gistdoinsert(Relation r,
 			 IndexTuple itup,
 			 InsertIndexResult *res,
@@ -103,14 +103,14 @@ static IndexTuple gistgetadjusted(Relation r,
 				IndexTuple oldtup,
 				IndexTuple addtup,
 				GISTSTATE *giststate);
-static int gistfindgroup( GISTSTATE *giststate, 
-			GISTENTRY *valvec, GIST_SPLITVEC * spl );
+static int gistfindgroup(GISTSTATE *giststate,
+			  GISTENTRY *valvec, GIST_SPLITVEC *spl);
 static void gistadjsubkey(Relation r,
-                  IndexTuple *itup, int *len,
-		  GIST_SPLITVEC *v,
-                  GISTSTATE *giststate);
-static IndexTuple gistFormTuple( GISTSTATE *giststate, 
-			Relation r, Datum attdata[], int datumsize[], bool isnull[] );
+			  IndexTuple *itup, int *len,
+			  GIST_SPLITVEC *v,
+			  GISTSTATE *giststate);
+static IndexTuple gistFormTuple(GISTSTATE *giststate,
+			Relation r, Datum attdata[], int datumsize[], bool isnull[]);
 static IndexTuple *gistSplit(Relation r,
 		  Buffer buffer,
 		  IndexTuple *itup,
@@ -124,6 +124,7 @@ static OffsetNumber gistchoose(Relation r, Page p,
 		   IndexTuple it,
 		   GISTSTATE *giststate);
 static void gistdelete(Relation r, ItemPointer tid);
+
 #ifdef GIST_PAGEADDITEM
 static IndexTuple gist_tuple_replacekey(Relation r,
 					  GISTENTRY entry, IndexTuple t);
@@ -132,14 +133,15 @@ static void gistcentryinit(GISTSTATE *giststate, int nkey,
 			   GISTENTRY *e, Datum k,
 			   Relation r, Page pg,
 			   OffsetNumber o, int b, bool l, bool isNull);
-static void gistDeCompressAtt( 	GISTSTATE *giststate, Relation r, 
-				IndexTuple tuple, Page p, OffsetNumber o, 
-				GISTENTRY attdata[], bool decompvec[], bool isnull[] );
-static void gistFreeAtt(  Relation r, GISTENTRY attdata[], bool decompvec[] );
-static void gistpenalty( GISTSTATE *giststate, int attno, 
+static void gistDeCompressAtt(GISTSTATE *giststate, Relation r,
+				  IndexTuple tuple, Page p, OffsetNumber o,
+				  GISTENTRY attdata[], bool decompvec[], bool isnull[]);
+static void gistFreeAtt(Relation r, GISTENTRY attdata[], bool decompvec[]);
+static void gistpenalty(GISTSTATE *giststate, int attno,
 			GISTENTRY *key1, bool isNull1,
-			GISTENTRY *key2, bool isNull2, 
-			float *penalty );
+			GISTENTRY *key2, bool isNull2,
+			float *penalty);
+
 #undef GISTDEBUG
 
 #ifdef GISTDEBUG
@@ -182,7 +184,7 @@ gistbuild(PG_FUNCTION_ARGS)
 
 	/* do the heap scan */
 	reltuples = IndexBuildHeapScan(heap, index, indexInfo,
-								   gistbuildCallback, (void *) &buildstate);
+								gistbuildCallback, (void *) &buildstate);
 
 	/* okay, all heap tuples are indexed */
 
@@ -208,7 +210,7 @@ gistbuild(PG_FUNCTION_ARGS)
 		UpdateStats(irelid, buildstate.indtuples);
 	}
 
-	freeGISTstate( &buildstate.giststate );
+	freeGISTstate(&buildstate.giststate);
 #ifdef GISTDEBUG
 	gist_dumptree(index, 0, GISTP_ROOT, 0);
 #endif
@@ -227,28 +229,31 @@ gistbuildCallback(Relation index,
 				  bool tupleIsAlive,
 				  void *state)
 {
-	GISTBuildState   *buildstate = (GISTBuildState *) state;
+	GISTBuildState *buildstate = (GISTBuildState *) state;
 	IndexTuple	itup;
 	bool		compvec[INDEX_MAX_KEYS];
 	GISTENTRY	tmpcentry;
 	int			i;
 
-	/* GiST cannot index tuples with leading NULLs */ 
-	if (  nulls[0] == 'n' )
-		return; 
+	/* GiST cannot index tuples with leading NULLs */
+	if (nulls[0] == 'n')
+		return;
 
 	/* immediately compress keys to normalize */
 	for (i = 0; i < buildstate->numindexattrs; i++)
 	{
-		if ( nulls[i]=='n' ) {
+		if (nulls[i] == 'n')
+		{
 			attdata[i] = (Datum) 0;
 			compvec[i] = FALSE;
-		} else {
+		}
+		else
+		{
 			gistcentryinit(&buildstate->giststate, i, &tmpcentry, attdata[i],
-					   (Relation) NULL, (Page) NULL, (OffsetNumber) 0,
-					   -1 /* size is currently bogus */ , TRUE, FALSE);
+						   (Relation) NULL, (Page) NULL, (OffsetNumber) 0,
+						 -1 /* size is currently bogus */ , TRUE, FALSE);
 			if (attdata[i] != tmpcentry.key &&
-				!( isAttByVal(&buildstate->giststate, i)))
+				!(isAttByVal(&buildstate->giststate, i)))
 				compvec[i] = TRUE;
 			else
 				compvec[i] = FALSE;
@@ -262,10 +267,10 @@ gistbuildCallback(Relation index,
 
 	/*
 	 * Since we already have the index relation locked, we call
-	 * gistdoinsert directly.  Normal access method calls dispatch
-	 * through gistinsert, which locks the relation for write.	This
-	 * is the right thing to do if you're inserting single tups, but
-	 * not when you're initializing the whole index at once.
+	 * gistdoinsert directly.  Normal access method calls dispatch through
+	 * gistinsert, which locks the relation for write.	This is the right
+	 * thing to do if you're inserting single tups, but not when you're
+	 * initializing the whole index at once.
 	 */
 	gistdoinsert(index, itup, NULL, &buildstate->giststate);
 
@@ -291,6 +296,7 @@ gistinsert(PG_FUNCTION_ARGS)
 	Datum	   *datum = (Datum *) PG_GETARG_POINTER(1);
 	char	   *nulls = (char *) PG_GETARG_POINTER(2);
 	ItemPointer ht_ctid = (ItemPointer) PG_GETARG_POINTER(3);
+
 #ifdef NOT_USED
 	Relation	heapRel = (Relation) PG_GETARG_POINTER(4);
 #endif
@@ -303,29 +309,33 @@ gistinsert(PG_FUNCTION_ARGS)
 
 	/*
 	 * Since GIST is not marked "amconcurrent" in pg_am, caller should
-	 * have acquired exclusive lock on index relation.  We need no locking
+	 * have acquired exclusive lock on index relation.	We need no locking
 	 * here.
 	 */
 
-	/* GiST cannot index tuples with leading NULLs */ 
-	if (  nulls[0] == 'n' ) {
+	/* GiST cannot index tuples with leading NULLs */
+	if (nulls[0] == 'n')
+	{
 		res = NULL;
 		PG_RETURN_POINTER(res);
-	} 
+	}
 
 	initGISTstate(&giststate, r);
 
 	/* immediately compress keys to normalize */
 	for (i = 0; i < r->rd_att->natts; i++)
 	{
-		if ( nulls[i]=='n' ) {
+		if (nulls[i] == 'n')
+		{
 			datum[i] = (Datum) 0;
 			compvec[i] = FALSE;
-		} else {
+		}
+		else
+		{
 			gistcentryinit(&giststate, i, &tmpentry, datum[i],
-					   (Relation) NULL, (Page) NULL, (OffsetNumber) 0,
-					   -1 /* size is currently bogus */ , TRUE, FALSE );
-			if (datum[i] != tmpentry.key && !( isAttByVal( &giststate, i)))
+						   (Relation) NULL, (Page) NULL, (OffsetNumber) 0,
+						 -1 /* size is currently bogus */ , TRUE, FALSE);
+			if (datum[i] != tmpentry.key && !(isAttByVal(&giststate, i)))
 				compvec[i] = TRUE;
 			else
 				compvec[i] = FALSE;
@@ -342,7 +352,7 @@ gistinsert(PG_FUNCTION_ARGS)
 		if (compvec[i] == TRUE)
 			pfree(DatumGetPointer(datum[i]));
 	pfree(itup);
-	freeGISTstate( &giststate );
+	freeGISTstate(&giststate);
 
 	PG_RETURN_POINTER(res);
 }
@@ -376,12 +386,12 @@ gistPageAddItem(GISTSTATE *giststate,
 	 * offset for insertion
 	 */
 	datum = index_getattr(itup, 1, r->rd_att, &IsNull);
-	gistdentryinit(giststate, 0,dentry, datum,
+	gistdentryinit(giststate, 0, dentry, datum,
 				   (Relation) 0, (Page) 0,
 				   (OffsetNumber) InvalidOffsetNumber,
-				   ATTSIZE( datum, r, 1, IsNull ),
+				   ATTSIZE(datum, r, 1, IsNull),
 				   FALSE, IsNull);
-	gistcentryinit(giststate, 0,&tmpcentry, dentry->key, r, page,
+	gistcentryinit(giststate, 0, &tmpcentry, dentry->key, r, page,
 				   offsetNumber, dentry->bytes, FALSE);
 	*newtup = gist_tuple_replacekey(r, tmpcentry, itup);
 	retval = PageAddItem(page, (Item) *newtup, IndexTupleSize(*newtup),
@@ -392,7 +402,7 @@ gistPageAddItem(GISTSTATE *giststate,
 	/* be tidy */
 	if (DatumGetPointer(tmpcentry.key) != NULL &&
 		tmpcentry.key != dentry->key &&
-		tmpcentry.key != datum )
+		tmpcentry.key != datum)
 		pfree(DatumGetPointer(tmpcentry.key));
 	return (retval);
 }
@@ -471,6 +481,7 @@ gistlayerinsert(Relation r, BlockNumber blkno,
 		if (!(ret & SPLITED))
 		{
 			IndexTuple	newtup = gistgetadjusted(r, oldtup, (*itup)[0], giststate);
+
 			if (!newtup)
 			{
 				/* not need to update key */
@@ -492,8 +503,10 @@ gistlayerinsert(Relation r, BlockNumber blkno,
 	if (gistnospace(page, (*itup), *len))
 	{
 		/* no space for insertion */
-		IndexTuple *itvec, *newitup;
-		int tlen,oldlen;
+		IndexTuple *itvec,
+				   *newitup;
+		int			tlen,
+					oldlen;
 
 		ret |= SPLITED;
 		itvec = gistreadbuffer(r, buffer, &tlen);
@@ -503,9 +516,9 @@ gistlayerinsert(Relation r, BlockNumber blkno,
 							(opaque->flags & F_LEAF) ? res : NULL);		/* res only for
 																		 * inserting in leaf */
 		ReleaseBuffer(buffer);
-		do  
-			pfree( (*itup)[ oldlen-1 ] );
-		while ( (--oldlen) > 0 );
+		do
+			pfree((*itup)[oldlen - 1]);
+		while ((--oldlen) > 0);
 		pfree((*itup));
 		pfree(itvec);
 		*itup = newitup;
@@ -539,7 +552,8 @@ gistlayerinsert(Relation r, BlockNumber blkno,
 			 * parent
 			 */
 			IndexTuple	newtup = gistunion(r, (*itup), *len, giststate);
-			ItemPointerSet(&(newtup->t_tid), blkno, 1); 
+
+			ItemPointerSet(&(newtup->t_tid), blkno, 1);
 
 			for (i = 0; i < *len; i++)
 				pfree((*itup)[i]);
@@ -560,10 +574,11 @@ gistwritebuffer(Relation r, Page page, IndexTuple *itup,
 {
 	OffsetNumber l = InvalidOffsetNumber;
 	int			i;
+
 #ifdef GIST_PAGEADDITEM
 	GISTENTRY	tmpdentry;
 	IndexTuple	newtup;
-	bool IsNull;	
+	bool		IsNull;
 #endif
 	for (i = 0; i < len; i++)
 	{
@@ -573,13 +588,13 @@ gistwritebuffer(Relation r, Page page, IndexTuple *itup,
 							off, LP_USED, &tmpdentry, &newtup);
 		off = OffsetNumberNext(off);
 		if (DatumGetPointer(tmpdentry.key) != NULL &&
-			tmpdentry.key != index_getattr(itup[i], 1, r->rd_att, &IsNull))
+		  tmpdentry.key != index_getattr(itup[i], 1, r->rd_att, &IsNull))
 			pfree(DatumGetPointer(tmpdentry.key));
 		if (itup[i] != newtup)
 			pfree(newtup);
 #else
 		l = PageAddItem(page, (Item) itup[i], IndexTupleSize(itup[i]),
-			off, LP_USED);
+						off, LP_USED);
 		if (l == InvalidOffsetNumber)
 			elog(ERROR, "gist: failed to add index item to %s",
 				 RelationGetRelationName(r));
@@ -618,7 +633,7 @@ gistreadbuffer(Relation r, Buffer buffer, int *len /* out */ )
 	*len = maxoff;
 	itvec = palloc(sizeof(IndexTuple) * maxoff);
 	for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
-		itvec[i-1] = (IndexTuple) PageGetItem(p, PageGetItemId(p, i));
+		itvec[i - 1] = (IndexTuple) PageGetItem(p, PageGetItemId(p, i));
 
 	return itvec;
 }
@@ -639,74 +654,85 @@ gistjoinvector(IndexTuple *itvec, int *len, IndexTuple *additvec, int addlen)
  * return union of itup vector
  */
 static IndexTuple
-gistunion(Relation r, IndexTuple *itvec, int len, GISTSTATE *giststate) {
+gistunion(Relation r, IndexTuple *itvec, int len, GISTSTATE *giststate)
+{
 	Datum		attr[INDEX_MAX_KEYS];
-	bool	whatfree[INDEX_MAX_KEYS];
+	bool		whatfree[INDEX_MAX_KEYS];
 	char		isnull[INDEX_MAX_KEYS];
 	bytea	   *evec;
 	Datum		datum;
 	int			datumsize,
-				i,j;
+				i,
+				j;
 	GISTENTRY	centry[INDEX_MAX_KEYS];
-	bool	*needfree;
-	IndexTuple newtup;
-	bool IsNull;
-	int reallen;
+	bool	   *needfree;
+	IndexTuple	newtup;
+	bool		IsNull;
+	int			reallen;
 
-	needfree = (bool *) palloc((( len==1 ) ? 2 : len ) * sizeof(bool));
-	evec =    (bytea *) palloc((( len==1 ) ? 2 : len ) * sizeof(GISTENTRY) + VARHDRSZ);
+	needfree = (bool *) palloc(((len == 1) ? 2 : len) * sizeof(bool));
+	evec = (bytea *) palloc(((len == 1) ? 2 : len) * sizeof(GISTENTRY) + VARHDRSZ);
 
-	for (j = 0; j < r->rd_att->natts; j++) {
-		reallen=0; 
-		for (i = 0; i < len; i++) {
-			datum = index_getattr(itvec[i], j+1, giststate->tupdesc, &IsNull);
-			if ( IsNull ) continue;
+	for (j = 0; j < r->rd_att->natts; j++)
+	{
+		reallen = 0;
+		for (i = 0; i < len; i++)
+		{
+			datum = index_getattr(itvec[i], j + 1, giststate->tupdesc, &IsNull);
+			if (IsNull)
+				continue;
 
 			gistdentryinit(giststate, j,
 						   &((GISTENTRY *) VARDATA(evec))[reallen],
 						   datum,
-						   (Relation) NULL, (Page) NULL, (OffsetNumber) NULL,
-						   ATTSIZE( datum, giststate->tupdesc, j+1, IsNull ), FALSE, IsNull);
-			if ( (!isAttByVal(giststate,j)) &&  
-				  ((GISTENTRY *) VARDATA(evec))[reallen].key != datum ) 
+					   (Relation) NULL, (Page) NULL, (OffsetNumber) NULL,
+						   ATTSIZE(datum, giststate->tupdesc, j + 1, IsNull), FALSE, IsNull);
+			if ((!isAttByVal(giststate, j)) &&
+				((GISTENTRY *) VARDATA(evec))[reallen].key != datum)
 				needfree[reallen] = TRUE;
 			else
 				needfree[reallen] = FALSE;
 			reallen++;
 		}
 
-		if ( reallen == 0 ) {
+		if (reallen == 0)
+		{
 			attr[j] = (Datum) 0;
 			isnull[j] = 'n';
 			whatfree[j] = FALSE;
-		} else {
-			if ( reallen == 1 ) {
+		}
+		else
+		{
+			if (reallen == 1)
+			{
 				VARATT_SIZEP(evec) = 2 * sizeof(GISTENTRY) + VARHDRSZ;
-				gistentryinit(((GISTENTRY *) VARDATA(evec))[1], 
-					((GISTENTRY *) VARDATA(evec))[0].key, r, (Page) NULL, 
-					(OffsetNumber) 0, ((GISTENTRY *) VARDATA(evec))[0].bytes, FALSE);
+				gistentryinit(((GISTENTRY *) VARDATA(evec))[1],
+					((GISTENTRY *) VARDATA(evec))[0].key, r, (Page) NULL,
+							  (OffsetNumber) 0, ((GISTENTRY *) VARDATA(evec))[0].bytes, FALSE);
 
-			} else {
-				VARATT_SIZEP(evec) = reallen * sizeof(GISTENTRY) + VARHDRSZ;
 			}
+			else
+				VARATT_SIZEP(evec) = reallen * sizeof(GISTENTRY) + VARHDRSZ;
 			datum = FunctionCall2(&giststate->unionFn[j],
-							  PointerGetDatum(evec),
-							  PointerGetDatum(&datumsize));
-	
+								  PointerGetDatum(evec),
+								  PointerGetDatum(&datumsize));
+
 			for (i = 0; i < reallen; i++)
-				if ( needfree[i] )
+				if (needfree[i])
 					pfree(DatumGetPointer(((GISTENTRY *) VARDATA(evec))[i].key));
 
 			gistcentryinit(giststate, j, &centry[j], datum,
-				(Relation) NULL, (Page) NULL, (OffsetNumber) NULL,
-				datumsize, FALSE, FALSE);
+					   (Relation) NULL, (Page) NULL, (OffsetNumber) NULL,
+						   datumsize, FALSE, FALSE);
 			isnull[j] = ' ';
-			attr[j] =  centry[j].key;
-			if ( !isAttByVal( giststate, j ) ) {
+			attr[j] = centry[j].key;
+			if (!isAttByVal(giststate, j))
+			{
 				whatfree[j] = TRUE;
-				if ( centry[j].key != datum )
+				if (centry[j].key != datum)
 					pfree(DatumGetPointer(datum));
-			} else 
+			}
+			else
 				whatfree[j] = FALSE;
 		}
 	}
@@ -716,7 +742,7 @@ gistunion(Relation r, IndexTuple *itvec, int len, GISTSTATE *giststate) {
 
 	newtup = (IndexTuple) index_formtuple(giststate->tupdesc, attr, isnull);
 	for (j = 0; j < r->rd_att->natts; j++)
-		if ( whatfree[j] )
+		if (whatfree[j])
 			pfree(DatumGetPointer(attr[j]));
 
 	return newtup;
@@ -732,7 +758,8 @@ gistgetadjusted(Relation r, IndexTuple oldtup, IndexTuple addtup, GISTSTATE *gis
 	bytea	   *evec;
 	Datum		datum;
 	int			datumsize;
-	bool		result, neednew = false;
+	bool		result,
+				neednew = false;
 	char		isnull[INDEX_MAX_KEYS],
 				whatfree[INDEX_MAX_KEYS];
 	Datum		attr[INDEX_MAX_KEYS];
@@ -744,104 +771,125 @@ gistgetadjusted(Relation r, IndexTuple oldtup, IndexTuple addtup, GISTSTATE *gis
 	bool		olddec[INDEX_MAX_KEYS],
 				adddec[INDEX_MAX_KEYS];
 	bool		oldisnull[INDEX_MAX_KEYS],
-			addisnull[INDEX_MAX_KEYS];
+				addisnull[INDEX_MAX_KEYS];
 
 	IndexTuple	newtup = NULL;
-	int j;
+	int			j;
 
 	evec = (bytea *) palloc(2 * sizeof(GISTENTRY) + VARHDRSZ);
 	VARATT_SIZEP(evec) = 2 * sizeof(GISTENTRY) + VARHDRSZ;
 	ev0p = &((GISTENTRY *) VARDATA(evec))[0];
 	ev1p = &((GISTENTRY *) VARDATA(evec))[1];
-	
-	gistDeCompressAtt( giststate, r, oldtup, (Page) NULL, 
-		(OffsetNumber) 0, oldatt, olddec, oldisnull);
 
-	gistDeCompressAtt( giststate, r, addtup, (Page) NULL, 
-		(OffsetNumber) 0, addatt, adddec, addisnull);
+	gistDeCompressAtt(giststate, r, oldtup, (Page) NULL,
+					  (OffsetNumber) 0, oldatt, olddec, oldisnull);
+
+	gistDeCompressAtt(giststate, r, addtup, (Page) NULL,
+					  (OffsetNumber) 0, addatt, adddec, addisnull);
+
 
-		
-	for( j=0; j<r->rd_att->natts; j++ ) {
-		if ( oldisnull[j] && addisnull[j] ) {
+	for (j = 0; j < r->rd_att->natts; j++)
+	{
+		if (oldisnull[j] && addisnull[j])
+		{
 			isnull[j] = 'n';
 			attr[j] = (Datum) 0;
 			whatfree[j] = FALSE;
-		} else {
+		}
+		else
+		{
 			FILLEV(
-				oldisnull[j], oldatt[j].key, oldatt[j].bytes, 
-				addisnull[j], addatt[j].key, addatt[j].bytes
-			);
-	
+				   oldisnull[j], oldatt[j].key, oldatt[j].bytes,
+				   addisnull[j], addatt[j].key, addatt[j].bytes
+				);
+
 			datum = FunctionCall2(&giststate->unionFn[j],
-						  PointerGetDatum(evec),
-						  PointerGetDatum(&datumsize));
+								  PointerGetDatum(evec),
+								  PointerGetDatum(&datumsize));
 
-			if ( oldisnull[j] || addisnull[j] ) {
-				if ( oldisnull[j] )
+			if (oldisnull[j] || addisnull[j])
+			{
+				if (oldisnull[j])
 					neednew = true;
-			} else { 
+			}
+			else
+			{
 				FunctionCall3(&giststate->equalFn[j],
-						  ev0p->key,
-						  datum,
-						  PointerGetDatum(&result));
-		
-				if ( !result ) 
+							  ev0p->key,
+							  datum,
+							  PointerGetDatum(&result));
+
+				if (!result)
 					neednew = true;
 			}
 
-			if ( olddec[j] ) pfree( DatumGetPointer(oldatt[j].key) );
-			if ( adddec[j] ) pfree( DatumGetPointer(addatt[j].key) );
+			if (olddec[j])
+				pfree(DatumGetPointer(oldatt[j].key));
+			if (adddec[j])
+				pfree(DatumGetPointer(addatt[j].key));
 
 			gistcentryinit(giststate, j, &centry[j], datum,
-				(Relation) NULL, (Page) NULL, (OffsetNumber) NULL,
-				datumsize, FALSE, FALSE);
-	
+					   (Relation) NULL, (Page) NULL, (OffsetNumber) NULL,
+						   datumsize, FALSE, FALSE);
+
 			isnull[j] = ' ';
-			attr[j] =  centry[j].key;
-			if ( (!isAttByVal( giststate, j ) ) ) {
+			attr[j] = centry[j].key;
+			if ((!isAttByVal(giststate, j)))
+			{
 				whatfree[j] = TRUE;
-				if ( centry[j].key != datum )
+				if (centry[j].key != datum)
 					pfree(DatumGetPointer(datum));
-			} else
+			}
+			else
 				whatfree[j] = FALSE;
 		}
-	} 
+	}
 	pfree(evec);
 
-	if (neednew) {
+	if (neednew)
+	{
 		/* need to update key */
 		newtup = (IndexTuple) index_formtuple(giststate->tupdesc, attr, isnull);
 		newtup->t_tid = oldtup->t_tid;
 	}
-	
+
 	for (j = 0; j < r->rd_att->natts; j++)
-		if ( whatfree[j] )
+		if (whatfree[j])
 			pfree(DatumGetPointer(attr[j]));
 
 	return newtup;
 }
 
 static void
-gistunionsubkey( Relation r, GISTSTATE *giststate, IndexTuple *itvec, GIST_SPLITVEC * spl ) {
-	int i,j,lr;
+gistunionsubkey(Relation r, GISTSTATE *giststate, IndexTuple *itvec, GIST_SPLITVEC *spl)
+{
+	int			i,
+				j,
+				lr;
 	Datum	   *attr;
-	bool *needfree, IsNull;
-	int len, *attrsize;
-	OffsetNumber	*entries;
-	bytea      *evec;
+	bool	   *needfree,
+				IsNull;
+	int			len,
+			   *attrsize;
+	OffsetNumber *entries;
+	bytea	   *evec;
 	Datum		datum;
-	int datumsize;
-	int reallen;
-	bool	*isnull;
+	int			datumsize;
+	int			reallen;
+	bool	   *isnull;
 
-	for(lr=0;lr<=1;lr++) {	
-		if ( lr ) {
+	for (lr = 0; lr <= 1; lr++)
+	{
+		if (lr)
+		{
 			attrsize = spl->spl_lattrsize;
 			attr = spl->spl_lattr;
 			len = spl->spl_nleft;
 			entries = spl->spl_left;
 			isnull = spl->spl_lisnull;
-		} else {
+		}
+		else
+		{
 			attrsize = spl->spl_rattrsize;
 			attr = spl->spl_rattr;
 			len = spl->spl_nright;
@@ -849,58 +897,64 @@ gistunionsubkey( Relation r, GISTSTATE *giststate, IndexTuple *itvec, GIST_SPLIT
 			isnull = spl->spl_risnull;
 		}
 
-	 	needfree =  (bool *) palloc( (( len==1 ) ? 2 : len ) * sizeof(bool));
-		evec     = (bytea *) palloc( (( len==1 ) ? 2 : len ) * sizeof(GISTENTRY) + VARHDRSZ);
-		for (j = 1; j < r->rd_att->natts; j++) {
+		needfree = (bool *) palloc(((len == 1) ? 2 : len) * sizeof(bool));
+		evec = (bytea *) palloc(((len == 1) ? 2 : len) * sizeof(GISTENTRY) + VARHDRSZ);
+		for (j = 1; j < r->rd_att->natts; j++)
+		{
 			reallen = 0;
-			for (i = 0; i < len; i++) {
-				if ( spl->spl_idgrp[ entries[i] ] )
+			for (i = 0; i < len; i++)
+			{
+				if (spl->spl_idgrp[entries[i]])
 					continue;
-				datum = index_getattr(itvec[ entries[i]-1 ], j+1,
+				datum = index_getattr(itvec[entries[i] - 1], j + 1,
 									  giststate->tupdesc, &IsNull);
-				if ( IsNull )
+				if (IsNull)
 					continue;
 				gistdentryinit(giststate, j,
 							   &((GISTENTRY *) VARDATA(evec))[reallen],
 							   datum,
 							   (Relation) NULL, (Page) NULL,
 							   (OffsetNumber) NULL,
-							   ATTSIZE( datum, giststate->tupdesc, j+1, IsNull ), FALSE, IsNull);
-				if ( (!isAttByVal( giststate, j )) &&
-						((GISTENTRY *) VARDATA(evec))[reallen].key != datum )
+							   ATTSIZE(datum, giststate->tupdesc, j + 1, IsNull), FALSE, IsNull);
+				if ((!isAttByVal(giststate, j)) &&
+					((GISTENTRY *) VARDATA(evec))[reallen].key != datum)
 					needfree[reallen] = TRUE;
 				else
 					needfree[reallen] = FALSE;
 				reallen++;
-			
-			} 
-			if ( reallen == 0 ) 
+
+			}
+			if (reallen == 0)
 			{
 				datum = (Datum) 0;
 				datumsize = 0;
 				isnull[j] = true;
-			} else {
+			}
+			else
+			{
 				/*
-				 * ((GISTENTRY *) VARDATA(evec))[0].bytes may be not defined,
-				 * so form union with itself
+				 * ((GISTENTRY *) VARDATA(evec))[0].bytes may be not
+				 * defined, so form union with itself
 				 */
-				if ( reallen == 1 ) {
+				if (reallen == 1)
+				{
 					VARATT_SIZEP(evec) = 2 * sizeof(GISTENTRY) + VARHDRSZ;
-					memcpy(	(void*) &((GISTENTRY *) VARDATA(evec))[1],
-						(void*) &((GISTENTRY *) VARDATA(evec))[0],
-						sizeof( GISTENTRY ) );
-				} else
+					memcpy((void *) &((GISTENTRY *) VARDATA(evec))[1],
+						   (void *) &((GISTENTRY *) VARDATA(evec))[0],
+						   sizeof(GISTENTRY));
+				}
+				else
 					VARATT_SIZEP(evec) = reallen * sizeof(GISTENTRY) + VARHDRSZ;
 				datum = FunctionCall2(&giststate->unionFn[j],
-								  PointerGetDatum(evec),
-								  PointerGetDatum(&datumsize));
+									  PointerGetDatum(evec),
+									  PointerGetDatum(&datumsize));
 				isnull[j] = false;
-			} 
+			}
 
 			for (i = 0; i < reallen; i++)
-				if ( needfree[i] )
+				if (needfree[i])
 					pfree(DatumGetPointer(((GISTENTRY *) VARDATA(evec))[i].key));
-			
+
 			attr[j] = datum;
 			attrsize[j] = datumsize;
 		}
@@ -910,51 +964,63 @@ gistunionsubkey( Relation r, GISTSTATE *giststate, IndexTuple *itvec, GIST_SPLIT
 }
 
 /*
- * find group in vector with equial value 
+ * find group in vector with equial value
  */
 static int
-gistfindgroup( GISTSTATE *giststate, GISTENTRY *valvec, GIST_SPLITVEC * spl ) {
-	int i,j,len;
-	int curid = 1;
-	bool result;
-
-	/* 
-	 * first key is always not null (see gistinsert),
-	 * so we may not check for nulls
-	 */ 
-          
-	for(i=0; i<spl->spl_nleft; i++) {
-		if ( spl->spl_idgrp[ spl->spl_left[i] ]) continue;
+gistfindgroup(GISTSTATE *giststate, GISTENTRY *valvec, GIST_SPLITVEC *spl)
+{
+	int			i,
+				j,
+				len;
+	int			curid = 1;
+	bool		result;
+
+	/*
+	 * first key is always not null (see gistinsert), so we may not check
+	 * for nulls
+	 */
+
+	for (i = 0; i < spl->spl_nleft; i++)
+	{
+		if (spl->spl_idgrp[spl->spl_left[i]])
+			continue;
 		len = 0;
 		/* find all equal value in right part */
-		for(j=0; j < spl->spl_nright; j++) {
-			if ( spl->spl_idgrp[ spl->spl_right[j] ]) continue;
+		for (j = 0; j < spl->spl_nright; j++)
+		{
+			if (spl->spl_idgrp[spl->spl_right[j]])
+				continue;
 			FunctionCall3(&giststate->equalFn[0],
-						  valvec[ spl->spl_left[i]  ].key,
-						  valvec[ spl->spl_right[j] ].key,
+						  valvec[spl->spl_left[i]].key,
+						  valvec[spl->spl_right[j]].key,
 						  PointerGetDatum(&result));
-			if ( result ) {
-				spl->spl_idgrp[ spl->spl_right[j] ] = curid;
+			if (result)
+			{
+				spl->spl_idgrp[spl->spl_right[j]] = curid;
 				len++;
 			}
 		}
 		/* find all other equal value in left part */
-		if ( len ) {
-			/* add current val to list of equial values*/
-			spl->spl_idgrp[ spl->spl_left[i] ]=curid;
+		if (len)
+		{
+			/* add current val to list of equial values */
+			spl->spl_idgrp[spl->spl_left[i]] = curid;
 			/* searching .. */
-			for(j=i+1; j < spl->spl_nleft; j++) {
-				if ( spl->spl_idgrp[ spl->spl_left[j] ]) continue;
+			for (j = i + 1; j < spl->spl_nleft; j++)
+			{
+				if (spl->spl_idgrp[spl->spl_left[j]])
+					continue;
 				FunctionCall3(&giststate->equalFn[0],
-							  valvec[ spl->spl_left[i]  ].key,
-							  valvec[ spl->spl_left[j]  ].key,
+							  valvec[spl->spl_left[i]].key,
+							  valvec[spl->spl_left[j]].key,
 							  PointerGetDatum(&result));
-				if ( result ) {
-					spl->spl_idgrp[ spl->spl_left[j] ] = curid;
+				if (result)
+				{
+					spl->spl_idgrp[spl->spl_left[j]] = curid;
 					len++;
 				}
 			}
-			spl->spl_ngrp[curid] = len+1;
+			spl->spl_ngrp[curid] = len + 1;
 			curid++;
 		}
 	}
@@ -968,40 +1034,50 @@ gistfindgroup( GISTSTATE *giststate, GISTENTRY *valvec, GIST_SPLITVEC * spl ) {
  */
 static void
 gistadjsubkey(Relation r,
-                  IndexTuple *itup,             /* contains compressed entry */
-                  int *len,
-		  GIST_SPLITVEC *v,
-                  GISTSTATE *giststate
-                  ) {
-	int	curlen;
-	OffsetNumber 	*curwpos;
-	bool decfree[INDEX_MAX_KEYS];
-	GISTENTRY entry,identry[INDEX_MAX_KEYS], *ev0p, *ev1p;
-	float lpenalty, rpenalty;
-	bytea      *evec;
-	int 	datumsize;
-	bool isnull[INDEX_MAX_KEYS];
-	int i,j;
+			  IndexTuple *itup, /* contains compressed entry */
+			  int *len,
+			  GIST_SPLITVEC *v,
+			  GISTSTATE *giststate
+)
+{
+	int			curlen;
+	OffsetNumber *curwpos;
+	bool		decfree[INDEX_MAX_KEYS];
+	GISTENTRY	entry,
+				identry[INDEX_MAX_KEYS],
+			   *ev0p,
+			   *ev1p;
+	float		lpenalty,
+				rpenalty;
+	bytea	   *evec;
+	int			datumsize;
+	bool		isnull[INDEX_MAX_KEYS];
+	int			i,
+				j;
 	Datum		datum;
 
 	/* clear vectors */
 	curlen = v->spl_nleft;
 	curwpos = v->spl_left;
-	for( i=0; i<v->spl_nleft;i++ )
-		if ( v->spl_idgrp[ v->spl_left[i] ] == 0 ) {
+	for (i = 0; i < v->spl_nleft; i++)
+		if (v->spl_idgrp[v->spl_left[i]] == 0)
+		{
 			*curwpos = v->spl_left[i];
 			curwpos++;
-		} else
+		}
+		else
 			curlen--;
 	v->spl_nleft = curlen;
 
 	curlen = v->spl_nright;
 	curwpos = v->spl_right;
-	for( i=0; i<v->spl_nright;i++ )
-		if ( v->spl_idgrp[ v->spl_right[i] ] == 0 ) {
+	for (i = 0; i < v->spl_nright; i++)
+		if (v->spl_idgrp[v->spl_right[i]] == 0)
+		{
 			*curwpos = v->spl_right[i];
 			curwpos++;
-		} else
+		}
+		else
 			curlen--;
 	v->spl_nright = curlen;
 
@@ -1011,82 +1087,98 @@ gistadjsubkey(Relation r,
 	ev1p = &((GISTENTRY *) VARDATA(evec))[1];
 
 	/* add equivalent tuple */
-	for(i = 0; i< *len; i++) {
-		if ( v->spl_idgrp[ i+1 ]==0 ) /* already inserted */
+	for (i = 0; i < *len; i++)
+	{
+		if (v->spl_idgrp[i + 1] == 0)	/* already inserted */
 			continue;
-		gistDeCompressAtt( giststate, r, itup[i], (Page) NULL, (OffsetNumber) 0,
-			identry, decfree, isnull);
+		gistDeCompressAtt(giststate, r, itup[i], (Page) NULL, (OffsetNumber) 0,
+						  identry, decfree, isnull);
 
-		v->spl_ngrp[ v->spl_idgrp[ i+1 ] ]--;
-		if ( v->spl_ngrp[ v->spl_idgrp[ i+1 ] ] == 0 && 
-			(v->spl_grpflag[ v->spl_idgrp[ i+1 ] ] & BOTH_ADDED) != BOTH_ADDED ) {
+		v->spl_ngrp[v->spl_idgrp[i + 1]]--;
+		if (v->spl_ngrp[v->spl_idgrp[i + 1]] == 0 &&
+		(v->spl_grpflag[v->spl_idgrp[i + 1]] & BOTH_ADDED) != BOTH_ADDED)
+		{
 
 			/* force last in group */
 			rpenalty = 1.0;
-			lpenalty = ( v->spl_grpflag[ v->spl_idgrp[ i+1 ] ] & LEFT_ADDED ) ? 2.0 : 0.0;
-		} else { 
-			/*where?*/
-			for( j=1; j<r->rd_att->natts; j++ ) {
-				gistentryinit(entry,v->spl_lattr[j], r, (Page) NULL,
-					(OffsetNumber) 0, v->spl_lattrsize[j], FALSE);
-				gistpenalty( giststate, j, &entry, v->spl_lisnull[j], 
-					&identry[j], isnull[j], &lpenalty); 
-
-				gistentryinit(entry,v->spl_rattr[j], r, (Page) NULL,
-					(OffsetNumber) 0, v->spl_rattrsize[j], FALSE);
-				gistpenalty( giststate, j, &entry, v->spl_risnull[j], 
-					&identry[j], isnull[j], &rpenalty); 
-
-				if ( lpenalty != rpenalty ) 
+			lpenalty = (v->spl_grpflag[v->spl_idgrp[i + 1]] & LEFT_ADDED) ? 2.0 : 0.0;
+		}
+		else
+		{
+			/* where? */
+			for (j = 1; j < r->rd_att->natts; j++)
+			{
+				gistentryinit(entry, v->spl_lattr[j], r, (Page) NULL,
+						   (OffsetNumber) 0, v->spl_lattrsize[j], FALSE);
+				gistpenalty(giststate, j, &entry, v->spl_lisnull[j],
+							&identry[j], isnull[j], &lpenalty);
+
+				gistentryinit(entry, v->spl_rattr[j], r, (Page) NULL,
+						   (OffsetNumber) 0, v->spl_rattrsize[j], FALSE);
+				gistpenalty(giststate, j, &entry, v->spl_risnull[j],
+							&identry[j], isnull[j], &rpenalty);
+
+				if (lpenalty != rpenalty)
 					break;
 			}
 		}
 		/* add */
-		if ( lpenalty < rpenalty ) {
-			v->spl_grpflag[ v->spl_idgrp[ i+1 ] ] |= LEFT_ADDED;
-			v->spl_left[ v->spl_nleft ] = i+1;
+		if (lpenalty < rpenalty)
+		{
+			v->spl_grpflag[v->spl_idgrp[i + 1]] |= LEFT_ADDED;
+			v->spl_left[v->spl_nleft] = i + 1;
 			v->spl_nleft++;
-			for( j=1; j<r->rd_att->natts; j++ ) {
-				if ( isnull[j] && v->spl_lisnull[j] ) {
+			for (j = 1; j < r->rd_att->natts; j++)
+			{
+				if (isnull[j] && v->spl_lisnull[j])
+				{
 					v->spl_lattr[j] = (Datum) 0;
 					v->spl_lattrsize[j] = 0;
-				} else {
+				}
+				else
+				{
 					FILLEV(
-						v->spl_lisnull[j], v->spl_lattr[j], v->spl_lattrsize[j], 
-						isnull[j], identry[j].key, identry[j].bytes
-					);
+						   v->spl_lisnull[j], v->spl_lattr[j], v->spl_lattrsize[j],
+						   isnull[j], identry[j].key, identry[j].bytes
+						);
 
 					datum = FunctionCall2(&giststate->unionFn[j],
-									  PointerGetDatum(evec),
-									  PointerGetDatum(&datumsize));
+										  PointerGetDatum(evec),
+										  PointerGetDatum(&datumsize));
 
-					if ( (!isAttByVal( giststate, j )) && !v->spl_lisnull[j] )
-						pfree( DatumGetPointer(v->spl_lattr[j]) );
+					if ((!isAttByVal(giststate, j)) && !v->spl_lisnull[j])
+						pfree(DatumGetPointer(v->spl_lattr[j]));
 					v->spl_lattr[j] = datum;
 					v->spl_lattrsize[j] = datumsize;
 					v->spl_lisnull[j] = false;
 				}
 			}
-		} else {
-			v->spl_grpflag[ v->spl_idgrp[ i+1 ] ] |= RIGHT_ADDED;
-			v->spl_right[ v->spl_nright ] = i+1;
+		}
+		else
+		{
+			v->spl_grpflag[v->spl_idgrp[i + 1]] |= RIGHT_ADDED;
+			v->spl_right[v->spl_nright] = i + 1;
 			v->spl_nright++;
-			for( j=1; j<r->rd_att->natts; j++ ) {
-				if ( isnull[j] && v->spl_risnull[j] ) {
+			for (j = 1; j < r->rd_att->natts; j++)
+			{
+				if (isnull[j] && v->spl_risnull[j])
+				{
 					v->spl_rattr[j] = (Datum) 0;
 					v->spl_rattrsize[j] = 0;
-				} else {
+				}
+				else
+				{
 					FILLEV(
-						v->spl_risnull[j], v->spl_rattr[j], v->spl_rattrsize[j], 
-						isnull[j], identry[j].key, identry[j].bytes
-					);
+						   v->spl_risnull[j], v->spl_rattr[j], v->spl_rattrsize[j],
+						   isnull[j], identry[j].key, identry[j].bytes
+						);
 
 					datum = FunctionCall2(&giststate->unionFn[j],
-									  PointerGetDatum(evec),
-									  PointerGetDatum(&datumsize));
+										  PointerGetDatum(evec),
+										  PointerGetDatum(&datumsize));
 
-					if ( (!isAttByVal( giststate, j)) && !v->spl_risnull[j] )
-						pfree( DatumGetPointer(v->spl_rattr[j]) );
+					if ((!isAttByVal(giststate, j)) && !v->spl_risnull[j])
+						pfree(DatumGetPointer(v->spl_rattr[j]));
 
 					v->spl_rattr[j] = datum;
 					v->spl_rattrsize[j] = datumsize;
@@ -1094,8 +1186,8 @@ gistadjsubkey(Relation r,
 				}
 			}
 
-		} 
-		gistFreeAtt( r, identry, decfree );
+		}
+		gistFreeAtt(r, identry, decfree);
 	}
 	pfree(evec);
 }
@@ -1125,11 +1217,12 @@ gistSplit(Relation r,
 	GIST_SPLITVEC v;
 	bytea	   *entryvec;
 	bool	   *decompvec;
-	int			i,j,
+	int			i,
+				j,
 				nlen;
-	int MaxGrpId	= 1;
+	int			MaxGrpId = 1;
 	Datum		datum;
-	bool IsNull;
+	bool		IsNull;
 
 	p = (Page) BufferGetPage(buffer);
 	opaque = (GISTPageOpaque) PageGetSpecialPointer(p);
@@ -1168,57 +1261,62 @@ gistSplit(Relation r,
 	for (i = 1; i <= *len; i++)
 	{
 		datum = index_getattr(itup[i - 1], 1, giststate->tupdesc, &IsNull);
-		gistdentryinit(giststate, 0,&((GISTENTRY *) VARDATA(entryvec))[i],
-					datum, r, p, i,
-					ATTSIZE( datum, giststate->tupdesc, 1, IsNull ), FALSE, IsNull);
-		if ( (!isAttByVal(giststate,0)) && ((GISTENTRY *) VARDATA(entryvec))[i].key != datum )  
+		gistdentryinit(giststate, 0, &((GISTENTRY *) VARDATA(entryvec))[i],
+					   datum, r, p, i,
+		   ATTSIZE(datum, giststate->tupdesc, 1, IsNull), FALSE, IsNull);
+		if ((!isAttByVal(giststate, 0)) && ((GISTENTRY *) VARDATA(entryvec))[i].key != datum)
 			decompvec[i] = TRUE;
 		else
 			decompvec[i] = FALSE;
 	}
 
-	/* now let the user-defined picksplit function set up the split vector;
-          in entryvec have no null value!! */
+	/*
+	 * now let the user-defined picksplit function set up the split
+	 * vector; in entryvec have no null value!!
+	 */
 	FunctionCall2(&giststate->picksplitFn[0],
 				  PointerGetDatum(entryvec),
 				  PointerGetDatum(&v));
 
-	/* compatibility with old code */	
-	if ( v.spl_left[ v.spl_nleft-1 ] == InvalidOffsetNumber ) 
-		v.spl_left[ v.spl_nleft-1 ] = (OffsetNumber)*len;
-	if ( v.spl_right[ v.spl_nright-1 ] == InvalidOffsetNumber ) 
-		v.spl_right[ v.spl_nright-1 ] = (OffsetNumber)*len;
-	
-	v.spl_lattr[0] = v.spl_ldatum; 
+	/* compatibility with old code */
+	if (v.spl_left[v.spl_nleft - 1] == InvalidOffsetNumber)
+		v.spl_left[v.spl_nleft - 1] = (OffsetNumber) *len;
+	if (v.spl_right[v.spl_nright - 1] == InvalidOffsetNumber)
+		v.spl_right[v.spl_nright - 1] = (OffsetNumber) *len;
+
+	v.spl_lattr[0] = v.spl_ldatum;
 	v.spl_rattr[0] = v.spl_rdatum;
 	v.spl_lisnull[0] = false;
 	v.spl_risnull[0] = false;
 
-	/* if index is multikey, then we must to try get smaller
-	 * bounding box for subkey(s)
-         */
-	if ( r->rd_att->natts > 1 ) {
-		v.spl_idgrp  = (int*) palloc( sizeof(int) * (*len + 1) );
-		MemSet((void*)v.spl_idgrp, 0, sizeof(int) * (*len + 1) );
-		v.spl_grpflag = (char*) palloc( sizeof(char) * (*len + 1) );
-		MemSet((void*)v.spl_grpflag, 0, sizeof(char) * (*len + 1) );
-		v.spl_ngrp    = (int*) palloc( sizeof(int) * (*len + 1) );
+	/*
+	 * if index is multikey, then we must to try get smaller bounding box
+	 * for subkey(s)
+	 */
+	if (r->rd_att->natts > 1)
+	{
+		v.spl_idgrp = (int *) palloc(sizeof(int) * (*len + 1));
+		MemSet((void *) v.spl_idgrp, 0, sizeof(int) * (*len + 1));
+		v.spl_grpflag = (char *) palloc(sizeof(char) * (*len + 1));
+		MemSet((void *) v.spl_grpflag, 0, sizeof(char) * (*len + 1));
+		v.spl_ngrp = (int *) palloc(sizeof(int) * (*len + 1));
 
-		MaxGrpId = gistfindgroup( giststate, (GISTENTRY *) VARDATA(entryvec), &v );
+		MaxGrpId = gistfindgroup(giststate, (GISTENTRY *) VARDATA(entryvec), &v);
 
 		/* form union of sub keys for each page (l,p) */
-		gistunionsubkey( r, giststate, itup, &v );
+		gistunionsubkey(r, giststate, itup, &v);
 
-		/* if possible, we insert equivalent tuples
-		 * with control by penalty for a subkey(s)
-                 */
-		if ( MaxGrpId > 1 )
-			gistadjsubkey( r,itup,len, &v, giststate );
+		/*
+		 * if possible, we insert equivalent tuples with control by
+		 * penalty for a subkey(s)
+		 */
+		if (MaxGrpId > 1)
+			gistadjsubkey(r, itup, len, &v, giststate);
 
-		pfree( v.spl_idgrp );
-		pfree( v.spl_grpflag );
-		pfree( v.spl_ngrp );
-	} 
+		pfree(v.spl_idgrp);
+		pfree(v.spl_grpflag);
+		pfree(v.spl_ngrp);
+	}
 
 	/* clean up the entry vector: its keys need to be deleted, too */
 	for (i = 1; i <= *len; i++)
@@ -1231,11 +1329,11 @@ gistSplit(Relation r,
 	lvectup = (IndexTuple *) palloc(sizeof(IndexTuple) * v.spl_nleft);
 	rvectup = (IndexTuple *) palloc(sizeof(IndexTuple) * v.spl_nright);
 
-	for(i=0; i<v.spl_nleft;i++) 
-		lvectup[i] = itup[ v.spl_left[i] - 1 ];
+	for (i = 0; i < v.spl_nleft; i++)
+		lvectup[i] = itup[v.spl_left[i] - 1];
 
-	for(i=0; i<v.spl_nright;i++) 
-		rvectup[i] = itup[ v.spl_right[i] - 1 ];
+	for (i = 0; i < v.spl_nright; i++)
+		rvectup[i] = itup[v.spl_right[i] - 1];
 
 
 	/* write on disk (may be need another split) */
@@ -1245,9 +1343,9 @@ gistSplit(Relation r,
 		newtup = gistSplit(r, rightbuf, rvectup, &nlen, giststate,
 			  (res && rvectup[nlen - 1] == itup[*len - 1]) ? res : NULL);
 		ReleaseBuffer(rightbuf);
-		for( j=1; j<r->rd_att->natts; j++ ) 
-			if ( (!isAttByVal(giststate,j)) && !v.spl_risnull[j] )
-				pfree( DatumGetPointer(v.spl_rattr[j]) ); 
+		for (j = 1; j < r->rd_att->natts; j++)
+			if ((!isAttByVal(giststate, j)) && !v.spl_risnull[j])
+				pfree(DatumGetPointer(v.spl_rattr[j]));
 	}
 	else
 	{
@@ -1261,7 +1359,7 @@ gistSplit(Relation r,
 
 		nlen = 1;
 		newtup = (IndexTuple *) palloc(sizeof(IndexTuple) * 1);
-		newtup[0] = gistFormTuple( giststate, r, v.spl_rattr, v.spl_rattrsize, v.spl_risnull ); 
+		newtup[0] = gistFormTuple(giststate, r, v.spl_rattr, v.spl_rattrsize, v.spl_risnull);
 		ItemPointerSet(&(newtup[0]->t_tid), rbknum, 1);
 	}
 
@@ -1275,9 +1373,9 @@ gistSplit(Relation r,
 			  (res && lvectup[llen - 1] == itup[*len - 1]) ? res : NULL);
 		ReleaseBuffer(leftbuf);
 
-		for( j=1; j<r->rd_att->natts; j++ ) 
-			if ( (!isAttByVal(giststate,j)) && !v.spl_lisnull[j] )
-				pfree( DatumGetPointer(v.spl_lattr[j]) ); 
+		for (j = 1; j < r->rd_att->natts; j++)
+			if ((!isAttByVal(giststate, j)) && !v.spl_lisnull[j])
+				pfree(DatumGetPointer(v.spl_lattr[j]));
 
 		newtup = gistjoinvector(newtup, &nlen, lntup, llen);
 		pfree(lntup);
@@ -1297,7 +1395,7 @@ gistSplit(Relation r,
 
 		nlen += 1;
 		newtup = (IndexTuple *) repalloc((void *) newtup, sizeof(IndexTuple) * nlen);
-		newtup[nlen - 1] = gistFormTuple( giststate, r, v.spl_lattr, v.spl_lattrsize, v.spl_lisnull );
+		newtup[nlen - 1] = gistFormTuple(giststate, r, v.spl_lattr, v.spl_lattrsize, v.spl_lisnull);
 		ItemPointerSet(&(newtup[nlen - 1]->t_tid), lbknum, 1);
 	}
 
@@ -1359,47 +1457,56 @@ gistchoose(Relation r, Page p, IndexTuple it,	/* it has compressed entry */
 	Datum		datum;
 	float		usize;
 	OffsetNumber which;
-	float		sum_grow, which_grow[INDEX_MAX_KEYS];
+	float		sum_grow,
+				which_grow[INDEX_MAX_KEYS];
 	GISTENTRY	entry,
 				identry[INDEX_MAX_KEYS];
-	bool IsNull, decompvec[INDEX_MAX_KEYS], isnull[INDEX_MAX_KEYS];
-	int j;
+	bool		IsNull,
+				decompvec[INDEX_MAX_KEYS],
+				isnull[INDEX_MAX_KEYS];
+	int			j;
 
 	maxoff = PageGetMaxOffsetNumber(p);
 	*which_grow = -1.0;
 	which = -1;
-	sum_grow=1;
-	gistDeCompressAtt( giststate, r, 
-                                it, (Page) NULL, (OffsetNumber) 0, 
-                                identry, decompvec, isnull );
+	sum_grow = 1;
+	gistDeCompressAtt(giststate, r,
+					  it, (Page) NULL, (OffsetNumber) 0,
+					  identry, decompvec, isnull);
 
 	for (i = FirstOffsetNumber; i <= maxoff && sum_grow; i = OffsetNumberNext(i))
 	{
-		IndexTuple itup = (IndexTuple) PageGetItem(p, PageGetItemId(p, i));
-		sum_grow=0;
-		for (j=0; j<r->rd_att->natts; j++) {
-			datum = index_getattr(itup, j+1, giststate->tupdesc, &IsNull);
-			gistdentryinit(giststate, j, &entry, datum, r, p, i, ATTSIZE( datum, giststate->tupdesc, j+1, IsNull ), FALSE, IsNull);
-			gistpenalty( giststate, j, &entry, IsNull, &identry[j], isnull[j], &usize); 
-
-			if ( (!isAttByVal(giststate,j)) && entry.key != datum) 
+		IndexTuple	itup = (IndexTuple) PageGetItem(p, PageGetItemId(p, i));
+
+		sum_grow = 0;
+		for (j = 0; j < r->rd_att->natts; j++)
+		{
+			datum = index_getattr(itup, j + 1, giststate->tupdesc, &IsNull);
+			gistdentryinit(giststate, j, &entry, datum, r, p, i, ATTSIZE(datum, giststate->tupdesc, j + 1, IsNull), FALSE, IsNull);
+			gistpenalty(giststate, j, &entry, IsNull, &identry[j], isnull[j], &usize);
+
+			if ((!isAttByVal(giststate, j)) && entry.key != datum)
 				pfree(DatumGetPointer(entry.key));
 
-			if ( which_grow[j]<0 || usize < which_grow[j] ) {
+			if (which_grow[j] < 0 || usize < which_grow[j])
+			{
 				which = i;
 				which_grow[j] = usize;
-				if ( j<r->rd_att->natts-1 && i==FirstOffsetNumber ) which_grow[j+1]=-1;
-				sum_grow += which_grow[j]; 
-			} else if ( which_grow[j] == usize )  {
+				if (j < r->rd_att->natts - 1 && i == FirstOffsetNumber)
+					which_grow[j + 1] = -1;
+				sum_grow += which_grow[j];
+			}
+			else if (which_grow[j] == usize)
 				sum_grow += usize;
-			} else {
-				sum_grow=1;
+			else
+			{
+				sum_grow = 1;
 				break;
 			}
 		}
 	}
 
-	gistFreeAtt( r, identry, decompvec );
+	gistFreeAtt(r, identry, decompvec);
 	return which;
 }
 
@@ -1434,7 +1541,7 @@ gistdelete(Relation r, ItemPointer tid)
 
 	/*
 	 * Since GIST is not marked "amconcurrent" in pg_am, caller should
-	 * have acquired exclusive lock on index relation.  We need no locking
+	 * have acquired exclusive lock on index relation.	We need no locking
 	 * here.
 	 */
 
@@ -1468,7 +1575,7 @@ gistbulkdelete(PG_FUNCTION_ARGS)
 	IndexBulkDeleteCallback callback = (IndexBulkDeleteCallback) PG_GETARG_POINTER(1);
 	void	   *callback_state = (void *) PG_GETARG_POINTER(2);
 	IndexBulkDeleteResult *result;
-	BlockNumber	num_pages;
+	BlockNumber num_pages;
 	double		tuples_removed;
 	double		num_index_tuples;
 	RetrieveIndexResult res;
@@ -1479,7 +1586,7 @@ gistbulkdelete(PG_FUNCTION_ARGS)
 
 	/*
 	 * Since GIST is not marked "amconcurrent" in pg_am, caller should
-	 * have acquired exclusive lock on index relation.  We need no locking
+	 * have acquired exclusive lock on index relation.	We need no locking
 	 * here.
 	 */
 
@@ -1542,7 +1649,7 @@ gistbulkdelete(PG_FUNCTION_ARGS)
 void
 initGISTstate(GISTSTATE *giststate, Relation index)
 {
-	int i;
+	int			i;
 
 	if (index->rd_att->natts > INDEX_MAX_KEYS)
 		elog(ERROR, "initGISTstate: numberOfAttributes %d > %d",
@@ -1553,31 +1660,32 @@ initGISTstate(GISTSTATE *giststate, Relation index)
 	for (i = 0; i < index->rd_att->natts; i++)
 	{
 		fmgr_info_copy(&(giststate->consistentFn[i]),
-					   index_getprocinfo(index, i+1, GIST_CONSISTENT_PROC),
+				   index_getprocinfo(index, i + 1, GIST_CONSISTENT_PROC),
 					   CurrentMemoryContext);
 		fmgr_info_copy(&(giststate->unionFn[i]),
-					   index_getprocinfo(index, i+1, GIST_UNION_PROC),
+					   index_getprocinfo(index, i + 1, GIST_UNION_PROC),
 					   CurrentMemoryContext);
 		fmgr_info_copy(&(giststate->compressFn[i]),
-					   index_getprocinfo(index, i+1, GIST_COMPRESS_PROC),
+					 index_getprocinfo(index, i + 1, GIST_COMPRESS_PROC),
 					   CurrentMemoryContext);
 		fmgr_info_copy(&(giststate->decompressFn[i]),
-					   index_getprocinfo(index, i+1, GIST_DECOMPRESS_PROC),
+				   index_getprocinfo(index, i + 1, GIST_DECOMPRESS_PROC),
 					   CurrentMemoryContext);
 		fmgr_info_copy(&(giststate->penaltyFn[i]),
-					   index_getprocinfo(index, i+1, GIST_PENALTY_PROC),
+					   index_getprocinfo(index, i + 1, GIST_PENALTY_PROC),
 					   CurrentMemoryContext);
 		fmgr_info_copy(&(giststate->picksplitFn[i]),
-					   index_getprocinfo(index, i+1, GIST_PICKSPLIT_PROC),
+					index_getprocinfo(index, i + 1, GIST_PICKSPLIT_PROC),
 					   CurrentMemoryContext);
 		fmgr_info_copy(&(giststate->equalFn[i]),
-					   index_getprocinfo(index, i+1, GIST_EQUAL_PROC),
+					   index_getprocinfo(index, i + 1, GIST_EQUAL_PROC),
 					   CurrentMemoryContext);
 	}
 }
 
 void
-freeGISTstate(GISTSTATE *giststate) {
+freeGISTstate(GISTSTATE *giststate)
+{
 	/* no work */
 }
 
@@ -1592,13 +1700,14 @@ freeGISTstate(GISTSTATE *giststate) {
 static IndexTuple
 gist_tuple_replacekey(Relation r, GISTENTRY entry, IndexTuple t)
 {
-	bool IsNull;
-	Datum	datum = index_getattr(t, 1, r->rd_att, &IsNull);
+	bool		IsNull;
+	Datum		datum = index_getattr(t, 1, r->rd_att, &IsNull);
 
 	/*
 	 * If new entry fits in index tuple, copy it in.  To avoid worrying
-	 * about null-value bitmask, pass it off to the general index_formtuple
-	 * routine if either the previous or new value is NULL.
+	 * about null-value bitmask, pass it off to the general
+	 * index_formtuple routine if either the previous or new value is
+	 * NULL.
 	 */
 	if (!IsNull && DatumGetPointer(entry.key) != NULL &&
 		(Size) entry.bytes <= ATTSIZE(datum, r, 1, IsNull))
@@ -1638,7 +1747,7 @@ gistdentryinit(GISTSTATE *giststate, int nkey, GISTENTRY *e,
 			   Datum k, Relation r, Page pg, OffsetNumber o,
 			   int b, bool l, bool isNull)
 {
-	if ( b && ! isNull )
+	if (b && !isNull)
 	{
 		GISTENTRY  *dep;
 
@@ -1655,9 +1764,7 @@ gistdentryinit(GISTSTATE *giststate, int nkey, GISTENTRY *e,
 		}
 	}
 	else
-	{
 		gistentryinit(*e, (Datum) 0, r, pg, o, 0, l);
-	}
 }
 
 
@@ -1686,92 +1793,103 @@ gistcentryinit(GISTSTATE *giststate, int nkey,
 		}
 	}
 	else
-	{
 		gistentryinit(*e, (Datum) 0, r, pg, o, 0, l);
-	}
 }
 
 static IndexTuple
-gistFormTuple( GISTSTATE *giststate, Relation r,
-			   Datum attdata[], int datumsize[], bool isnull[] )
+gistFormTuple(GISTSTATE *giststate, Relation r,
+			  Datum attdata[], int datumsize[], bool isnull[])
 {
 	IndexTuple	tup;
-	char            isnullchar[INDEX_MAX_KEYS];
-	bool    whatfree[INDEX_MAX_KEYS];
-	GISTENTRY       centry[INDEX_MAX_KEYS];
-	Datum	compatt[INDEX_MAX_KEYS];
-	int j;
-	
-	for (j = 0; j < r->rd_att->natts; j++) {
-		if ( isnull[j] ) {
+	char		isnullchar[INDEX_MAX_KEYS];
+	bool		whatfree[INDEX_MAX_KEYS];
+	GISTENTRY	centry[INDEX_MAX_KEYS];
+	Datum		compatt[INDEX_MAX_KEYS];
+	int			j;
+
+	for (j = 0; j < r->rd_att->natts; j++)
+	{
+		if (isnull[j])
+		{
 			isnullchar[j] = 'n';
 			compatt[j] = (Datum) 0;
 			whatfree[j] = FALSE;
-		} else {
+		}
+		else
+		{
 			gistcentryinit(giststate, j, &centry[j], attdata[j],
-				(Relation) NULL, (Page) NULL, (OffsetNumber) NULL,
-				datumsize[j], FALSE, FALSE);
+					   (Relation) NULL, (Page) NULL, (OffsetNumber) NULL,
+						   datumsize[j], FALSE, FALSE);
 			isnullchar[j] = ' ';
 			compatt[j] = centry[j].key;
-			if ( !isAttByVal(giststate,j) ) {
+			if (!isAttByVal(giststate, j))
+			{
 				whatfree[j] = TRUE;
-				if ( centry[j].key != attdata[j] )
+				if (centry[j].key != attdata[j])
 					pfree(DatumGetPointer(attdata[j]));
-			} else
+			}
+			else
 				whatfree[j] = FALSE;
 		}
 	}
 
 	tup = (IndexTuple) index_formtuple(giststate->tupdesc, compatt, isnullchar);
 	for (j = 0; j < r->rd_att->natts; j++)
-		if ( whatfree[j] ) pfree(DatumGetPointer(compatt[j]));
+		if (whatfree[j])
+			pfree(DatumGetPointer(compatt[j]));
 
-	return  tup;
-}  
+	return tup;
+}
 
 static void
-gistDeCompressAtt( GISTSTATE *giststate, Relation r, IndexTuple tuple, Page p, 
-			OffsetNumber o, GISTENTRY attdata[], bool decompvec[], bool isnull[] ) {
-	int i;
-	Datum	datum;
+gistDeCompressAtt(GISTSTATE *giststate, Relation r, IndexTuple tuple, Page p,
+	OffsetNumber o, GISTENTRY attdata[], bool decompvec[], bool isnull[])
+{
+	int			i;
+	Datum		datum;
 
-	for(i=0; i < r->rd_att->natts; i++ ) {
-		datum = index_getattr(tuple, i+1, giststate->tupdesc, &isnull[i]);
+	for (i = 0; i < r->rd_att->natts; i++)
+	{
+		datum = index_getattr(tuple, i + 1, giststate->tupdesc, &isnull[i]);
 		gistdentryinit(giststate, i, &attdata[i],
-					datum, r, p, o,
-					ATTSIZE( datum, giststate->tupdesc, i+1, isnull[i] ), FALSE, isnull[i]);
-		if ( isAttByVal(giststate,i) ) 
+					   datum, r, p, o,
+					   ATTSIZE(datum, giststate->tupdesc, i + 1, isnull[i]), FALSE, isnull[i]);
+		if (isAttByVal(giststate, i))
 			decompvec[i] = FALSE;
-		else {
-			if (attdata[i].key == datum || isnull[i] )
+		else
+		{
+			if (attdata[i].key == datum || isnull[i])
 				decompvec[i] = FALSE;
 			else
 				decompvec[i] = TRUE;
 		}
 	}
-} 
+}
 
 static void
-gistFreeAtt(  Relation r, GISTENTRY attdata[], bool decompvec[] ) {
-	int i;
-	for(i=0; i < r->rd_att->natts; i++ )
-		if ( decompvec[i] )
-			pfree( DatumGetPointer(attdata[i].key) );
+gistFreeAtt(Relation r, GISTENTRY attdata[], bool decompvec[])
+{
+	int			i;
+
+	for (i = 0; i < r->rd_att->natts; i++)
+		if (decompvec[i])
+			pfree(DatumGetPointer(attdata[i].key));
 }
 
 static void
-gistpenalty( GISTSTATE *giststate, int attno, 
-		GISTENTRY *key1, bool isNull1, 
-		GISTENTRY *key2, bool isNull2, float *penalty ){
-	if ( giststate->penaltyFn[attno].fn_strict && ( isNull1 || isNull2 ) )
-		*penalty=0.0;
-	else  
+gistpenalty(GISTSTATE *giststate, int attno,
+			GISTENTRY *key1, bool isNull1,
+			GISTENTRY *key2, bool isNull2, float *penalty)
+{
+	if (giststate->penaltyFn[attno].fn_strict && (isNull1 || isNull2))
+		*penalty = 0.0;
+	else
 		FunctionCall3(&giststate->penaltyFn[attno],
-				  PointerGetDatum(key1),
-				  PointerGetDatum(key2),
-				  PointerGetDatum(penalty));
+					  PointerGetDatum(key1),
+					  PointerGetDatum(key2),
+					  PointerGetDatum(penalty));
 }
- 
+
 #ifdef GISTDEBUG
 static void
 gist_dumptree(Relation r, int level, BlockNumber blk, OffsetNumber coff)
@@ -1816,7 +1934,6 @@ gist_dumptree(Relation r, int level, BlockNumber blk, OffsetNumber coff)
 	ReleaseBuffer(buffer);
 	pfree(pred);
 }
-
 #endif	 /* defined GISTDEBUG */
 
 void