diff options
| author | Bruce Momjian | 2004-08-29 05:07:03 +0000 |
|---|---|---|
| committer | Bruce Momjian | 2004-08-29 05:07:03 +0000 |
| commit | 553f27a8368adec5f62207e963f08d47e73dbdc9 (patch) | |
| tree | b563582288ca79e4d8ff7b7b18a3e416996347d1 | |
| parent | 22d07c998e406c1282a5099ba2bf73b0480a0f2e (diff) | |
Pgindent run for 8.0.
527 files changed, 20262 insertions, 17995 deletions
diff --git a/contrib/btree_gist/btree_bit.c b/contrib/btree_gist/btree_bit.c index 138418a30e..0b220ae2bb 100644 --- a/contrib/btree_gist/btree_bit.c +++ b/contrib/btree_gist/btree_bit.c @@ -14,92 +14,99 @@ PG_FUNCTION_INFO_V1(gbt_bit_consistent); PG_FUNCTION_INFO_V1(gbt_bit_penalty); PG_FUNCTION_INFO_V1(gbt_bit_same); -Datum gbt_bit_compress(PG_FUNCTION_ARGS); -Datum gbt_bit_union(PG_FUNCTION_ARGS); -Datum gbt_bit_picksplit(PG_FUNCTION_ARGS); -Datum gbt_bit_consistent(PG_FUNCTION_ARGS); -Datum gbt_bit_penalty(PG_FUNCTION_ARGS); -Datum gbt_bit_same(PG_FUNCTION_ARGS); +Datum gbt_bit_compress(PG_FUNCTION_ARGS); +Datum gbt_bit_union(PG_FUNCTION_ARGS); +Datum gbt_bit_picksplit(PG_FUNCTION_ARGS); +Datum gbt_bit_consistent(PG_FUNCTION_ARGS); +Datum gbt_bit_penalty(PG_FUNCTION_ARGS); +Datum gbt_bit_same(PG_FUNCTION_ARGS); /* define for comparison */ -static bool gbt_bitgt (const void *a, const void *b) +static bool +gbt_bitgt(const void *a, const void *b) { - return ( DatumGetBool(DirectFunctionCall2( bitgt ,PointerGetDatum( a ),PointerGetDatum( b ) ) ) ); + return (DatumGetBool(DirectFunctionCall2(bitgt, PointerGetDatum(a), PointerGetDatum(b)))); } -static bool gbt_bitge (const void *a, const void *b) +static bool +gbt_bitge(const void *a, const void *b) { - return ( DatumGetBool(DirectFunctionCall2( bitge ,PointerGetDatum( a ),PointerGetDatum( b ) ) ) ); + return (DatumGetBool(DirectFunctionCall2(bitge, PointerGetDatum(a), PointerGetDatum(b)))); } -static bool gbt_biteq (const void *a, const void *b) +static bool +gbt_biteq(const void *a, const void *b) { - return ( DatumGetBool(DirectFunctionCall2( biteq ,PointerGetDatum( a ),PointerGetDatum( b ) ) ) ); + return (DatumGetBool(DirectFunctionCall2(biteq, PointerGetDatum(a), PointerGetDatum(b)))); } -static bool gbt_bitle (const void *a, const void *b) +static bool +gbt_bitle(const void *a, const void *b) { - return ( DatumGetBool(DirectFunctionCall2( bitle ,PointerGetDatum( a ),PointerGetDatum( b ) ) ) ); + return (DatumGetBool(DirectFunctionCall2(bitle, PointerGetDatum(a), PointerGetDatum(b)))); } -static bool gbt_bitlt (const void *a, const void *b) +static bool +gbt_bitlt(const void *a, const void *b) { - return ( DatumGetBool(DirectFunctionCall2( bitlt ,PointerGetDatum( a ),PointerGetDatum( b ) ) ) ); + return (DatumGetBool(DirectFunctionCall2(bitlt, PointerGetDatum(a), PointerGetDatum(b)))); } -static int32 gbt_bitcmp ( const bytea * a , const bytea * b ) +static int32 +gbt_bitcmp(const bytea *a, const bytea *b) { - return - ( DatumGetInt32(DirectFunctionCall2(byteacmp,PointerGetDatum(a),PointerGetDatum(b) ) ) ); + return + (DatumGetInt32(DirectFunctionCall2(byteacmp, PointerGetDatum(a), PointerGetDatum(b)))); } - + static bytea * -gbt_bit_xfrm ( bytea * leaf ) +gbt_bit_xfrm(bytea *leaf) { - bytea * out = leaf; - int s = VARBITBYTES(leaf) + VARHDRSZ; + bytea *out = leaf; + int s = VARBITBYTES(leaf) + VARHDRSZ; - out = palloc ( s ); - VARATT_SIZEP(out) = s; - memcpy ( (void*)VARDATA(out), (void*)VARBITS(leaf), VARBITBYTES(leaf) ); - return out; + out = palloc(s); + VARATT_SIZEP(out) = s; + memcpy((void *) VARDATA(out), (void *) VARBITS(leaf), VARBITBYTES(leaf)); + return out; } -static GBT_VARKEY * gbt_bit_l2n ( GBT_VARKEY * leaf ) +static GBT_VARKEY * +gbt_bit_l2n(GBT_VARKEY * leaf) { - GBT_VARKEY *out = leaf ; - GBT_VARKEY_R r = gbt_var_key_readable ( leaf ); - bytea *o ; + GBT_VARKEY *out = leaf; + GBT_VARKEY_R r = gbt_var_key_readable(leaf); + bytea *o; - o = gbt_bit_xfrm (r.lower); - r.upper = r.lower = o; - out = gbt_var_key_copy( &r, TRUE ); - pfree(o); + o = gbt_bit_xfrm(r.lower); + r.upper = r.lower = o; + out = gbt_var_key_copy(&r, TRUE); + pfree(o); - return out; + return out; } static const gbtree_vinfo tinfo = { - gbt_t_bit, - FALSE, - TRUE, - gbt_bitgt, - gbt_bitge, - gbt_biteq, - gbt_bitle, - gbt_bitlt, - gbt_bitcmp, - gbt_bit_l2n + gbt_t_bit, + FALSE, + TRUE, + gbt_bitgt, + gbt_bitge, + gbt_biteq, + gbt_bitle, + gbt_bitlt, + gbt_bitcmp, + gbt_bit_l2n }; @@ -108,40 +115,40 @@ static const gbtree_vinfo tinfo = **************************************************/ Datum -gbt_bit_compress (PG_FUNCTION_ARGS) +gbt_bit_compress(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - PG_RETURN_POINTER ( gbt_var_compress( entry, &tinfo ) ); + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + + PG_RETURN_POINTER(gbt_var_compress(entry, &tinfo)); } Datum gbt_bit_consistent(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - GBT_VARKEY *ktst = (GBT_VARKEY *) DatumGetPointer ( entry->key ) ; - GBT_VARKEY *key = (GBT_VARKEY *) DatumGetPointer ( PG_DETOAST_DATUM( entry->key ) ); - void *qtst = ( void * ) DatumGetPointer( PG_GETARG_DATUM(1) ); - void *query = ( void * ) DatumGetByteaP ( PG_GETARG_DATUM(1) ); - StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); - bool retval = FALSE; - GBT_VARKEY_R r = gbt_var_key_readable ( key ); - - if ( GIST_LEAF(entry) ) - { - retval = gbt_var_consistent( &r, query, &strategy, TRUE, &tinfo ); - } else { - bytea * q = gbt_bit_xfrm ( ( bytea * ) query ); - retval = gbt_var_consistent( &r, (void*)q, &strategy, FALSE, &tinfo ); - pfree(q); - } - - if ( ktst != key ){ - pfree ( key ); - } - if ( qtst != query ){ - pfree ( query ); - } - PG_RETURN_BOOL(retval); + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + GBT_VARKEY *ktst = (GBT_VARKEY *) DatumGetPointer(entry->key); + GBT_VARKEY *key = (GBT_VARKEY *) DatumGetPointer(PG_DETOAST_DATUM(entry->key)); + void *qtst = (void *) DatumGetPointer(PG_GETARG_DATUM(1)); + void *query = (void *) DatumGetByteaP(PG_GETARG_DATUM(1)); + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + bool retval = FALSE; + GBT_VARKEY_R r = gbt_var_key_readable(key); + + if (GIST_LEAF(entry)) + retval = gbt_var_consistent(&r, query, &strategy, TRUE, &tinfo); + else + { + bytea *q = gbt_bit_xfrm((bytea *) query); + + retval = gbt_var_consistent(&r, (void *) q, &strategy, FALSE, &tinfo); + pfree(q); + } + + if (ktst != key) + pfree(key); + if (qtst != query) + pfree(query); + PG_RETURN_BOOL(retval); } @@ -149,37 +156,40 @@ gbt_bit_consistent(PG_FUNCTION_ARGS) Datum gbt_bit_union(PG_FUNCTION_ARGS) { - GistEntryVector * entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); - int32 * size = (int *) PG_GETARG_POINTER(1); - PG_RETURN_POINTER( gbt_var_union ( entryvec , size , &tinfo ) ); + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + int32 *size = (int *) PG_GETARG_POINTER(1); + + PG_RETURN_POINTER(gbt_var_union(entryvec, size, &tinfo)); } - + Datum gbt_bit_picksplit(PG_FUNCTION_ARGS) { - GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); - GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1); - gbt_var_picksplit ( entryvec, v, &tinfo ); - PG_RETURN_POINTER(v); + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1); + + gbt_var_picksplit(entryvec, v, &tinfo); + PG_RETURN_POINTER(v); } Datum gbt_bit_same(PG_FUNCTION_ARGS) { - Datum d1 = PG_GETARG_DATUM(0); - Datum d2 = PG_GETARG_DATUM(1); - bool *result = (bool *) PG_GETARG_POINTER(2); - PG_RETURN_POINTER( gbt_var_same ( result, d1 , d2 , &tinfo )); + Datum d1 = PG_GETARG_DATUM(0); + Datum d2 = PG_GETARG_DATUM(1); + bool *result = (bool *) PG_GETARG_POINTER(2); + + PG_RETURN_POINTER(gbt_var_same(result, d1, d2, &tinfo)); } Datum gbt_bit_penalty(PG_FUNCTION_ARGS) { - float *result = (float *) PG_GETARG_POINTER(2); - GISTENTRY * o = (GISTENTRY *) PG_GETARG_POINTER(0); - GISTENTRY * n = (GISTENTRY *) PG_GETARG_POINTER(1); - PG_RETURN_POINTER( gbt_var_penalty ( result ,o , n, &tinfo ) ); -} + float *result = (float *) PG_GETARG_POINTER(2); + GISTENTRY *o = (GISTENTRY *) PG_GETARG_POINTER(0); + GISTENTRY *n = (GISTENTRY *) PG_GETARG_POINTER(1); + PG_RETURN_POINTER(gbt_var_penalty(result, o, n, &tinfo)); +} diff --git a/contrib/btree_gist/btree_bytea.c b/contrib/btree_gist/btree_bytea.c index da8a7f405b..3671acd24c 100644 --- a/contrib/btree_gist/btree_bytea.c +++ b/contrib/btree_gist/btree_bytea.c @@ -13,61 +13,67 @@ PG_FUNCTION_INFO_V1(gbt_bytea_consistent); PG_FUNCTION_INFO_V1(gbt_bytea_penalty); PG_FUNCTION_INFO_V1(gbt_bytea_same); -Datum gbt_bytea_compress(PG_FUNCTION_ARGS); -Datum gbt_bytea_union(PG_FUNCTION_ARGS); -Datum gbt_bytea_picksplit(PG_FUNCTION_ARGS); -Datum gbt_bytea_consistent(PG_FUNCTION_ARGS); -Datum gbt_bytea_penalty(PG_FUNCTION_ARGS); -Datum gbt_bytea_same(PG_FUNCTION_ARGS); +Datum gbt_bytea_compress(PG_FUNCTION_ARGS); +Datum gbt_bytea_union(PG_FUNCTION_ARGS); +Datum gbt_bytea_picksplit(PG_FUNCTION_ARGS); +Datum gbt_bytea_consistent(PG_FUNCTION_ARGS); +Datum gbt_bytea_penalty(PG_FUNCTION_ARGS); +Datum gbt_bytea_same(PG_FUNCTION_ARGS); /* define for comparison */ -static bool gbt_byteagt (const void *a, const void *b) +static bool +gbt_byteagt(const void *a, const void *b) { - return ( DatumGetBool(DirectFunctionCall2( byteagt ,PointerGetDatum( a ),PointerGetDatum( b ) ) ) ); + return (DatumGetBool(DirectFunctionCall2(byteagt, PointerGetDatum(a), PointerGetDatum(b)))); } -static bool gbt_byteage (const void *a, const void *b) +static bool +gbt_byteage(const void *a, const void *b) { - return ( DatumGetBool(DirectFunctionCall2( byteage ,PointerGetDatum( a ),PointerGetDatum( b ) ) ) ); + return (DatumGetBool(DirectFunctionCall2(byteage, PointerGetDatum(a), PointerGetDatum(b)))); } -static bool gbt_byteaeq (const void *a, const void *b) +static bool +gbt_byteaeq(const void *a, const void *b) { - return ( DatumGetBool(DirectFunctionCall2( byteaeq ,PointerGetDatum( a ),PointerGetDatum( b ) ) ) ); + return (DatumGetBool(DirectFunctionCall2(byteaeq, PointerGetDatum(a), PointerGetDatum(b)))); } -static bool gbt_byteale (const void *a, const void *b) +static bool +gbt_byteale(const void *a, const void *b) { - return ( DatumGetBool(DirectFunctionCall2( byteale ,PointerGetDatum( a ),PointerGetDatum( b ) ) ) ); + return (DatumGetBool(DirectFunctionCall2(byteale, PointerGetDatum(a), PointerGetDatum(b)))); } -static bool gbt_bytealt (const void *a, const void *b) +static bool +gbt_bytealt(const void *a, const void *b) { - return ( DatumGetBool(DirectFunctionCall2( bytealt ,PointerGetDatum( a ),PointerGetDatum( b ) ) ) ); + return (DatumGetBool(DirectFunctionCall2(bytealt, PointerGetDatum(a), PointerGetDatum(b)))); } - -static int32 gbt_byteacmp ( const bytea * a , const bytea * b ) + +static int32 +gbt_byteacmp(const bytea *a, const bytea *b) { - return - ( DatumGetInt32(DirectFunctionCall2(byteacmp,PointerGetDatum(a),PointerGetDatum(b) ) ) ); + return + (DatumGetInt32(DirectFunctionCall2(byteacmp, PointerGetDatum(a), PointerGetDatum(b)))); } static const gbtree_vinfo tinfo = { - gbt_t_bytea, - FALSE, - TRUE, - gbt_byteagt, - gbt_byteage, - gbt_byteaeq, - gbt_byteale, - gbt_bytealt, - gbt_byteacmp, - NULL + gbt_t_bytea, + FALSE, + TRUE, + gbt_byteagt, + gbt_byteage, + gbt_byteaeq, + gbt_byteale, + gbt_bytealt, + gbt_byteacmp, + NULL }; @@ -77,10 +83,11 @@ static const gbtree_vinfo tinfo = Datum -gbt_bytea_compress (PG_FUNCTION_ARGS) +gbt_bytea_compress(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - PG_RETURN_POINTER ( gbt_var_compress( entry, &tinfo ) ); + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + + PG_RETURN_POINTER(gbt_var_compress(entry, &tinfo)); } @@ -88,24 +95,22 @@ gbt_bytea_compress (PG_FUNCTION_ARGS) Datum gbt_bytea_consistent(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - GBT_VARKEY *ktst = (GBT_VARKEY *) DatumGetPointer ( entry->key ) ; - GBT_VARKEY *key = (GBT_VARKEY *) DatumGetPointer ( PG_DETOAST_DATUM( entry->key ) ); - void *qtst = ( void * ) DatumGetPointer( PG_GETARG_DATUM(1) ); - void *query = ( void * ) DatumGetByteaP ( PG_GETARG_DATUM(1) ); - StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); - bool retval = FALSE; - GBT_VARKEY_R r = gbt_var_key_readable ( key ); - - retval = gbt_var_consistent( &r, query, &strategy, GIST_LEAF(entry), &tinfo ); - - if ( ktst != key ){ - pfree ( key ); - } - if ( qtst != query ){ - pfree ( query ); - } - PG_RETURN_BOOL(retval); + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + GBT_VARKEY *ktst = (GBT_VARKEY *) DatumGetPointer(entry->key); + GBT_VARKEY *key = (GBT_VARKEY *) DatumGetPointer(PG_DETOAST_DATUM(entry->key)); + void *qtst = (void *) DatumGetPointer(PG_GETARG_DATUM(1)); + void *query = (void *) DatumGetByteaP(PG_GETARG_DATUM(1)); + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + bool retval = FALSE; + GBT_VARKEY_R r = gbt_var_key_readable(key); + + retval = gbt_var_consistent(&r, query, &strategy, GIST_LEAF(entry), &tinfo); + + if (ktst != key) + pfree(key); + if (qtst != query) + pfree(query); + PG_RETURN_BOOL(retval); } @@ -113,37 +118,40 @@ gbt_bytea_consistent(PG_FUNCTION_ARGS) Datum gbt_bytea_union(PG_FUNCTION_ARGS) { - GistEntryVector * entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); - int32 * size = (int *) PG_GETARG_POINTER(1); - PG_RETURN_POINTER( gbt_var_union ( entryvec , size , &tinfo ) ); + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + int32 *size = (int *) PG_GETARG_POINTER(1); + + PG_RETURN_POINTER(gbt_var_union(entryvec, size, &tinfo)); } - + Datum gbt_bytea_picksplit(PG_FUNCTION_ARGS) { - GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); - GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1); - gbt_var_picksplit ( entryvec, v, &tinfo ); - PG_RETURN_POINTER(v); + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1); + + gbt_var_picksplit(entryvec, v, &tinfo); + PG_RETURN_POINTER(v); } Datum gbt_bytea_same(PG_FUNCTION_ARGS) { - Datum d1 = PG_GETARG_DATUM(0); - Datum d2 = PG_GETARG_DATUM(1); - bool *result = (bool *) PG_GETARG_POINTER(2); - PG_RETURN_POINTER( gbt_var_same ( result, d1 , d2 , &tinfo )); + Datum d1 = PG_GETARG_DATUM(0); + Datum d2 = PG_GETARG_DATUM(1); + bool *result = (bool *) PG_GETARG_POINTER(2); + + PG_RETURN_POINTER(gbt_var_same(result, d1, d2, &tinfo)); } Datum gbt_bytea_penalty(PG_FUNCTION_ARGS) { - float *result = (float *) PG_GETARG_POINTER(2); - GISTENTRY * o = (GISTENTRY *) PG_GETARG_POINTER(0); - GISTENTRY * n = (GISTENTRY *) PG_GETARG_POINTER(1); - PG_RETURN_POINTER( gbt_var_penalty ( result ,o , n, &tinfo ) ); -} + float *result = (float *) PG_GETARG_POINTER(2); + GISTENTRY *o = (GISTENTRY *) PG_GETARG_POINTER(0); + GISTENTRY *n = (GISTENTRY *) PG_GETARG_POINTER(1); + PG_RETURN_POINTER(gbt_var_penalty(result, o, n, &tinfo)); +} diff --git a/contrib/btree_gist/btree_cash.c b/contrib/btree_gist/btree_cash.c index 6c5acb3e7e..84e4610118 100644 --- a/contrib/btree_gist/btree_cash.c +++ b/contrib/btree_gist/btree_cash.c @@ -4,9 +4,9 @@ typedef struct { - Cash lower; - Cash upper; -} cashKEY; + Cash lower; + Cash upper; +} cashKEY; /* ** Cash ops @@ -18,59 +18,62 @@ PG_FUNCTION_INFO_V1(gbt_cash_consistent); PG_FUNCTION_INFO_V1(gbt_cash_penalty); PG_FUNCTION_INFO_V1(gbt_cash_same); -Datum gbt_cash_compress(PG_FUNCTION_ARGS); -Datum gbt_cash_union(PG_FUNCTION_ARGS); -Datum gbt_cash_picksplit(PG_FUNCTION_ARGS); -Datum gbt_cash_consistent(PG_FUNCTION_ARGS); -Datum gbt_cash_penalty(PG_FUNCTION_ARGS); -Datum gbt_cash_same(PG_FUNCTION_ARGS); +Datum gbt_cash_compress(PG_FUNCTION_ARGS); +Datum gbt_cash_union(PG_FUNCTION_ARGS); +Datum gbt_cash_picksplit(PG_FUNCTION_ARGS); +Datum gbt_cash_consistent(PG_FUNCTION_ARGS); +Datum gbt_cash_penalty(PG_FUNCTION_ARGS); +Datum gbt_cash_same(PG_FUNCTION_ARGS); -static bool gbt_cashgt (const void *a, const void *b) +static bool +gbt_cashgt(const void *a, const void *b) { - return ( *((Cash*)a) > *((Cash*)b) ); + return (*((Cash *) a) > *((Cash *) b)); } -static bool gbt_cashge (const void *a, const void *b) +static bool +gbt_cashge(const void *a, const void *b) { - return ( *((Cash*)a) >= *((Cash*)b) ); + return (*((Cash *) a) >= *((Cash *) b)); } -static bool gbt_casheq (const void *a, const void *b) +static bool +gbt_casheq(const void *a, const void *b) { - return ( *((Cash*)a) == *((Cash*)b) ); + return (*((Cash *) a) == *((Cash *) b)); } -static bool gbt_cashle (const void *a, const void *b) +static bool +gbt_cashle(const void *a, const void *b) { - return ( *((Cash*)a) <= *((Cash*)b) ); + return (*((Cash *) a) <= *((Cash *) b)); } -static bool gbt_cashlt (const void *a, const void *b) +static bool +gbt_cashlt(const void *a, const void *b) { - return ( *((Cash*)a) < *((Cash*)b) ); + return (*((Cash *) a) < *((Cash *) b)); } static int gbt_cashkey_cmp(const void *a, const void *b) { - if ( *(Cash*)&(((Nsrt *) a)->t[0]) > *(Cash*)&(((Nsrt *) b)->t[0]) ){ - return 1; - } else - if ( *(Cash*)&(((Nsrt *) a)->t[0]) < *(Cash*)&(((Nsrt *) b)->t[0]) ){ - return -1; - } - return 0; + if (*(Cash *) &(((Nsrt *) a)->t[0]) > *(Cash *) &(((Nsrt *) b)->t[0])) + return 1; + else if (*(Cash *) &(((Nsrt *) a)->t[0]) < *(Cash *) &(((Nsrt *) b)->t[0])) + return -1; + return 0; } -static const gbtree_ninfo tinfo = +static const gbtree_ninfo tinfo = { - gbt_t_cash, - sizeof(Cash), - gbt_cashgt, - gbt_cashge, - gbt_casheq, - gbt_cashle, - gbt_cashlt, - gbt_cashkey_cmp + gbt_t_cash, + sizeof(Cash), + gbt_cashgt, + gbt_cashge, + gbt_casheq, + gbt_cashle, + gbt_cashlt, + gbt_cashkey_cmp }; @@ -82,81 +85,83 @@ static const gbtree_ninfo tinfo = Datum gbt_cash_compress(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - GISTENTRY *retval = NULL; - PG_RETURN_POINTER( gbt_num_compress( retval , entry , &tinfo )); + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + GISTENTRY *retval = NULL; + + PG_RETURN_POINTER(gbt_num_compress(retval, entry, &tinfo)); } Datum gbt_cash_consistent(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - Cash query = (*((Cash *) PG_GETARG_POINTER(1))); - cashKEY *kkk = (cashKEY *) DatumGetPointer(entry->key); - GBT_NUMKEY_R key ; - StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); - key.lower = (GBT_NUMKEY*) &kkk->lower ; - key.upper = (GBT_NUMKEY*) &kkk->upper ; - - PG_RETURN_BOOL( - gbt_num_consistent( &key, (void*)&query,&strategy,GIST_LEAF(entry),&tinfo) - ); + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + Cash query = (*((Cash *) PG_GETARG_POINTER(1))); + cashKEY *kkk = (cashKEY *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + + key.lower = (GBT_NUMKEY *) & kkk->lower; + key.upper = (GBT_NUMKEY *) & kkk->upper; + + PG_RETURN_BOOL( + gbt_num_consistent(&key, (void *) &query, &strategy, GIST_LEAF(entry), &tinfo) + ); } Datum gbt_cash_union(PG_FUNCTION_ARGS) { - GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); - void *out = palloc(sizeof(cashKEY)); - *(int *) PG_GETARG_POINTER(1) = sizeof(cashKEY); - PG_RETURN_POINTER( gbt_num_union ( (void*)out, entryvec, &tinfo ) ); + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + void *out = palloc(sizeof(cashKEY)); + + *(int *) PG_GETARG_POINTER(1) = sizeof(cashKEY); + PG_RETURN_POINTER(gbt_num_union((void *) out, entryvec, &tinfo)); } Datum gbt_cash_penalty(PG_FUNCTION_ARGS) { - cashKEY *origentry = (cashKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); - cashKEY *newentry = (cashKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); - float *result = (float *) PG_GETARG_POINTER(2); + cashKEY *origentry = (cashKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); + cashKEY *newentry = (cashKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); + float *result = (float *) PG_GETARG_POINTER(2); + + Cash res; - Cash res ; + *result = 0.0; - *result = 0.0; - - penalty_range_enlarge ( origentry->lower, origentry->upper, newentry->lower, newentry->upper ); + penalty_range_enlarge(origentry->lower, origentry->upper, newentry->lower, newentry->upper); - if ( res > 0 ){ - *result += FLT_MIN ; - *result += (float) ( res / ( (double) ( res + origentry->upper - origentry->lower ) ) ); - *result *= ( FLT_MAX / ( ( (GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1 ) ); - } + if (res > 0) + { + *result += FLT_MIN; + *result += (float) (res / ((double) (res + origentry->upper - origentry->lower))); + *result *= (FLT_MAX / (((GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1)); + } - PG_RETURN_POINTER(result); + PG_RETURN_POINTER(result); } Datum gbt_cash_picksplit(PG_FUNCTION_ARGS) { - PG_RETURN_POINTER(gbt_num_picksplit( - (GistEntryVector *) PG_GETARG_POINTER(0), - (GIST_SPLITVEC *) PG_GETARG_POINTER(1), - &tinfo - )); + PG_RETURN_POINTER(gbt_num_picksplit( + (GistEntryVector *) PG_GETARG_POINTER(0), + (GIST_SPLITVEC *) PG_GETARG_POINTER(1), + &tinfo + )); } Datum gbt_cash_same(PG_FUNCTION_ARGS) { - cashKEY *b1 = (cashKEY *) PG_GETARG_POINTER(0); - cashKEY *b2 = (cashKEY *) PG_GETARG_POINTER(1); - bool *result = (bool *) PG_GETARG_POINTER(2); + cashKEY *b1 = (cashKEY *) PG_GETARG_POINTER(0); + cashKEY *b2 = (cashKEY *) PG_GETARG_POINTER(1); + bool *result = (bool *) PG_GETARG_POINTER(2); - *result = gbt_num_same ( (void*)b1, (void*)b2, &tinfo ); - PG_RETURN_POINTER(result); + *result = gbt_num_same((void *) b1, (void *) b2, &tinfo); + PG_RETURN_POINTER(result); } - - diff --git a/contrib/btree_gist/btree_date.c b/contrib/btree_gist/btree_date.c index 9522d38625..d3ce33c717 100644 --- a/contrib/btree_gist/btree_date.c +++ b/contrib/btree_gist/btree_date.c @@ -4,9 +4,9 @@ typedef struct { - DateADT lower; - DateADT upper; -} dateKEY; + DateADT lower; + DateADT upper; +} dateKEY; /* ** date ops @@ -18,46 +18,51 @@ PG_FUNCTION_INFO_V1(gbt_date_consistent); PG_FUNCTION_INFO_V1(gbt_date_penalty); PG_FUNCTION_INFO_V1(gbt_date_same); -Datum gbt_date_compress(PG_FUNCTION_ARGS); -Datum gbt_date_union(PG_FUNCTION_ARGS); -Datum gbt_date_picksplit(PG_FUNCTION_ARGS); -Datum gbt_date_consistent(PG_FUNCTION_ARGS); -Datum gbt_date_penalty(PG_FUNCTION_ARGS); -Datum gbt_date_same(PG_FUNCTION_ARGS); +Datum gbt_date_compress(PG_FUNCTION_ARGS); +Datum gbt_date_union(PG_FUNCTION_ARGS); +Datum gbt_date_picksplit(PG_FUNCTION_ARGS); +Datum gbt_date_consistent(PG_FUNCTION_ARGS); +Datum gbt_date_penalty(PG_FUNCTION_ARGS); +Datum gbt_date_same(PG_FUNCTION_ARGS); -static bool gbt_dategt (const void *a, const void *b) +static bool +gbt_dategt(const void *a, const void *b) { - return DatumGetBool( - DirectFunctionCall2(date_gt,DateADTGetDatum( *((DateADT*)a) ), DateADTGetDatum( *((DateADT*)b) ) ) - ); + return DatumGetBool( + DirectFunctionCall2(date_gt, DateADTGetDatum(*((DateADT *) a)), DateADTGetDatum(*((DateADT *) b))) + ); } -static bool gbt_datege (const void *a, const void *b) +static bool +gbt_datege(const void *a, const void *b) { - return DatumGetBool( - DirectFunctionCall2(date_ge,DateADTGetDatum( *((DateADT*)a) ), DateADTGetDatum( *((DateADT*)b) ) ) - ); + return DatumGetBool( + DirectFunctionCall2(date_ge, DateADTGetDatum(*((DateADT *) a)), DateADTGetDatum(*((DateADT *) b))) + ); } -static bool gbt_dateeq (const void *a, const void *b) +static bool +gbt_dateeq(const void *a, const void *b) { - return DatumGetBool( - DirectFunctionCall2(date_eq,DateADTGetDatum( *((DateADT*)a) ), DateADTGetDatum( *((DateADT*)b) ) ) - ); + return DatumGetBool( + DirectFunctionCall2(date_eq, DateADTGetDatum(*((DateADT *) a)), DateADTGetDatum(*((DateADT *) b))) + ); } -static bool gbt_datele (const void *a, const void *b) +static bool +gbt_datele(const void *a, const void *b) { - return DatumGetBool( - DirectFunctionCall2(date_le,DateADTGetDatum( *((DateADT*)a) ), DateADTGetDatum( *((DateADT*)b) ) ) - ); + return DatumGetBool( + DirectFunctionCall2(date_le, DateADTGetDatum(*((DateADT *) a)), DateADTGetDatum(*((DateADT *) b))) + ); } -static bool gbt_datelt (const void *a, const void *b) +static bool +gbt_datelt(const void *a, const void *b) { - return DatumGetBool( - DirectFunctionCall2(date_lt,DateADTGetDatum( *((DateADT*)a) ), DateADTGetDatum( *((DateADT*)b) ) ) - ); + return DatumGetBool( + DirectFunctionCall2(date_lt, DateADTGetDatum(*((DateADT *) a)), DateADTGetDatum(*((DateADT *) b))) + ); } @@ -65,26 +70,24 @@ static bool gbt_datelt (const void *a, const void *b) static int gbt_datekey_cmp(const void *a, const void *b) { - if ( gbt_dategt( (void*)&(((Nsrt *) a)->t[0]) , (void*)&(((Nsrt *) b)->t[0]) ) ){ - return 1; - } else - if ( gbt_datelt( (void*)&(((Nsrt *) a)->t[0]) , (void*)&(((Nsrt *) b)->t[0]) ) ){ - return -1; - } - return 0; + if (gbt_dategt((void *) &(((Nsrt *) a)->t[0]), (void *) &(((Nsrt *) b)->t[0]))) + return 1; + else if (gbt_datelt((void *) &(((Nsrt *) a)->t[0]), (void *) &(((Nsrt *) b)->t[0]))) + return -1; + return 0; } -static const gbtree_ninfo tinfo = +static const gbtree_ninfo tinfo = { - gbt_t_date, - sizeof(DateADT), - gbt_dategt, - gbt_datege, - gbt_dateeq, - gbt_datele, - gbt_datelt, - gbt_datekey_cmp + gbt_t_date, + sizeof(DateADT), + gbt_dategt, + gbt_datege, + gbt_dateeq, + gbt_datele, + gbt_datelt, + gbt_datekey_cmp }; @@ -97,9 +100,10 @@ static const gbtree_ninfo tinfo = Datum gbt_date_compress(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - GISTENTRY *retval = NULL; - PG_RETURN_POINTER( gbt_num_compress( retval , entry , &tinfo )); + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + GISTENTRY *retval = NULL; + + PG_RETURN_POINTER(gbt_num_compress(retval, entry, &tinfo)); } @@ -107,86 +111,89 @@ gbt_date_compress(PG_FUNCTION_ARGS) Datum gbt_date_consistent(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - DateADT query = PG_GETARG_DATEADT( 1 ); - dateKEY *kkk = (dateKEY *) DatumGetPointer(entry->key); - GBT_NUMKEY_R key ; - StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); - - key.lower = (GBT_NUMKEY*) &kkk->lower ; - key.upper = (GBT_NUMKEY*) &kkk->upper ; - - PG_RETURN_BOOL( - gbt_num_consistent( &key, (void*)&query,&strategy,GIST_LEAF(entry),&tinfo) - ); + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + DateADT query = PG_GETARG_DATEADT(1); + dateKEY *kkk = (dateKEY *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + + key.lower = (GBT_NUMKEY *) & kkk->lower; + key.upper = (GBT_NUMKEY *) & kkk->upper; + + PG_RETURN_BOOL( + gbt_num_consistent(&key, (void *) &query, &strategy, GIST_LEAF(entry), &tinfo) + ); } Datum gbt_date_union(PG_FUNCTION_ARGS) { - GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); - void *out = palloc(sizeof(dateKEY)); - *(int *) PG_GETARG_POINTER(1) = sizeof(dateKEY); - PG_RETURN_POINTER( gbt_num_union ( (void*)out, entryvec, &tinfo ) ); + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + void *out = palloc(sizeof(dateKEY)); + + *(int *) PG_GETARG_POINTER(1) = sizeof(dateKEY); + PG_RETURN_POINTER(gbt_num_union((void *) out, entryvec, &tinfo)); } Datum gbt_date_penalty(PG_FUNCTION_ARGS) { - dateKEY *origentry = (dateKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); - dateKEY *newentry = (dateKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); - float *result = (float *) PG_GETARG_POINTER(2); - int32 diff, res ; - - diff = DatumGetInt32(DirectFunctionCall2( - date_mi, - DateADTGetDatum(newentry->upper), - DateADTGetDatum(origentry->upper))); - - res = Max(diff, 0); - - diff = DatumGetInt32(DirectFunctionCall2( - date_mi, - DateADTGetDatum(origentry->lower), - DateADTGetDatum(newentry->lower))); - - res += Max(diff, 0); - - *result = 0.0; - - if ( res > 0 ){ - diff = DatumGetInt32(DirectFunctionCall2( - date_mi, - DateADTGetDatum(origentry->upper), - DateADTGetDatum(origentry->lower))); - *result += FLT_MIN ; - *result += (float) ( res / ( (double) ( res + diff ) ) ); - *result *= ( FLT_MAX / ( ( (GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1 ) ); - } - - PG_RETURN_POINTER(result); + dateKEY *origentry = (dateKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); + dateKEY *newentry = (dateKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); + float *result = (float *) PG_GETARG_POINTER(2); + int32 diff, + res; + + diff = DatumGetInt32(DirectFunctionCall2( + date_mi, + DateADTGetDatum(newentry->upper), + DateADTGetDatum(origentry->upper))); + + res = Max(diff, 0); + + diff = DatumGetInt32(DirectFunctionCall2( + date_mi, + DateADTGetDatum(origentry->lower), + DateADTGetDatum(newentry->lower))); + + res += Max(diff, 0); + + *result = 0.0; + + if (res > 0) + { + diff = DatumGetInt32(DirectFunctionCall2( + date_mi, + DateADTGetDatum(origentry->upper), + DateADTGetDatum(origentry->lower))); + *result += FLT_MIN; + *result += (float) (res / ((double) (res + diff))); + *result *= (FLT_MAX / (((GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1)); + } + + PG_RETURN_POINTER(result); } Datum gbt_date_picksplit(PG_FUNCTION_ARGS) { - PG_RETURN_POINTER(gbt_num_picksplit( - (GistEntryVector *) PG_GETARG_POINTER(0), - (GIST_SPLITVEC *) PG_GETARG_POINTER(1), - &tinfo - )); + PG_RETURN_POINTER(gbt_num_picksplit( + (GistEntryVector *) PG_GETARG_POINTER(0), + (GIST_SPLITVEC *) PG_GETARG_POINTER(1), + &tinfo + )); } Datum gbt_date_same(PG_FUNCTION_ARGS) { - dateKEY *b1 = (dateKEY *) PG_GETARG_POINTER(0); - dateKEY *b2 = (dateKEY *) PG_GETARG_POINTER(1); - bool *result = (bool *) PG_GETARG_POINTER(2); + dateKEY *b1 = (dateKEY *) PG_GETARG_POINTER(0); + dateKEY *b2 = (dateKEY *) PG_GETARG_POINTER(1); + bool *result = (bool *) PG_GETARG_POINTER(2); - *result = gbt_num_same ( (void*)b1, (void*)b2, &tinfo ); - PG_RETURN_POINTER(result); + *result = gbt_num_same((void *) b1, (void *) b2, &tinfo); + PG_RETURN_POINTER(result); } diff --git a/contrib/btree_gist/btree_float4.c b/contrib/btree_gist/btree_float4.c index 621532d9a9..b36178e454 100644 --- a/contrib/btree_gist/btree_float4.c +++ b/contrib/btree_gist/btree_float4.c @@ -3,9 +3,9 @@ typedef struct float4key { - float4 lower; - float4 upper; -} float4KEY; + float4 lower; + float4 upper; +} float4KEY; /* ** float4 ops @@ -17,59 +17,62 @@ PG_FUNCTION_INFO_V1(gbt_float4_consistent); PG_FUNCTION_INFO_V1(gbt_float4_penalty); PG_FUNCTION_INFO_V1(gbt_float4_same); -Datum gbt_float4_compress(PG_FUNCTION_ARGS); -Datum gbt_float4_union(PG_FUNCTION_ARGS); -Datum gbt_float4_picksplit(PG_FUNCTION_ARGS); -Datum gbt_float4_consistent(PG_FUNCTION_ARGS); -Datum gbt_float4_penalty(PG_FUNCTION_ARGS); -Datum gbt_float4_same(PG_FUNCTION_ARGS); +Datum gbt_float4_compress(PG_FUNCTION_ARGS); +Datum gbt_float4_union(PG_FUNCTION_ARGS); +Datum gbt_float4_picksplit(PG_FUNCTION_ARGS); +Datum gbt_float4_consistent(PG_FUNCTION_ARGS); +Datum gbt_float4_penalty(PG_FUNCTION_ARGS); +Datum gbt_float4_same(PG_FUNCTION_ARGS); -static bool gbt_float4gt (const void *a, const void *b) +static bool +gbt_float4gt(const void *a, const void *b) { - return ( *((float4*)a) > *((float4*)b) ); + return (*((float4 *) a) > *((float4 *) b)); } -static bool gbt_float4ge (const void *a, const void *b) +static bool +gbt_float4ge(const void *a, const void *b) { - return ( *((float4*)a) >= *((float4*)b) ); + return (*((float4 *) a) >= *((float4 *) b)); } -static bool gbt_float4eq (const void *a, const void *b) +static bool +gbt_float4eq(const void *a, const void *b) { - return ( *((float4*)a) == *((float4*)b) ); + return (*((float4 *) a) == *((float4 *) b)); } -static bool gbt_float4le (const void *a, const void *b) +static bool +gbt_float4le(const void *a, const void *b) { - return ( *((float4*)a) <= *((float4*)b) ); + return (*((float4 *) a) <= *((float4 *) b)); } -static bool gbt_float4lt (const void *a, const void *b) +static bool +gbt_float4lt(const void *a, const void *b) { - return ( *((float4*)a) < *((float4*)b) ); + return (*((float4 *) a) < *((float4 *) b)); } static int gbt_float4key_cmp(const void *a, const void *b) { - if ( *(float4*)&(((Nsrt *) a)->t[0]) > *(float4*)&(((Nsrt *) b)->t[0]) ){ - return 1; - } else - if ( *(float4*)&(((Nsrt *) a)->t[0]) < *(float4*)&(((Nsrt *) b)->t[0]) ){ - return -1; - } - return 0; + if (*(float4 *) &(((Nsrt *) a)->t[0]) > *(float4 *) &(((Nsrt *) b)->t[0])) + return 1; + else if (*(float4 *) &(((Nsrt *) a)->t[0]) < *(float4 *) &(((Nsrt *) b)->t[0])) + return -1; + return 0; } -static const gbtree_ninfo tinfo = -{ - gbt_t_float4, - sizeof(float4), - gbt_float4gt, - gbt_float4ge, - gbt_float4eq, - gbt_float4le, - gbt_float4lt, - gbt_float4key_cmp +static const gbtree_ninfo tinfo = +{ + gbt_t_float4, + sizeof(float4), + gbt_float4gt, + gbt_float4ge, + gbt_float4eq, + gbt_float4le, + gbt_float4lt, + gbt_float4key_cmp }; @@ -81,80 +84,83 @@ static const gbtree_ninfo tinfo = Datum gbt_float4_compress(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - GISTENTRY *retval = NULL; - PG_RETURN_POINTER( gbt_num_compress( retval , entry , &tinfo )); + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + GISTENTRY *retval = NULL; + + PG_RETURN_POINTER(gbt_num_compress(retval, entry, &tinfo)); } Datum gbt_float4_consistent(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - float4 query = PG_GETARG_FLOAT4(1); - float4KEY *kkk = (float4KEY *) DatumGetPointer(entry->key); - GBT_NUMKEY_R key ; - StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); - key.lower = (GBT_NUMKEY*) &kkk->lower ; - key.upper = (GBT_NUMKEY*) &kkk->upper ; - - PG_RETURN_BOOL( - gbt_num_consistent( &key, (void*)&query,&strategy,GIST_LEAF(entry),&tinfo) - ); + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + float4 query = PG_GETARG_FLOAT4(1); + float4KEY *kkk = (float4KEY *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + + key.lower = (GBT_NUMKEY *) & kkk->lower; + key.upper = (GBT_NUMKEY *) & kkk->upper; + + PG_RETURN_BOOL( + gbt_num_consistent(&key, (void *) &query, &strategy, GIST_LEAF(entry), &tinfo) + ); } Datum gbt_float4_union(PG_FUNCTION_ARGS) { - GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); - void *out = palloc(sizeof(float4KEY)); - *(int *) PG_GETARG_POINTER(1) = sizeof(float4KEY); - PG_RETURN_POINTER( gbt_num_union ( (void*)out, entryvec, &tinfo ) ); + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + void *out = palloc(sizeof(float4KEY)); + + *(int *) PG_GETARG_POINTER(1) = sizeof(float4KEY); + PG_RETURN_POINTER(gbt_num_union((void *) out, entryvec, &tinfo)); } Datum gbt_float4_penalty(PG_FUNCTION_ARGS) { - float4KEY *origentry = (float4KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); - float4KEY *newentry = (float4KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); - float *result = (float *) PG_GETARG_POINTER(2); + float4KEY *origentry = (float4KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); + float4KEY *newentry = (float4KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); + float *result = (float *) PG_GETARG_POINTER(2); - float4 res ; + float4 res; - *result = 0.0; - - penalty_range_enlarge ( origentry->lower, origentry->upper, newentry->lower, newentry->upper ); + *result = 0.0; - if ( res > 0 ){ - *result += FLT_MIN ; - *result += (float) ( res / ( (double) ( res + origentry->upper - origentry->lower ) ) ); - *result *= ( FLT_MAX / ( ( (GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1 ) ); - } + penalty_range_enlarge(origentry->lower, origentry->upper, newentry->lower, newentry->upper); - PG_RETURN_POINTER(result); + if (res > 0) + { + *result += FLT_MIN; + *result += (float) (res / ((double) (res + origentry->upper - origentry->lower))); + *result *= (FLT_MAX / (((GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1)); + } + + PG_RETURN_POINTER(result); } Datum gbt_float4_picksplit(PG_FUNCTION_ARGS) { - PG_RETURN_POINTER(gbt_num_picksplit( - (GistEntryVector *) PG_GETARG_POINTER(0), - (GIST_SPLITVEC *) PG_GETARG_POINTER(1), - &tinfo - )); + PG_RETURN_POINTER(gbt_num_picksplit( + (GistEntryVector *) PG_GETARG_POINTER(0), + (GIST_SPLITVEC *) PG_GETARG_POINTER(1), + &tinfo + )); } Datum gbt_float4_same(PG_FUNCTION_ARGS) { - float4KEY *b1 = (float4KEY *) PG_GETARG_POINTER(0); - float4KEY *b2 = (float4KEY *) PG_GETARG_POINTER(1); - bool *result = (bool *) PG_GETARG_POINTER(2); + float4KEY *b1 = (float4KEY *) PG_GETARG_POINTER(0); + float4KEY *b2 = (float4KEY *) PG_GETARG_POINTER(1); + bool *result = (bool *) PG_GETARG_POINTER(2); - *result = gbt_num_same ( (void*)b1, (void*)b2, &tinfo ); - PG_RETURN_POINTER(result); + *result = gbt_num_same((void *) b1, (void *) b2, &tinfo); + PG_RETURN_POINTER(result); } - diff --git a/contrib/btree_gist/btree_float8.c b/contrib/btree_gist/btree_float8.c index e19632fd78..a5511d5abf 100644 --- a/contrib/btree_gist/btree_float8.c +++ b/contrib/btree_gist/btree_float8.c @@ -3,9 +3,9 @@ typedef struct float8key { - float8 lower; - float8 upper; -} float8KEY; + float8 lower; + float8 upper; +} float8KEY; /* ** float8 ops @@ -17,60 +17,63 @@ PG_FUNCTION_INFO_V1(gbt_float8_consistent); PG_FUNCTION_INFO_V1(gbt_float8_penalty); PG_FUNCTION_INFO_V1(gbt_float8_same); -Datum gbt_float8_compress(PG_FUNCTION_ARGS); -Datum gbt_float8_union(PG_FUNCTION_ARGS); -Datum gbt_float8_picksplit(PG_FUNCTION_ARGS); -Datum gbt_float8_consistent(PG_FUNCTION_ARGS); -Datum gbt_float8_penalty(PG_FUNCTION_ARGS); -Datum gbt_float8_same(PG_FUNCTION_ARGS); +Datum gbt_float8_compress(PG_FUNCTION_ARGS); +Datum gbt_float8_union(PG_FUNCTION_ARGS); +Datum gbt_float8_picksplit(PG_FUNCTION_ARGS); +Datum gbt_float8_consistent(PG_FUNCTION_ARGS); +Datum gbt_float8_penalty(PG_FUNCTION_ARGS); +Datum gbt_float8_same(PG_FUNCTION_ARGS); -static bool gbt_float8gt (const void *a, const void *b) +static bool +gbt_float8gt(const void *a, const void *b) { - return ( *((float8*)a) > *((float8*)b) ); + return (*((float8 *) a) > *((float8 *) b)); } -static bool gbt_float8ge (const void *a, const void *b) +static bool +gbt_float8ge(const void *a, const void *b) { - return ( *((float8*)a) >= *((float8*)b) ); + return (*((float8 *) a) >= *((float8 *) b)); } -static bool gbt_float8eq (const void *a, const void *b) +static bool +gbt_float8eq(const void *a, const void *b) { - return ( *((float8*)a) == *((float8*)b) ); + return (*((float8 *) a) == *((float8 *) b)); } -static bool gbt_float8le (const void *a, const void *b) +static bool +gbt_float8le(const void *a, const void *b) { - return ( *((float8*)a) <= *((float8*)b) ); + return (*((float8 *) a) <= *((float8 *) b)); } -static bool gbt_float8lt (const void *a, const void *b) +static bool +gbt_float8lt(const void *a, const void *b) { - return ( *((float8*)a) < *((float8*)b) ); + return (*((float8 *) a) < *((float8 *) b)); } static int gbt_float8key_cmp(const void *a, const void *b) { - if ( *(float8*)&(((Nsrt *) a)->t[0]) > *(float8*)&(((Nsrt *) b)->t[0]) ){ - return 1; - } else - if ( *(float8*)&(((Nsrt *) a)->t[0]) < *(float8*)&(((Nsrt *) b)->t[0]) ){ - return -1; - } - return 0; + if (*(float8 *) &(((Nsrt *) a)->t[0]) > *(float8 *) &(((Nsrt *) b)->t[0])) + return 1; + else if (*(float8 *) &(((Nsrt *) a)->t[0]) < *(float8 *) &(((Nsrt *) b)->t[0])) + return -1; + return 0; } -static const gbtree_ninfo tinfo = -{ - gbt_t_float8, - sizeof(float8), - gbt_float8gt, - gbt_float8ge, - gbt_float8eq, - gbt_float8le, - gbt_float8lt, - gbt_float8key_cmp +static const gbtree_ninfo tinfo = +{ + gbt_t_float8, + sizeof(float8), + gbt_float8gt, + gbt_float8ge, + gbt_float8eq, + gbt_float8le, + gbt_float8lt, + gbt_float8key_cmp }; @@ -82,9 +85,10 @@ static const gbtree_ninfo tinfo = Datum gbt_float8_compress(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - GISTENTRY *retval = NULL; - PG_RETURN_POINTER( gbt_num_compress( retval , entry , &tinfo )); + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + GISTENTRY *retval = NULL; + + PG_RETURN_POINTER(gbt_num_compress(retval, entry, &tinfo)); } @@ -92,70 +96,73 @@ Datum gbt_float8_consistent(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - float8 query = PG_GETARG_FLOAT8(1); - float8KEY *kkk = (float8KEY *) DatumGetPointer(entry->key); - GBT_NUMKEY_R key ; - StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); - key.lower = (GBT_NUMKEY*) &kkk->lower ; - key.upper = (GBT_NUMKEY*) &kkk->upper ; - - PG_RETURN_BOOL( - gbt_num_consistent( &key, (void*)&query,&strategy,GIST_LEAF(entry),&tinfo) - ); + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + float8 query = PG_GETARG_FLOAT8(1); + float8KEY *kkk = (float8KEY *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + + key.lower = (GBT_NUMKEY *) & kkk->lower; + key.upper = (GBT_NUMKEY *) & kkk->upper; + + PG_RETURN_BOOL( + gbt_num_consistent(&key, (void *) &query, &strategy, GIST_LEAF(entry), &tinfo) + ); } Datum gbt_float8_union(PG_FUNCTION_ARGS) { - GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); - void *out = palloc(sizeof(float8KEY)); - *(int *) PG_GETARG_POINTER(1) = sizeof(float8KEY); - PG_RETURN_POINTER( gbt_num_union ( (void*)out, entryvec, &tinfo ) ); + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + void *out = palloc(sizeof(float8KEY)); + + *(int *) PG_GETARG_POINTER(1) = sizeof(float8KEY); + PG_RETURN_POINTER(gbt_num_union((void *) out, entryvec, &tinfo)); } Datum gbt_float8_penalty(PG_FUNCTION_ARGS) { - float8KEY *origentry = (float8KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); - float8KEY *newentry = (float8KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); - float *result = (float *) PG_GETARG_POINTER(2); + float8KEY *origentry = (float8KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); + float8KEY *newentry = (float8KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); + float *result = (float *) PG_GETARG_POINTER(2); + + float8 res; - float8 res ; + *result = 0.0; - *result = 0.0; - - penalty_range_enlarge ( origentry->lower, origentry->upper, newentry->lower, newentry->upper ); + penalty_range_enlarge(origentry->lower, origentry->upper, newentry->lower, newentry->upper); - if ( res > 0 ){ - *result += FLT_MIN ; - *result += (float) ( res / ( (double) ( res + origentry->upper - origentry->lower ) ) ); - *result *= ( FLT_MAX / ( ( (GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1 ) ); - } + if (res > 0) + { + *result += FLT_MIN; + *result += (float) (res / ((double) (res + origentry->upper - origentry->lower))); + *result *= (FLT_MAX / (((GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1)); + } - PG_RETURN_POINTER(result); + PG_RETURN_POINTER(result); } Datum gbt_float8_picksplit(PG_FUNCTION_ARGS) { - PG_RETURN_POINTER(gbt_num_picksplit( - (GistEntryVector *) PG_GETARG_POINTER(0), - (GIST_SPLITVEC *) PG_GETARG_POINTER(1), - &tinfo - )); + PG_RETURN_POINTER(gbt_num_picksplit( + (GistEntryVector *) PG_GETARG_POINTER(0), + (GIST_SPLITVEC *) PG_GETARG_POINTER(1), + &tinfo + )); } Datum gbt_float8_same(PG_FUNCTION_ARGS) { - float8KEY *b1 = (float8KEY *) PG_GETARG_POINTER(0); - float8KEY *b2 = (float8KEY *) PG_GETARG_POINTER(1); - bool *result = (bool *) PG_GETARG_POINTER(2); + float8KEY *b1 = (float8KEY *) PG_GETARG_POINTER(0); + float8KEY *b2 = (float8KEY *) PG_GETARG_POINTER(1); + bool *result = (bool *) PG_GETARG_POINTER(2); - *result = gbt_num_same ( (void*)b1, (void*)b2, &tinfo ); - PG_RETURN_POINTER(result); + *result = gbt_num_same((void *) b1, (void *) b2, &tinfo); + PG_RETURN_POINTER(result); } diff --git a/contrib/btree_gist/btree_gist.c b/contrib/btree_gist/btree_gist.c index 5e5a6988bb..a64a6cb7c1 100644 --- a/contrib/btree_gist/btree_gist.c +++ b/contrib/btree_gist/btree_gist.c @@ -1,24 +1,24 @@ #include "btree_gist.h" PG_FUNCTION_INFO_V1(gbt_decompress); -PG_FUNCTION_INFO_V1(gbtreekey_in); +PG_FUNCTION_INFO_V1(gbtreekey_in); PG_FUNCTION_INFO_V1(gbtreekey_out); -Datum gbt_decompress(PG_FUNCTION_ARGS); +Datum gbt_decompress(PG_FUNCTION_ARGS); /************************************************** * In/Out for keys **************************************************/ - + Datum gbtreekey_in(PG_FUNCTION_ARGS) { - ereport(ERROR, - (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), - errmsg("<datatype>key_in() not implemented"))); + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + errmsg("<datatype>key_in() not implemented"))); - PG_RETURN_POINTER(NULL); + PG_RETURN_POINTER(NULL); } #include "btree_utils_var.h" @@ -26,10 +26,10 @@ gbtreekey_in(PG_FUNCTION_ARGS) Datum gbtreekey_out(PG_FUNCTION_ARGS) { - ereport(ERROR, - (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), - errmsg("<datatype>key_out() not implemented"))); - PG_RETURN_POINTER(NULL); + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + errmsg("<datatype>key_out() not implemented"))); + PG_RETURN_POINTER(NULL); } @@ -40,6 +40,5 @@ gbtreekey_out(PG_FUNCTION_ARGS) Datum gbt_decompress(PG_FUNCTION_ARGS) { - PG_RETURN_POINTER(PG_GETARG_POINTER(0)); + PG_RETURN_POINTER(PG_GETARG_POINTER(0)); } - diff --git a/contrib/btree_gist/btree_gist.h b/contrib/btree_gist/btree_gist.h index 1b4fe837d2..f7db9206e7 100644 --- a/contrib/btree_gist/btree_gist.h +++ b/contrib/btree_gist/btree_gist.h @@ -7,25 +7,25 @@ enum gbtree_type { - gbt_t_var , - gbt_t_int2 , - gbt_t_int4 , - gbt_t_int8 , - gbt_t_float4 , - gbt_t_float8 , - gbt_t_numeric, - gbt_t_ts, - gbt_t_cash, - gbt_t_oid, - gbt_t_time, - gbt_t_date, - gbt_t_intv, - gbt_t_macad, - gbt_t_text, - gbt_t_bpchar, - gbt_t_bytea, - gbt_t_bit, - gbt_t_inet + gbt_t_var, + gbt_t_int2, + gbt_t_int4, + gbt_t_int8, + gbt_t_float4, + gbt_t_float8, + gbt_t_numeric, + gbt_t_ts, + gbt_t_cash, + gbt_t_oid, + gbt_t_time, + gbt_t_date, + gbt_t_intv, + gbt_t_macad, + gbt_t_text, + gbt_t_bpchar, + gbt_t_bytea, + gbt_t_bit, + gbt_t_inet }; @@ -34,6 +34,6 @@ enum gbtree_type * Generic btree functions */ -Datum gbtreekey_in (PG_FUNCTION_ARGS); +Datum gbtreekey_in(PG_FUNCTION_ARGS); -Datum gbtreekey_out(PG_FUNCTION_ARGS); +Datum gbtreekey_out(PG_FUNCTION_ARGS); diff --git a/contrib/btree_gist/btree_inet.c b/contrib/btree_gist/btree_inet.c index 5b3f66789d..fad053a36f 100644 --- a/contrib/btree_gist/btree_inet.c +++ b/contrib/btree_gist/btree_inet.c @@ -6,9 +6,9 @@ typedef struct inetkey { - double lower; - double upper; -} inetKEY; + double lower; + double upper; +} inetKEY; /* ** inet ops @@ -22,62 +22,65 @@ PG_FUNCTION_INFO_V1(gbt_cidr_consistent); PG_FUNCTION_INFO_V1(gbt_inet_penalty); PG_FUNCTION_INFO_V1(gbt_inet_same); -Datum gbt_inet_compress(PG_FUNCTION_ARGS); -Datum gbt_cidr_compress(PG_FUNCTION_ARGS); -Datum gbt_inet_union(PG_FUNCTION_ARGS); -Datum gbt_inet_picksplit(PG_FUNCTION_ARGS); -Datum gbt_inet_consistent(PG_FUNCTION_ARGS); -Datum gbt_cidr_consistent(PG_FUNCTION_ARGS); -Datum gbt_inet_penalty(PG_FUNCTION_ARGS); -Datum gbt_inet_same(PG_FUNCTION_ARGS); +Datum gbt_inet_compress(PG_FUNCTION_ARGS); +Datum gbt_cidr_compress(PG_FUNCTION_ARGS); +Datum gbt_inet_union(PG_FUNCTION_ARGS); +Datum gbt_inet_picksplit(PG_FUNCTION_ARGS); +Datum gbt_inet_consistent(PG_FUNCTION_ARGS); +Datum gbt_cidr_consistent(PG_FUNCTION_ARGS); +Datum gbt_inet_penalty(PG_FUNCTION_ARGS); +Datum gbt_inet_same(PG_FUNCTION_ARGS); -static bool gbt_inetgt (const void *a, const void *b) +static bool +gbt_inetgt(const void *a, const void *b) { - return ( *((double*)a) > *((double*)b) ); + return (*((double *) a) > *((double *) b)); } -static bool gbt_inetge (const void *a, const void *b) +static bool +gbt_inetge(const void *a, const void *b) { - return ( *((double*)a) >= *((double*)b) ); + return (*((double *) a) >= *((double *) b)); } -static bool gbt_ineteq (const void *a, const void *b) +static bool +gbt_ineteq(const void *a, const void *b) { - return ( *((double*)a) == *((double*)b) ); + return (*((double *) a) == *((double *) b)); } -static bool gbt_inetle (const void *a, const void *b) +static bool +gbt_inetle(const void *a, const void *b) { - return ( *((double*)a) <= *((double*)b) ); + return (*((double *) a) <= *((double *) b)); } -static bool gbt_inetlt (const void *a, const void *b) +static bool +gbt_inetlt(const void *a, const void *b) { - return ( *((double*)a) < *((double*)b) ); + return (*((double *) a) < *((double *) b)); } static int gbt_inetkey_cmp(const void *a, const void *b) { - if ( *(double*)(&((Nsrt *) a)->t[0]) > *(double*)(&((Nsrt *) b)->t[0]) ){ - return 1; - } else - if ( *(double*)(&((Nsrt *) a)->t[0]) < *(double*)(&((Nsrt *) b)->t[0]) ){ - return -1; - } - return 0; + if (*(double *) (&((Nsrt *) a)->t[0]) > *(double *) (&((Nsrt *) b)->t[0])) + return 1; + else if (*(double *) (&((Nsrt *) a)->t[0]) < *(double *) (&((Nsrt *) b)->t[0])) + return -1; + return 0; } -static const gbtree_ninfo tinfo = +static const gbtree_ninfo tinfo = { - gbt_t_inet, - sizeof(double), - gbt_inetgt, - gbt_inetge, - gbt_ineteq, - gbt_inetle, - gbt_inetlt, - gbt_inetkey_cmp + gbt_t_inet, + sizeof(double), + gbt_inetgt, + gbt_inetge, + gbt_ineteq, + gbt_inetle, + gbt_inetlt, + gbt_inetkey_cmp }; @@ -87,24 +90,25 @@ static const gbtree_ninfo tinfo = -static GISTENTRY * -gbt_inet_compress_inetrnal(GISTENTRY *retval , GISTENTRY *entry , Oid typid) +static GISTENTRY * +gbt_inet_compress_inetrnal(GISTENTRY *retval, GISTENTRY *entry, Oid typid) { - - if (entry->leafkey) - { - inetKEY *r = (inetKEY *) palloc(sizeof(inetKEY)); - retval = palloc(sizeof(GISTENTRY)); - r->lower = convert_network_to_scalar(entry->key, typid ); - r->upper = r->lower ; - gistentryinit(*retval, PointerGetDatum(r), - entry->rel, entry->page, - entry->offset, sizeof(inetKEY), FALSE); - } - else - retval = entry; - return ( retval ); + if (entry->leafkey) + { + inetKEY *r = (inetKEY *) palloc(sizeof(inetKEY)); + + retval = palloc(sizeof(GISTENTRY)); + r->lower = convert_network_to_scalar(entry->key, typid); + r->upper = r->lower; + gistentryinit(*retval, PointerGetDatum(r), + entry->rel, entry->page, + entry->offset, sizeof(inetKEY), FALSE); + } + else + retval = entry; + + return (retval); } @@ -112,113 +116,118 @@ gbt_inet_compress_inetrnal(GISTENTRY *retval , GISTENTRY *entry , Oid typid) Datum gbt_inet_compress(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - GISTENTRY *retval = NULL; - PG_RETURN_POINTER( gbt_inet_compress_inetrnal(retval ,entry ,INETOID ) ); + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + GISTENTRY *retval = NULL; + + PG_RETURN_POINTER(gbt_inet_compress_inetrnal(retval, entry, INETOID)); } Datum gbt_cidr_compress(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - GISTENTRY *retval = NULL; - PG_RETURN_POINTER( gbt_inet_compress_inetrnal(retval ,entry ,CIDROID ) ); + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + GISTENTRY *retval = NULL; + + PG_RETURN_POINTER(gbt_inet_compress_inetrnal(retval, entry, CIDROID)); } static bool -gbt_inet_consistent_internal ( - const GISTENTRY * entry, - const double * query, - const StrategyNumber * strategy -){ - inetKEY *kkk = (inetKEY *) DatumGetPointer(entry->key); - GBT_NUMKEY_R key ; +gbt_inet_consistent_internal( + const GISTENTRY *entry, + const double *query, + const StrategyNumber *strategy +) +{ + inetKEY *kkk = (inetKEY *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + + key.lower = (GBT_NUMKEY *) & kkk->lower; + key.upper = (GBT_NUMKEY *) & kkk->upper; - key.lower = (GBT_NUMKEY*) &kkk->lower ; - key.upper = (GBT_NUMKEY*) &kkk->upper ; - - return ( - gbt_num_consistent( &key, (void*)query,strategy,GIST_LEAF(entry),&tinfo) - ); + return ( + gbt_num_consistent(&key, (void *) query, strategy, GIST_LEAF(entry), &tinfo) + ); } Datum gbt_inet_consistent(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - double query = convert_network_to_scalar( PG_GETARG_DATUM(1) ,INETOID ); - StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + double query = convert_network_to_scalar(PG_GETARG_DATUM(1), INETOID); + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); - PG_RETURN_BOOL( - gbt_inet_consistent_internal ( entry, &query, &strategy ) - ); + PG_RETURN_BOOL( + gbt_inet_consistent_internal(entry, &query, &strategy) + ); } Datum gbt_cidr_consistent(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - double query = convert_network_to_scalar( PG_GETARG_DATUM(1) ,CIDROID ); - StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + double query = convert_network_to_scalar(PG_GETARG_DATUM(1), CIDROID); + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); - PG_RETURN_BOOL( - gbt_inet_consistent_internal ( entry, &query, &strategy ) - ); + PG_RETURN_BOOL( + gbt_inet_consistent_internal(entry, &query, &strategy) + ); } Datum gbt_inet_union(PG_FUNCTION_ARGS) { - GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); - void *out = palloc(sizeof(inetKEY)); - *(int *) PG_GETARG_POINTER(1) = sizeof(inetKEY); - PG_RETURN_POINTER( gbt_num_union ( (void*)out, entryvec, &tinfo ) ); + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + void *out = palloc(sizeof(inetKEY)); + + *(int *) PG_GETARG_POINTER(1) = sizeof(inetKEY); + PG_RETURN_POINTER(gbt_num_union((void *) out, entryvec, &tinfo)); } Datum gbt_inet_penalty(PG_FUNCTION_ARGS) { - inetKEY *origentry = (inetKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); - inetKEY *newentry = (inetKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); - float *result = (float *) PG_GETARG_POINTER(2); + inetKEY *origentry = (inetKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); + inetKEY *newentry = (inetKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); + float *result = (float *) PG_GETARG_POINTER(2); - double res ; + double res; - *result = 0.0; + *result = 0.0; - penalty_range_enlarge ( origentry->lower, origentry->upper, newentry->lower, newentry->upper ); + penalty_range_enlarge(origentry->lower, origentry->upper, newentry->lower, newentry->upper); - if ( res > 0 ){ - *result += FLT_MIN ; - *result += (float) ( res / ( (double) ( res + origentry->upper - origentry->lower ) ) ); - *result *= ( FLT_MAX / ( ( (GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1 ) ); - } + if (res > 0) + { + *result += FLT_MIN; + *result += (float) (res / ((double) (res + origentry->upper - origentry->lower))); + *result *= (FLT_MAX / (((GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1)); + } - PG_RETURN_POINTER(result); + PG_RETURN_POINTER(result); } Datum gbt_inet_picksplit(PG_FUNCTION_ARGS) { - PG_RETURN_POINTER(gbt_num_picksplit( - (GistEntryVector *) PG_GETARG_POINTER(0), - (GIST_SPLITVEC *) PG_GETARG_POINTER(1), - &tinfo - )); + PG_RETURN_POINTER(gbt_num_picksplit( + (GistEntryVector *) PG_GETARG_POINTER(0), + (GIST_SPLITVEC *) PG_GETARG_POINTER(1), + &tinfo + )); } Datum gbt_inet_same(PG_FUNCTION_ARGS) { - inetKEY *b1 = (inetKEY *) PG_GETARG_POINTER(0); - inetKEY *b2 = (inetKEY *) PG_GETARG_POINTER(1); - bool *result = (bool *) PG_GETARG_POINTER(2); + inetKEY *b1 = (inetKEY *) PG_GETARG_POINTER(0); + inetKEY *b2 = (inetKEY *) PG_GETARG_POINTER(1); + bool *result = (bool *) PG_GETARG_POINTER(2); - *result = gbt_num_same ( (void*)b1, (void*)b2, &tinfo ); - PG_RETURN_POINTER(result); + *result = gbt_num_same((void *) b1, (void *) b2, &tinfo); + PG_RETURN_POINTER(result); } diff --git a/contrib/btree_gist/btree_int2.c b/contrib/btree_gist/btree_int2.c index 9b791df2c3..3eb5801a7e 100644 --- a/contrib/btree_gist/btree_int2.c +++ b/contrib/btree_gist/btree_int2.c @@ -3,9 +3,9 @@ typedef struct int16key { - int16 lower; - int16 upper; -} int16KEY; + int16 lower; + int16 upper; +} int16KEY; /* ** int16 ops @@ -17,59 +17,62 @@ PG_FUNCTION_INFO_V1(gbt_int2_consistent); PG_FUNCTION_INFO_V1(gbt_int2_penalty); PG_FUNCTION_INFO_V1(gbt_int2_same); -Datum gbt_int2_compress(PG_FUNCTION_ARGS); -Datum gbt_int2_union(PG_FUNCTION_ARGS); -Datum gbt_int2_picksplit(PG_FUNCTION_ARGS); -Datum gbt_int2_consistent(PG_FUNCTION_ARGS); -Datum gbt_int2_penalty(PG_FUNCTION_ARGS); -Datum gbt_int2_same(PG_FUNCTION_ARGS); +Datum gbt_int2_compress(PG_FUNCTION_ARGS); +Datum gbt_int2_union(PG_FUNCTION_ARGS); +Datum gbt_int2_picksplit(PG_FUNCTION_ARGS); +Datum gbt_int2_consistent(PG_FUNCTION_ARGS); +Datum gbt_int2_penalty(PG_FUNCTION_ARGS); +Datum gbt_int2_same(PG_FUNCTION_ARGS); -static bool gbt_int2gt (const void *a, const void *b) +static bool +gbt_int2gt(const void *a, const void *b) { - return ( *((int16*)a) > *((int16*)b) ); + return (*((int16 *) a) > *((int16 *) b)); } -static bool gbt_int2ge (const void *a, const void *b) +static bool +gbt_int2ge(const void *a, const void *b) { - return ( *((int16*)a) >= *((int16*)b) ); + return (*((int16 *) a) >= *((int16 *) b)); } -static bool gbt_int2eq (const void *a, const void *b) +static bool +gbt_int2eq(const void *a, const void *b) { - return ( *((int16*)a) == *((int16*)b) ); + return (*((int16 *) a) == *((int16 *) b)); } -static bool gbt_int2le (const void *a, const void *b) +static bool +gbt_int2le(const void *a, const void *b) { - return ( *((int16*)a) <= *((int16*)b) ); + return (*((int16 *) a) <= *((int16 *) b)); } -static bool gbt_int2lt (const void *a, const void *b) +static bool +gbt_int2lt(const void *a, const void *b) { - return ( *((int16*)a) < *((int16*)b) ); + return (*((int16 *) a) < *((int16 *) b)); } static int gbt_int2key_cmp(const void *a, const void *b) { - if ( *(int16*)(&((Nsrt *) a)->t[0]) > *(int16*)&(((Nsrt *) b)->t[0]) ){ - return 1; - } else - if ( *(int16*)&(((Nsrt *) a)->t[0]) < *(int16*)&(((Nsrt *) b)->t[0]) ){ - return -1; - } - return 0; + if (*(int16 *) (&((Nsrt *) a)->t[0]) > *(int16 *) &(((Nsrt *) b)->t[0])) + return 1; + else if (*(int16 *) &(((Nsrt *) a)->t[0]) < *(int16 *) &(((Nsrt *) b)->t[0])) + return -1; + return 0; } -static const gbtree_ninfo tinfo = -{ - gbt_t_int2, - sizeof(int16), - gbt_int2gt, - gbt_int2ge, - gbt_int2eq, - gbt_int2le, - gbt_int2lt, - gbt_int2key_cmp +static const gbtree_ninfo tinfo = +{ + gbt_t_int2, + sizeof(int16), + gbt_int2gt, + gbt_int2ge, + gbt_int2eq, + gbt_int2le, + gbt_int2lt, + gbt_int2key_cmp }; @@ -85,77 +88,81 @@ static const gbtree_ninfo tinfo = Datum gbt_int2_compress(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - GISTENTRY *retval = NULL; - PG_RETURN_POINTER( gbt_num_compress( retval , entry , &tinfo )); + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + GISTENTRY *retval = NULL; + + PG_RETURN_POINTER(gbt_num_compress(retval, entry, &tinfo)); } Datum gbt_int2_consistent(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - int16 query = PG_GETARG_INT16(1); - int16KEY *kkk = (int16KEY *) DatumGetPointer(entry->key); - GBT_NUMKEY_R key ; - StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); - key.lower = (GBT_NUMKEY*) &kkk->lower ; - key.upper = (GBT_NUMKEY*) &kkk->upper ; - - PG_RETURN_BOOL( - gbt_num_consistent( &key, (void*)&query,&strategy,GIST_LEAF(entry),&tinfo) - ); + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + int16 query = PG_GETARG_INT16(1); + int16KEY *kkk = (int16KEY *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + + key.lower = (GBT_NUMKEY *) & kkk->lower; + key.upper = (GBT_NUMKEY *) & kkk->upper; + + PG_RETURN_BOOL( + gbt_num_consistent(&key, (void *) &query, &strategy, GIST_LEAF(entry), &tinfo) + ); } Datum gbt_int2_union(PG_FUNCTION_ARGS) { - GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); - void *out = palloc(sizeof(int16KEY)); - *(int *) PG_GETARG_POINTER(1) = sizeof(int16KEY); - PG_RETURN_POINTER( gbt_num_union ( (void*)out, entryvec, &tinfo ) ); + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + void *out = palloc(sizeof(int16KEY)); + + *(int *) PG_GETARG_POINTER(1) = sizeof(int16KEY); + PG_RETURN_POINTER(gbt_num_union((void *) out, entryvec, &tinfo)); } Datum gbt_int2_penalty(PG_FUNCTION_ARGS) { - int16KEY *origentry = (int16KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); - int16KEY *newentry = (int16KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); - float *result = (float *) PG_GETARG_POINTER(2); - int2 res ; + int16KEY *origentry = (int16KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); + int16KEY *newentry = (int16KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); + float *result = (float *) PG_GETARG_POINTER(2); + int2 res; - *result = 0.0; + *result = 0.0; - penalty_range_enlarge ( origentry->lower, origentry->upper, newentry->lower, newentry->upper ); + penalty_range_enlarge(origentry->lower, origentry->upper, newentry->lower, newentry->upper); - if ( res > 0 ){ - *result += FLT_MIN ; - *result += (float) ( res / ( (double) ( res + origentry->upper - origentry->lower ) ) ); - *result *= ( FLT_MAX / ( ( (GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1 ) ); - } + if (res > 0) + { + *result += FLT_MIN; + *result += (float) (res / ((double) (res + origentry->upper - origentry->lower))); + *result *= (FLT_MAX / (((GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1)); + } - PG_RETURN_POINTER(result); + PG_RETURN_POINTER(result); } Datum gbt_int2_picksplit(PG_FUNCTION_ARGS) { - PG_RETURN_POINTER(gbt_num_picksplit( - (GistEntryVector *) PG_GETARG_POINTER(0), - (GIST_SPLITVEC *) PG_GETARG_POINTER(1), - &tinfo - )); + PG_RETURN_POINTER(gbt_num_picksplit( + (GistEntryVector *) PG_GETARG_POINTER(0), + (GIST_SPLITVEC *) PG_GETARG_POINTER(1), + &tinfo + )); } Datum gbt_int2_same(PG_FUNCTION_ARGS) { - int16KEY *b1 = (int16KEY *) PG_GETARG_POINTER(0); - int16KEY *b2 = (int16KEY *) PG_GETARG_POINTER(1); - bool *result = (bool *) PG_GETARG_POINTER(2); + int16KEY *b1 = (int16KEY *) PG_GETARG_POINTER(0); + int16KEY *b2 = (int16KEY *) PG_GETARG_POINTER(1); + bool *result = (bool *) PG_GETARG_POINTER(2); - *result = gbt_num_same ( (void*)b1, (void*)b2, &tinfo ); - PG_RETURN_POINTER(result); + *result = gbt_num_same((void *) b1, (void *) b2, &tinfo); + PG_RETURN_POINTER(result); } diff --git a/contrib/btree_gist/btree_int4.c b/contrib/btree_gist/btree_int4.c index 6e26752e5f..6693185c98 100644 --- a/contrib/btree_gist/btree_int4.c +++ b/contrib/btree_gist/btree_int4.c @@ -3,9 +3,9 @@ typedef struct int32key { - int32 lower; - int32 upper; -} int32KEY; + int32 lower; + int32 upper; +} int32KEY; /* ** int32 ops @@ -17,60 +17,63 @@ PG_FUNCTION_INFO_V1(gbt_int4_consistent); PG_FUNCTION_INFO_V1(gbt_int4_penalty); PG_FUNCTION_INFO_V1(gbt_int4_same); -Datum gbt_int4_compress(PG_FUNCTION_ARGS); -Datum gbt_int4_union(PG_FUNCTION_ARGS); -Datum gbt_int4_picksplit(PG_FUNCTION_ARGS); -Datum gbt_int4_consistent(PG_FUNCTION_ARGS); -Datum gbt_int4_penalty(PG_FUNCTION_ARGS); -Datum gbt_int4_same(PG_FUNCTION_ARGS); +Datum gbt_int4_compress(PG_FUNCTION_ARGS); +Datum gbt_int4_union(PG_FUNCTION_ARGS); +Datum gbt_int4_picksplit(PG_FUNCTION_ARGS); +Datum gbt_int4_consistent(PG_FUNCTION_ARGS); +Datum gbt_int4_penalty(PG_FUNCTION_ARGS); +Datum gbt_int4_same(PG_FUNCTION_ARGS); -static bool gbt_int4gt (const void *a, const void *b) +static bool +gbt_int4gt(const void *a, const void *b) { - return ( *((int32*)a) > *((int32*)b) ); + return (*((int32 *) a) > *((int32 *) b)); } -static bool gbt_int4ge (const void *a, const void *b) +static bool +gbt_int4ge(const void *a, const void *b) { - return ( *((int32*)a) >= *((int32*)b) ); + return (*((int32 *) a) >= *((int32 *) b)); } -static bool gbt_int4eq (const void *a, const void *b) +static bool +gbt_int4eq(const void *a, const void *b) { - return ( *((int32*)a) == *((int32*)b) ); + return (*((int32 *) a) == *((int32 *) b)); } -static bool gbt_int4le (const void *a, const void *b) +static bool +gbt_int4le(const void *a, const void *b) { - return ( *((int32*)a) <= *((int32*)b) ); + return (*((int32 *) a) <= *((int32 *) b)); } -static bool gbt_int4lt (const void *a, const void *b) +static bool +gbt_int4lt(const void *a, const void *b) { - return ( *((int32*)a) < *((int32*)b) ); + return (*((int32 *) a) < *((int32 *) b)); } static int gbt_int4key_cmp(const void *a, const void *b) { - if ( *(int32*)&(((Nsrt *) a)->t[0]) > *(int32*)&(((Nsrt *) b)->t[0]) ){ - return 1; - } else - if ( *(int32*)&(((Nsrt *) a)->t[0]) < *(int32*)&(((Nsrt *) b)->t[0]) ){ - return -1; - } - return 0; + if (*(int32 *) &(((Nsrt *) a)->t[0]) > *(int32 *) &(((Nsrt *) b)->t[0])) + return 1; + else if (*(int32 *) &(((Nsrt *) a)->t[0]) < *(int32 *) &(((Nsrt *) b)->t[0])) + return -1; + return 0; } -static const gbtree_ninfo tinfo = -{ - gbt_t_int4, - sizeof(int32), - gbt_int4gt, - gbt_int4ge, - gbt_int4eq, - gbt_int4le, - gbt_int4lt, - gbt_int4key_cmp +static const gbtree_ninfo tinfo = +{ + gbt_t_int4, + sizeof(int32), + gbt_int4gt, + gbt_int4ge, + gbt_int4eq, + gbt_int4le, + gbt_int4lt, + gbt_int4key_cmp }; @@ -82,9 +85,10 @@ static const gbtree_ninfo tinfo = Datum gbt_int4_compress(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - GISTENTRY *retval = NULL; - PG_RETURN_POINTER( gbt_num_compress( retval , entry , &tinfo )); + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + GISTENTRY *retval = NULL; + + PG_RETURN_POINTER(gbt_num_compress(retval, entry, &tinfo)); } @@ -92,68 +96,71 @@ Datum gbt_int4_consistent(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - int32 query = PG_GETARG_INT32(1); - int32KEY *kkk = (int32KEY *) DatumGetPointer(entry->key); - GBT_NUMKEY_R key ; - StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); - key.lower = (GBT_NUMKEY*) &kkk->lower ; - key.upper = (GBT_NUMKEY*) &kkk->upper ; - - PG_RETURN_BOOL( - gbt_num_consistent( &key, (void*)&query,&strategy,GIST_LEAF(entry),&tinfo) - ); + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + int32 query = PG_GETARG_INT32(1); + int32KEY *kkk = (int32KEY *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + + key.lower = (GBT_NUMKEY *) & kkk->lower; + key.upper = (GBT_NUMKEY *) & kkk->upper; + + PG_RETURN_BOOL( + gbt_num_consistent(&key, (void *) &query, &strategy, GIST_LEAF(entry), &tinfo) + ); } Datum gbt_int4_union(PG_FUNCTION_ARGS) { - GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); - void *out = palloc( sizeof(int32KEY) ); - *(int *) PG_GETARG_POINTER(1) = sizeof(int32KEY); - PG_RETURN_POINTER( gbt_num_union ( (void*)out, entryvec, &tinfo ) ); + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + void *out = palloc(sizeof(int32KEY)); + + *(int *) PG_GETARG_POINTER(1) = sizeof(int32KEY); + PG_RETURN_POINTER(gbt_num_union((void *) out, entryvec, &tinfo)); } Datum gbt_int4_penalty(PG_FUNCTION_ARGS) { - int32KEY *origentry = (int32KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); - int32KEY *newentry = (int32KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); - float *result = (float *) PG_GETARG_POINTER(2); - int4 res ; + int32KEY *origentry = (int32KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); + int32KEY *newentry = (int32KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); + float *result = (float *) PG_GETARG_POINTER(2); + int4 res; - *result = 0.0; + *result = 0.0; - penalty_range_enlarge ( origentry->lower, origentry->upper, newentry->lower, newentry->upper ); + penalty_range_enlarge(origentry->lower, origentry->upper, newentry->lower, newentry->upper); - if ( res > 0 ){ - *result += FLT_MIN ; - *result += (float) ( res / ( (double) ( res + origentry->upper - origentry->lower ) ) ); - *result *= ( FLT_MAX / ( ( (GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1 ) ); - } + if (res > 0) + { + *result += FLT_MIN; + *result += (float) (res / ((double) (res + origentry->upper - origentry->lower))); + *result *= (FLT_MAX / (((GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1)); + } - PG_RETURN_POINTER(result); + PG_RETURN_POINTER(result); } Datum gbt_int4_picksplit(PG_FUNCTION_ARGS) { - PG_RETURN_POINTER(gbt_num_picksplit( - (GistEntryVector *) PG_GETARG_POINTER(0), - (GIST_SPLITVEC *) PG_GETARG_POINTER(1), - &tinfo - )); + PG_RETURN_POINTER(gbt_num_picksplit( + (GistEntryVector *) PG_GETARG_POINTER(0), + (GIST_SPLITVEC *) PG_GETARG_POINTER(1), + &tinfo + )); } Datum gbt_int4_same(PG_FUNCTION_ARGS) { - int32KEY *b1 = (int32KEY *) PG_GETARG_POINTER(0); - int32KEY *b2 = (int32KEY *) PG_GETARG_POINTER(1); - bool *result = (bool *) PG_GETARG_POINTER(2); + int32KEY *b1 = (int32KEY *) PG_GETARG_POINTER(0); + int32KEY *b2 = (int32KEY *) PG_GETARG_POINTER(1); + bool *result = (bool *) PG_GETARG_POINTER(2); - *result = gbt_num_same ( (void*)b1, (void*)b2, &tinfo ); - PG_RETURN_POINTER(result); + *result = gbt_num_same((void *) b1, (void *) b2, &tinfo); + PG_RETURN_POINTER(result); } diff --git a/contrib/btree_gist/btree_int8.c b/contrib/btree_gist/btree_int8.c index c12d078f4c..0741193c6f 100644 --- a/contrib/btree_gist/btree_int8.c +++ b/contrib/btree_gist/btree_int8.c @@ -3,9 +3,9 @@ typedef struct int64key { - int64 lower; - int64 upper; -} int64KEY; + int64 lower; + int64 upper; +} int64KEY; /* ** int64 ops @@ -17,60 +17,63 @@ PG_FUNCTION_INFO_V1(gbt_int8_consistent); PG_FUNCTION_INFO_V1(gbt_int8_penalty); PG_FUNCTION_INFO_V1(gbt_int8_same); -Datum gbt_int8_compress(PG_FUNCTION_ARGS); -Datum gbt_int8_union(PG_FUNCTION_ARGS); -Datum gbt_int8_picksplit(PG_FUNCTION_ARGS); -Datum gbt_int8_consistent(PG_FUNCTION_ARGS); -Datum gbt_int8_penalty(PG_FUNCTION_ARGS); -Datum gbt_int8_same(PG_FUNCTION_ARGS); +Datum gbt_int8_compress(PG_FUNCTION_ARGS); +Datum gbt_int8_union(PG_FUNCTION_ARGS); +Datum gbt_int8_picksplit(PG_FUNCTION_ARGS); +Datum gbt_int8_consistent(PG_FUNCTION_ARGS); +Datum gbt_int8_penalty(PG_FUNCTION_ARGS); +Datum gbt_int8_same(PG_FUNCTION_ARGS); -static bool gbt_int8gt (const void *a, const void *b) +static bool +gbt_int8gt(const void *a, const void *b) { - return ( *((int64*)a) > *((int64*)b) ); + return (*((int64 *) a) > *((int64 *) b)); } -static bool gbt_int8ge (const void *a, const void *b) +static bool +gbt_int8ge(const void *a, const void *b) { - return ( *((int64*)a) >= *((int64*)b) ); + return (*((int64 *) a) >= *((int64 *) b)); } -static bool gbt_int8eq (const void *a, const void *b) +static bool +gbt_int8eq(const void *a, const void *b) { - return ( *((int64*)a) == *((int64*)b) ); + return (*((int64 *) a) == *((int64 *) b)); } -static bool gbt_int8le (const void *a, const void *b) +static bool +gbt_int8le(const void *a, const void *b) { - return ( *((int64*)a) <= *((int64*)b) ); + return (*((int64 *) a) <= *((int64 *) b)); } -static bool gbt_int8lt (const void *a, const void *b) +static bool +gbt_int8lt(const void *a, const void *b) { - return ( *((int64*)a) < *((int64*)b) ); + return (*((int64 *) a) < *((int64 *) b)); } static int gbt_int8key_cmp(const void *a, const void *b) { - if ( *(int64*)&(((Nsrt *) a)->t[0]) > *(int64*)&(((Nsrt *) b)->t[0]) ){ - return 1; - } else - if ( *(int64*)&(((Nsrt *) a)->t[0]) < *(int64*)&(((Nsrt *) b)->t[0]) ){ - return -1; - } - return 0; + if (*(int64 *) &(((Nsrt *) a)->t[0]) > *(int64 *) &(((Nsrt *) b)->t[0])) + return 1; + else if (*(int64 *) &(((Nsrt *) a)->t[0]) < *(int64 *) &(((Nsrt *) b)->t[0])) + return -1; + return 0; } -static const gbtree_ninfo tinfo = +static const gbtree_ninfo tinfo = { - gbt_t_int8, - sizeof(int64), - gbt_int8gt, - gbt_int8ge, - gbt_int8eq, - gbt_int8le, - gbt_int8lt, - gbt_int8key_cmp + gbt_t_int8, + sizeof(int64), + gbt_int8gt, + gbt_int8ge, + gbt_int8eq, + gbt_int8le, + gbt_int8lt, + gbt_int8key_cmp }; @@ -82,79 +85,82 @@ static const gbtree_ninfo tinfo = Datum gbt_int8_compress(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - GISTENTRY *retval = NULL; - PG_RETURN_POINTER( gbt_num_compress( retval , entry , &tinfo )); + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + GISTENTRY *retval = NULL; + + PG_RETURN_POINTER(gbt_num_compress(retval, entry, &tinfo)); } Datum gbt_int8_consistent(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - int64 query = PG_GETARG_INT64(1); - int64KEY *kkk = (int64KEY *) DatumGetPointer(entry->key); - GBT_NUMKEY_R key ; - StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); - key.lower = (GBT_NUMKEY*) &kkk->lower ; - key.upper = (GBT_NUMKEY*) &kkk->upper ; - - PG_RETURN_BOOL( - gbt_num_consistent( &key, (void*)&query,&strategy,GIST_LEAF(entry),&tinfo) - ); + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + int64 query = PG_GETARG_INT64(1); + int64KEY *kkk = (int64KEY *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + + key.lower = (GBT_NUMKEY *) & kkk->lower; + key.upper = (GBT_NUMKEY *) & kkk->upper; + + PG_RETURN_BOOL( + gbt_num_consistent(&key, (void *) &query, &strategy, GIST_LEAF(entry), &tinfo) + ); } Datum gbt_int8_union(PG_FUNCTION_ARGS) { - GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); - void *out = palloc(sizeof(int64KEY)); - *(int *) PG_GETARG_POINTER(1) = sizeof(int64KEY); - PG_RETURN_POINTER( gbt_num_union ( (void*)out, entryvec, &tinfo ) ); + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + void *out = palloc(sizeof(int64KEY)); + + *(int *) PG_GETARG_POINTER(1) = sizeof(int64KEY); + PG_RETURN_POINTER(gbt_num_union((void *) out, entryvec, &tinfo)); } Datum gbt_int8_penalty(PG_FUNCTION_ARGS) { - int64KEY *origentry = (int64KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); - int64KEY *newentry = (int64KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); - float *result = (float *) PG_GETARG_POINTER(2); - int64 res ; + int64KEY *origentry = (int64KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); + int64KEY *newentry = (int64KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); + float *result = (float *) PG_GETARG_POINTER(2); + int64 res; - *result = 0.0; + *result = 0.0; - penalty_range_enlarge ( origentry->lower, origentry->upper, newentry->lower, newentry->upper ); + penalty_range_enlarge(origentry->lower, origentry->upper, newentry->lower, newentry->upper); - if ( res > 0 ){ - *result += FLT_MIN ; - *result += (float) ( res / ( (double) ( res + origentry->upper - origentry->lower ) ) ); - *result *= ( FLT_MAX / ( ( (GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1 ) ); - } + if (res > 0) + { + *result += FLT_MIN; + *result += (float) (res / ((double) (res + origentry->upper - origentry->lower))); + *result *= (FLT_MAX / (((GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1)); + } - PG_RETURN_POINTER(result); + PG_RETURN_POINTER(result); } Datum gbt_int8_picksplit(PG_FUNCTION_ARGS) { - PG_RETURN_POINTER(gbt_num_picksplit( - (GistEntryVector *) PG_GETARG_POINTER(0), - (GIST_SPLITVEC *) PG_GETARG_POINTER(1), - &tinfo - )); + PG_RETURN_POINTER(gbt_num_picksplit( + (GistEntryVector *) PG_GETARG_POINTER(0), + (GIST_SPLITVEC *) PG_GETARG_POINTER(1), + &tinfo + )); } Datum gbt_int8_same(PG_FUNCTION_ARGS) { - int64KEY *b1 = (int64KEY *) PG_GETARG_POINTER(0); - int64KEY *b2 = (int64KEY *) PG_GETARG_POINTER(1); - bool *result = (bool *) PG_GETARG_POINTER(2); + int64KEY *b1 = (int64KEY *) PG_GETARG_POINTER(0); + int64KEY *b2 = (int64KEY *) PG_GETARG_POINTER(1); + bool *result = (bool *) PG_GETARG_POINTER(2); - *result = gbt_num_same ( (void*)b1, (void*)b2, &tinfo ); - PG_RETURN_POINTER(result); + *result = gbt_num_same((void *) b1, (void *) b2, &tinfo); + PG_RETURN_POINTER(result); } - diff --git a/contrib/btree_gist/btree_interval.c b/contrib/btree_gist/btree_interval.c index 9dd3701084..97374a4054 100644 --- a/contrib/btree_gist/btree_interval.c +++ b/contrib/btree_gist/btree_interval.c @@ -3,8 +3,9 @@ typedef struct { - Interval lower, upper; -} intvKEY; + Interval lower, + upper; +} intvKEY; /* @@ -18,81 +19,88 @@ PG_FUNCTION_INFO_V1(gbt_intv_consistent); PG_FUNCTION_INFO_V1(gbt_intv_penalty); PG_FUNCTION_INFO_V1(gbt_intv_same); -Datum gbt_intv_compress(PG_FUNCTION_ARGS); -Datum gbt_intv_decompress(PG_FUNCTION_ARGS); -Datum gbt_intv_union(PG_FUNCTION_ARGS); -Datum gbt_intv_picksplit(PG_FUNCTION_ARGS); -Datum gbt_intv_consistent(PG_FUNCTION_ARGS); -Datum gbt_intv_penalty(PG_FUNCTION_ARGS); -Datum gbt_intv_same(PG_FUNCTION_ARGS); +Datum gbt_intv_compress(PG_FUNCTION_ARGS); +Datum gbt_intv_decompress(PG_FUNCTION_ARGS); +Datum gbt_intv_union(PG_FUNCTION_ARGS); +Datum gbt_intv_picksplit(PG_FUNCTION_ARGS); +Datum gbt_intv_consistent(PG_FUNCTION_ARGS); +Datum gbt_intv_penalty(PG_FUNCTION_ARGS); +Datum gbt_intv_same(PG_FUNCTION_ARGS); -static bool gbt_intvgt (const void *a, const void *b) +static bool +gbt_intvgt(const void *a, const void *b) { - return DatumGetBool(DirectFunctionCall2 ( interval_gt , IntervalPGetDatum ( a ) , IntervalPGetDatum ( b ) )); + return DatumGetBool(DirectFunctionCall2(interval_gt, IntervalPGetDatum(a), IntervalPGetDatum(b))); } -static bool gbt_intvge (const void *a, const void *b) +static bool +gbt_intvge(const void *a, const void *b) { - return DatumGetBool(DirectFunctionCall2 ( interval_ge , IntervalPGetDatum ( a ) , IntervalPGetDatum ( b ) )); + return DatumGetBool(DirectFunctionCall2(interval_ge, IntervalPGetDatum(a), IntervalPGetDatum(b))); } -static bool gbt_intveq (const void *a, const void *b) +static bool +gbt_intveq(const void *a, const void *b) { - return DatumGetBool(DirectFunctionCall2 ( interval_eq , IntervalPGetDatum ( a ) , IntervalPGetDatum ( b ) )); + return DatumGetBool(DirectFunctionCall2(interval_eq, IntervalPGetDatum(a), IntervalPGetDatum(b))); } -static bool gbt_intvle (const void *a, const void *b) +static bool +gbt_intvle(const void *a, const void *b) { - return DatumGetBool(DirectFunctionCall2 ( interval_le , IntervalPGetDatum ( a ) , IntervalPGetDatum ( b ) )); + return DatumGetBool(DirectFunctionCall2(interval_le, IntervalPGetDatum(a), IntervalPGetDatum(b))); } -static bool gbt_intvlt (const void *a, const void *b) +static bool +gbt_intvlt(const void *a, const void *b) { - return DatumGetBool(DirectFunctionCall2 ( interval_lt , IntervalPGetDatum ( a ) , IntervalPGetDatum ( b ) )); + return DatumGetBool(DirectFunctionCall2(interval_lt, IntervalPGetDatum(a), IntervalPGetDatum(b))); } static int gbt_intvkey_cmp(const void *a, const void *b) { - return DatumGetInt32 ( - DirectFunctionCall2 ( interval_cmp , - IntervalPGetDatum(((Nsrt *) a)->t) , - IntervalPGetDatum(((Nsrt *) b)->t) - ) - ); + return DatumGetInt32( + DirectFunctionCall2(interval_cmp, + IntervalPGetDatum(((Nsrt *) a)->t), + IntervalPGetDatum(((Nsrt *) b)->t) + ) + ); } -static double intr2num ( const Interval * i ) +static double +intr2num(const Interval *i) { - double ret = 0.0; - struct pg_tm tm; - fsec_t fsec; - interval2tm( *i, &tm, &fsec); - ret += ( tm.tm_year * 360.0 * 86400.0 ) ; - ret += ( tm.tm_mon * 12.0 * 86400.0 ) ; - ret += ( tm.tm_mday * 86400.0 ) ; - ret += ( tm.tm_hour * 3600.0 ) ; - ret += ( tm.tm_min * 60.0 ) ; - ret += ( tm.tm_sec ) ; - ret += ( fsec / 1000000.0 ); + double ret = 0.0; + struct pg_tm tm; + fsec_t fsec; - return ( ret ); + interval2tm(*i, &tm, &fsec); + ret += (tm.tm_year * 360.0 * 86400.0); + ret += (tm.tm_mon * 12.0 * 86400.0); + ret += (tm.tm_mday * 86400.0); + ret += (tm.tm_hour * 3600.0); + ret += (tm.tm_min * 60.0); + ret += (tm.tm_sec); + ret += (fsec / 1000000.0); + + return (ret); } #define INTERVALSIZE 12 -static const gbtree_ninfo tinfo = +static const gbtree_ninfo tinfo = { - gbt_t_intv, - sizeof(Interval), - gbt_intvgt, - gbt_intvge, - gbt_intveq, - gbt_intvle, - gbt_intvlt, - gbt_intvkey_cmp + gbt_t_intv, + sizeof(Interval), + gbt_intvgt, + gbt_intvge, + gbt_intveq, + gbt_intvle, + gbt_intvlt, + gbt_intvkey_cmp }; @@ -104,126 +112,137 @@ static const gbtree_ninfo tinfo = Datum gbt_intv_compress(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - GISTENTRY *retval = entry; - if ( entry->leafkey || INTERVALSIZE != sizeof(Interval) ) { - char *r = ( char * ) palloc(2 * INTERVALSIZE); - - retval = palloc(sizeof(GISTENTRY)); - - if ( entry->leafkey ) { - Interval *key = DatumGetIntervalP(entry->key); - memcpy( (void*) r , (void*)key, INTERVALSIZE); - memcpy( (void*)(r + INTERVALSIZE), (void*)key, INTERVALSIZE); - } else { - intvKEY *key = ( intvKEY * ) DatumGetPointer(entry->key); - memcpy(r, &key->lower, INTERVALSIZE); - memcpy(r + INTERVALSIZE, &key->upper, INTERVALSIZE); - } - gistentryinit(*retval, PointerGetDatum(r), - entry->rel, entry->page, - entry->offset, 2 * INTERVALSIZE, FALSE); - } - - PG_RETURN_POINTER(retval); + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + GISTENTRY *retval = entry; + + if (entry->leafkey || INTERVALSIZE != sizeof(Interval)) + { + char *r = (char *) palloc(2 * INTERVALSIZE); + + retval = palloc(sizeof(GISTENTRY)); + + if (entry->leafkey) + { + Interval *key = DatumGetIntervalP(entry->key); + + memcpy((void *) r, (void *) key, INTERVALSIZE); + memcpy((void *) (r + INTERVALSIZE), (void *) key, INTERVALSIZE); + } + else + { + intvKEY *key = (intvKEY *) DatumGetPointer(entry->key); + + memcpy(r, &key->lower, INTERVALSIZE); + memcpy(r + INTERVALSIZE, &key->upper, INTERVALSIZE); + } + gistentryinit(*retval, PointerGetDatum(r), + entry->rel, entry->page, + entry->offset, 2 * INTERVALSIZE, FALSE); + } + + PG_RETURN_POINTER(retval); } Datum gbt_intv_decompress(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - GISTENTRY *retval = entry; + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + GISTENTRY *retval = entry; - if ( INTERVALSIZE != sizeof(Interval) ) { - intvKEY *r = palloc(sizeof(intvKEY)); - char *key = DatumGetPointer(entry->key); + if (INTERVALSIZE != sizeof(Interval)) + { + intvKEY *r = palloc(sizeof(intvKEY)); + char *key = DatumGetPointer(entry->key); - retval = palloc(sizeof(GISTENTRY)); - memcpy( &r->lower, key, INTERVALSIZE); - memcpy( &r->upper, key+ INTERVALSIZE, INTERVALSIZE); + retval = palloc(sizeof(GISTENTRY)); + memcpy(&r->lower, key, INTERVALSIZE); + memcpy(&r->upper, key + INTERVALSIZE, INTERVALSIZE); - gistentryinit(*retval, PointerGetDatum(r), - entry->rel, entry->page, - entry->offset, sizeof(intvKEY), FALSE); - } - PG_RETURN_POINTER(retval); + gistentryinit(*retval, PointerGetDatum(r), + entry->rel, entry->page, + entry->offset, sizeof(intvKEY), FALSE); + } + PG_RETURN_POINTER(retval); } Datum gbt_intv_consistent(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - Interval *query = PG_GETARG_INTERVAL_P(1); - intvKEY *kkk = (intvKEY *) DatumGetPointer(entry->key); - GBT_NUMKEY_R key ; - StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); - - key.lower = (GBT_NUMKEY*) &kkk->lower ; - key.upper = (GBT_NUMKEY*) &kkk->upper ; - - PG_RETURN_BOOL( - gbt_num_consistent( &key, (void*)query ,&strategy,GIST_LEAF(entry),&tinfo) - ); + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + Interval *query = PG_GETARG_INTERVAL_P(1); + intvKEY *kkk = (intvKEY *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + + key.lower = (GBT_NUMKEY *) & kkk->lower; + key.upper = (GBT_NUMKEY *) & kkk->upper; + + PG_RETURN_BOOL( + gbt_num_consistent(&key, (void *) query, &strategy, GIST_LEAF(entry), &tinfo) + ); } Datum gbt_intv_union(PG_FUNCTION_ARGS) { - GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); - void *out = palloc(sizeof(intvKEY)); - *(int *) PG_GETARG_POINTER(1) = sizeof(intvKEY); - PG_RETURN_POINTER( gbt_num_union ( (void*)out, entryvec, &tinfo ) ); + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + void *out = palloc(sizeof(intvKEY)); + + *(int *) PG_GETARG_POINTER(1) = sizeof(intvKEY); + PG_RETURN_POINTER(gbt_num_union((void *) out, entryvec, &tinfo)); } Datum gbt_intv_penalty(PG_FUNCTION_ARGS) { - intvKEY *origentry = (intvKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); - intvKEY *newentry = (intvKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); - float *result = (float *) PG_GETARG_POINTER(2); - double iorg[2], inew[2], res; + intvKEY *origentry = (intvKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); + intvKEY *newentry = (intvKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); + float *result = (float *) PG_GETARG_POINTER(2); + double iorg[2], + inew[2], + res; - iorg[0] = intr2num ( &origentry->lower ); - iorg[1] = intr2num ( &origentry->upper ); - inew[0] = intr2num ( &newentry->lower ); - inew[1] = intr2num ( &newentry->upper ); + iorg[0] = intr2num(&origentry->lower); + iorg[1] = intr2num(&origentry->upper); + inew[0] = intr2num(&newentry->lower); + inew[1] = intr2num(&newentry->upper); - penalty_range_enlarge ( iorg[0], iorg[1], inew[0], inew[1] ); + penalty_range_enlarge(iorg[0], iorg[1], inew[0], inew[1]); - *result = 0.0; + *result = 0.0; - if ( res > 0 ){ - *result += FLT_MIN ; - *result += (float) ( res / ( res + iorg[1] - iorg[0] ) ); - *result *= ( FLT_MAX / ( ( (GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1 ) ); - } + if (res > 0) + { + *result += FLT_MIN; + *result += (float) (res / (res + iorg[1] - iorg[0])); + *result *= (FLT_MAX / (((GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1)); + } - PG_RETURN_POINTER(result); + PG_RETURN_POINTER(result); } Datum gbt_intv_picksplit(PG_FUNCTION_ARGS) { - PG_RETURN_POINTER(gbt_num_picksplit( - (GistEntryVector *) PG_GETARG_POINTER(0), - (GIST_SPLITVEC *) PG_GETARG_POINTER(1), - &tinfo - )); + PG_RETURN_POINTER(gbt_num_picksplit( + (GistEntryVector *) PG_GETARG_POINTER(0), + (GIST_SPLITVEC *) PG_GETARG_POINTER(1), + &tinfo + )); } Datum gbt_intv_same(PG_FUNCTION_ARGS) { - intvKEY *b1 = (intvKEY *) PG_GETARG_POINTER(0); - intvKEY *b2 = (intvKEY *) PG_GETARG_POINTER(1); - bool *result = (bool *) PG_GETARG_POINTER(2); + intvKEY *b1 = (intvKEY *) PG_GETARG_POINTER(0); + intvKEY *b2 = (intvKEY *) PG_GETARG_POINTER(1); + bool *result = (bool *) PG_GETARG_POINTER(2); - *result = gbt_num_same ( (void*)b1, (void*)b2, &tinfo ); - PG_RETURN_POINTER(result); + *result = gbt_num_same((void *) b1, (void *) b2, &tinfo); + PG_RETURN_POINTER(result); } - diff --git a/contrib/btree_gist/btree_macaddr.c b/contrib/btree_gist/btree_macaddr.c index b6e9c672f1..3f08a58655 100644 --- a/contrib/btree_gist/btree_macaddr.c +++ b/contrib/btree_gist/btree_macaddr.c @@ -5,9 +5,9 @@ typedef struct { - macaddr lower; - macaddr upper; -} macKEY; + macaddr lower; + macaddr upper; +} macKEY; /* ** OID ops @@ -19,62 +19,67 @@ PG_FUNCTION_INFO_V1(gbt_macad_consistent); PG_FUNCTION_INFO_V1(gbt_macad_penalty); PG_FUNCTION_INFO_V1(gbt_macad_same); -Datum gbt_macad_compress(PG_FUNCTION_ARGS); -Datum gbt_macad_union(PG_FUNCTION_ARGS); -Datum gbt_macad_picksplit(PG_FUNCTION_ARGS); -Datum gbt_macad_consistent(PG_FUNCTION_ARGS); -Datum gbt_macad_penalty(PG_FUNCTION_ARGS); -Datum gbt_macad_same(PG_FUNCTION_ARGS); +Datum gbt_macad_compress(PG_FUNCTION_ARGS); +Datum gbt_macad_union(PG_FUNCTION_ARGS); +Datum gbt_macad_picksplit(PG_FUNCTION_ARGS); +Datum gbt_macad_consistent(PG_FUNCTION_ARGS); +Datum gbt_macad_penalty(PG_FUNCTION_ARGS); +Datum gbt_macad_same(PG_FUNCTION_ARGS); -static bool gbt_macadgt (const void *a, const void *b) +static bool +gbt_macadgt(const void *a, const void *b) { - return DatumGetBool(DirectFunctionCall2(macaddr_gt,PointerGetDatum(a),PointerGetDatum(b))); + return DatumGetBool(DirectFunctionCall2(macaddr_gt, PointerGetDatum(a), PointerGetDatum(b))); } -static bool gbt_macadge (const void *a, const void *b) +static bool +gbt_macadge(const void *a, const void *b) { - return DatumGetBool(DirectFunctionCall2(macaddr_ge,PointerGetDatum(a),PointerGetDatum(b))); + return DatumGetBool(DirectFunctionCall2(macaddr_ge, PointerGetDatum(a), PointerGetDatum(b))); } -static bool gbt_macadeq (const void *a, const void *b) +static bool +gbt_macadeq(const void *a, const void *b) { - return DatumGetBool(DirectFunctionCall2(macaddr_eq,PointerGetDatum(a),PointerGetDatum(b))); + return DatumGetBool(DirectFunctionCall2(macaddr_eq, PointerGetDatum(a), PointerGetDatum(b))); } -static bool gbt_macadle (const void *a, const void *b) +static bool +gbt_macadle(const void *a, const void *b) { - return DatumGetBool(DirectFunctionCall2(macaddr_le,PointerGetDatum(a),PointerGetDatum(b))); + return DatumGetBool(DirectFunctionCall2(macaddr_le, PointerGetDatum(a), PointerGetDatum(b))); } -static bool gbt_macadlt (const void *a, const void *b) +static bool +gbt_macadlt(const void *a, const void *b) { - return DatumGetBool(DirectFunctionCall2(macaddr_lt,PointerGetDatum(a),PointerGetDatum(b))); + return DatumGetBool(DirectFunctionCall2(macaddr_lt, PointerGetDatum(a), PointerGetDatum(b))); } static int gbt_macadkey_cmp(const void *a, const void *b) { - return DatumGetInt32( - DirectFunctionCall2( - macaddr_cmp , - PointerGetDatum (&((Nsrt *) a)->t[0]), - PointerGetDatum (&((Nsrt *) b)->t[0]) - ) - ); + return DatumGetInt32( + DirectFunctionCall2( + macaddr_cmp, + PointerGetDatum(&((Nsrt *) a)->t[0]), + PointerGetDatum(&((Nsrt *) b)->t[0]) + ) + ); } -static const gbtree_ninfo tinfo = -{ - gbt_t_macad, - sizeof(macaddr), - gbt_macadgt, - gbt_macadge, - gbt_macadeq, - gbt_macadle, - gbt_macadlt, - gbt_macadkey_cmp +static const gbtree_ninfo tinfo = +{ + gbt_t_macad, + sizeof(macaddr), + gbt_macadgt, + gbt_macadge, + gbt_macadeq, + gbt_macadle, + gbt_macadlt, + gbt_macadkey_cmp }; @@ -84,14 +89,16 @@ static const gbtree_ninfo tinfo = -static uint64 mac_2_uint64 ( macaddr * m ){ - unsigned char * mi = ( unsigned char * ) m; - uint64 res = 0; - int i; - for (i=0; i<6; i++ ){ - res += ( ( (uint64) mi[i] ) << ( (uint64) ( (5-i)*8 ) ) ); - } - return res; +static uint64 +mac_2_uint64(macaddr *m) +{ + unsigned char *mi = (unsigned char *) m; + uint64 res = 0; + int i; + + for (i = 0; i < 6; i++) + res += (((uint64) mi[i]) << ((uint64) ((5 - i) * 8))); + return res; } @@ -99,9 +106,10 @@ static uint64 mac_2_uint64 ( macaddr * m ){ Datum gbt_macad_compress(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - GISTENTRY *retval = NULL; - PG_RETURN_POINTER( gbt_num_compress( retval , entry , &tinfo )); + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + GISTENTRY *retval = NULL; + + PG_RETURN_POINTER(gbt_num_compress(retval, entry, &tinfo)); } @@ -109,76 +117,79 @@ Datum gbt_macad_consistent(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - macaddr *query = (macaddr *) PG_GETARG_POINTER(1); - macKEY *kkk = (macKEY *) DatumGetPointer(entry->key); - GBT_NUMKEY_R key ; - StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); - key.lower = (GBT_NUMKEY*) &kkk->lower ; - key.upper = (GBT_NUMKEY*) &kkk->upper ; - - PG_RETURN_BOOL( - gbt_num_consistent( &key, (void*)query,&strategy,GIST_LEAF(entry),&tinfo) - ); + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + macaddr *query = (macaddr *) PG_GETARG_POINTER(1); + macKEY *kkk = (macKEY *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + + key.lower = (GBT_NUMKEY *) & kkk->lower; + key.upper = (GBT_NUMKEY *) & kkk->upper; + + PG_RETURN_BOOL( + gbt_num_consistent(&key, (void *) query, &strategy, GIST_LEAF(entry), &tinfo) + ); } Datum gbt_macad_union(PG_FUNCTION_ARGS) { - GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); - void *out = palloc(sizeof(macKEY)); - *(int *) PG_GETARG_POINTER(1) = sizeof(macKEY); - PG_RETURN_POINTER( gbt_num_union ( (void*)out, entryvec, &tinfo ) ); + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + void *out = palloc(sizeof(macKEY)); + + *(int *) PG_GETARG_POINTER(1) = sizeof(macKEY); + PG_RETURN_POINTER(gbt_num_union((void *) out, entryvec, &tinfo)); } Datum gbt_macad_penalty(PG_FUNCTION_ARGS) { - macKEY *origentry = (macKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); - macKEY *newentry = (macKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); - float *result = (float *) PG_GETARG_POINTER(2); - uint64 iorg[2], inew[2]; - uint64 res; + macKEY *origentry = (macKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); + macKEY *newentry = (macKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); + float *result = (float *) PG_GETARG_POINTER(2); + uint64 iorg[2], + inew[2]; + uint64 res; - iorg[0] = mac_2_uint64 ( &origentry->lower ); - iorg[1] = mac_2_uint64 ( &origentry->upper ); - inew[0] = mac_2_uint64 ( &newentry->lower ); - inew[1] = mac_2_uint64 ( &newentry->upper ); + iorg[0] = mac_2_uint64(&origentry->lower); + iorg[1] = mac_2_uint64(&origentry->upper); + inew[0] = mac_2_uint64(&newentry->lower); + inew[1] = mac_2_uint64(&newentry->upper); - penalty_range_enlarge ( iorg[0], iorg[1], inew[0], inew[1] ); + penalty_range_enlarge(iorg[0], iorg[1], inew[0], inew[1]); - *result = 0.0; + *result = 0.0; - if ( res > 0 ){ - *result += FLT_MIN ; - *result += (float) ( ( (double)res ) / ( (double)res + (double)iorg[1] - (double)iorg[0] ) ); - *result *= ( FLT_MAX / ( ( (GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1 ) ); - } + if (res > 0) + { + *result += FLT_MIN; + *result += (float) (((double) res) / ((double) res + (double) iorg[1] - (double) iorg[0])); + *result *= (FLT_MAX / (((GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1)); + } - PG_RETURN_POINTER(result); + PG_RETURN_POINTER(result); } Datum gbt_macad_picksplit(PG_FUNCTION_ARGS) { - PG_RETURN_POINTER(gbt_num_picksplit( - (GistEntryVector *) PG_GETARG_POINTER(0), - (GIST_SPLITVEC *) PG_GETARG_POINTER(1), - &tinfo - )); + PG_RETURN_POINTER(gbt_num_picksplit( + (GistEntryVector *) PG_GETARG_POINTER(0), + (GIST_SPLITVEC *) PG_GETARG_POINTER(1), + &tinfo + )); } Datum gbt_macad_same(PG_FUNCTION_ARGS) { - macKEY *b1 = (macKEY *) PG_GETARG_POINTER(0); - macKEY *b2 = (macKEY *) PG_GETARG_POINTER(1); - bool *result = (bool *) PG_GETARG_POINTER(2); + macKEY *b1 = (macKEY *) PG_GETARG_POINTER(0); + macKEY *b2 = (macKEY *) PG_GETARG_POINTER(1); + bool *result = (bool *) PG_GETARG_POINTER(2); - *result = gbt_num_same ( (void*)b1, (void*)b2, &tinfo ); - PG_RETURN_POINTER(result); + *result = gbt_num_same((void *) b1, (void *) b2, &tinfo); + PG_RETURN_POINTER(result); } - diff --git a/contrib/btree_gist/btree_numeric.c b/contrib/btree_gist/btree_numeric.c index f46cfa4fef..8b54b931d5 100644 --- a/contrib/btree_gist/btree_numeric.c +++ b/contrib/btree_gist/btree_numeric.c @@ -13,61 +13,67 @@ PG_FUNCTION_INFO_V1(gbt_numeric_consistent); PG_FUNCTION_INFO_V1(gbt_numeric_penalty); PG_FUNCTION_INFO_V1(gbt_numeric_same); -Datum gbt_numeric_compress(PG_FUNCTION_ARGS); -Datum gbt_numeric_union(PG_FUNCTION_ARGS); -Datum gbt_numeric_picksplit(PG_FUNCTION_ARGS); -Datum gbt_numeric_consistent(PG_FUNCTION_ARGS); -Datum gbt_numeric_penalty(PG_FUNCTION_ARGS); -Datum gbt_numeric_same(PG_FUNCTION_ARGS); +Datum gbt_numeric_compress(PG_FUNCTION_ARGS); +Datum gbt_numeric_union(PG_FUNCTION_ARGS); +Datum gbt_numeric_picksplit(PG_FUNCTION_ARGS); +Datum gbt_numeric_consistent(PG_FUNCTION_ARGS); +Datum gbt_numeric_penalty(PG_FUNCTION_ARGS); +Datum gbt_numeric_same(PG_FUNCTION_ARGS); /* define for comparison */ -static bool gbt_numeric_gt (const void *a, const void *b) +static bool +gbt_numeric_gt(const void *a, const void *b) { - return ( DatumGetBool(DirectFunctionCall2( numeric_gt ,PointerGetDatum( a ),PointerGetDatum( b ) ) ) ); + return (DatumGetBool(DirectFunctionCall2(numeric_gt, PointerGetDatum(a), PointerGetDatum(b)))); } -static bool gbt_numeric_ge (const void *a, const void *b) +static bool +gbt_numeric_ge(const void *a, const void *b) { - return ( DatumGetBool(DirectFunctionCall2( numeric_ge ,PointerGetDatum( a ),PointerGetDatum( b ) ) ) ); + return (DatumGetBool(DirectFunctionCall2(numeric_ge, PointerGetDatum(a), PointerGetDatum(b)))); } -static bool gbt_numeric_eq (const void *a, const void *b) +static bool +gbt_numeric_eq(const void *a, const void *b) { - return ( DatumGetBool(DirectFunctionCall2( numeric_eq ,PointerGetDatum( a ),PointerGetDatum( b ) ) ) ); + return (DatumGetBool(DirectFunctionCall2(numeric_eq, PointerGetDatum(a), PointerGetDatum(b)))); } -static bool gbt_numeric_le (const void *a, const void *b) +static bool +gbt_numeric_le(const void *a, const void *b) { - return ( DatumGetBool(DirectFunctionCall2( numeric_le ,PointerGetDatum( a ),PointerGetDatum( b ) ) ) ); + return (DatumGetBool(DirectFunctionCall2(numeric_le, PointerGetDatum(a), PointerGetDatum(b)))); } -static bool gbt_numeric_lt (const void *a, const void *b) +static bool +gbt_numeric_lt(const void *a, const void *b) { - return ( DatumGetBool(DirectFunctionCall2( numeric_lt ,PointerGetDatum( a ),PointerGetDatum( b ) ) ) ); + return (DatumGetBool(DirectFunctionCall2(numeric_lt, PointerGetDatum(a), PointerGetDatum(b)))); } - -static int32 gbt_numeric_cmp ( const bytea * a , const bytea * b ) + +static int32 +gbt_numeric_cmp(const bytea *a, const bytea *b) { - return - ( DatumGetInt32(DirectFunctionCall2(numeric_cmp,PointerGetDatum(a),PointerGetDatum(b) ) ) ); + return + (DatumGetInt32(DirectFunctionCall2(numeric_cmp, PointerGetDatum(a), PointerGetDatum(b)))); } static const gbtree_vinfo tinfo = { - gbt_t_numeric, - FALSE, - FALSE, - gbt_numeric_gt, - gbt_numeric_ge, - gbt_numeric_eq, - gbt_numeric_le, - gbt_numeric_lt, - gbt_numeric_cmp, - NULL + gbt_t_numeric, + FALSE, + FALSE, + gbt_numeric_gt, + gbt_numeric_ge, + gbt_numeric_eq, + gbt_numeric_le, + gbt_numeric_lt, + gbt_numeric_cmp, + NULL }; @@ -77,10 +83,11 @@ static const gbtree_vinfo tinfo = Datum -gbt_numeric_compress (PG_FUNCTION_ARGS) +gbt_numeric_compress(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - PG_RETURN_POINTER ( gbt_var_compress( entry, &tinfo ) ); + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + + PG_RETURN_POINTER(gbt_var_compress(entry, &tinfo)); } @@ -89,24 +96,22 @@ Datum gbt_numeric_consistent(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - GBT_VARKEY *ktst = (GBT_VARKEY *) DatumGetPointer ( entry->key ) ; - GBT_VARKEY *key = (GBT_VARKEY *) DatumGetPointer ( PG_DETOAST_DATUM( entry->key ) ); - void *qtst = ( void * ) DatumGetPointer ( PG_GETARG_DATUM(1) ); - void *query = ( void * ) DatumGetNumeric ( PG_GETARG_DATUM(1) ); - StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); - bool retval = FALSE; - GBT_VARKEY_R r = gbt_var_key_readable ( key ); - - retval = gbt_var_consistent( &r, query, &strategy, GIST_LEAF(entry), &tinfo ); - - if ( ktst != key ){ - pfree ( key ); - } - if ( qtst != query ){ - pfree ( query ); - } - PG_RETURN_BOOL(retval); + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + GBT_VARKEY *ktst = (GBT_VARKEY *) DatumGetPointer(entry->key); + GBT_VARKEY *key = (GBT_VARKEY *) DatumGetPointer(PG_DETOAST_DATUM(entry->key)); + void *qtst = (void *) DatumGetPointer(PG_GETARG_DATUM(1)); + void *query = (void *) DatumGetNumeric(PG_GETARG_DATUM(1)); + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + bool retval = FALSE; + GBT_VARKEY_R r = gbt_var_key_readable(key); + + retval = gbt_var_consistent(&r, query, &strategy, GIST_LEAF(entry), &tinfo); + + if (ktst != key) + pfree(key); + if (qtst != query) + pfree(query); + PG_RETURN_BOOL(retval); } @@ -114,104 +119,110 @@ gbt_numeric_consistent(PG_FUNCTION_ARGS) Datum gbt_numeric_union(PG_FUNCTION_ARGS) { - GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); - int32 * size = (int *) PG_GETARG_POINTER(1); - PG_RETURN_POINTER( gbt_var_union ( entryvec , size , &tinfo ) ); + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + int32 *size = (int *) PG_GETARG_POINTER(1); + + PG_RETURN_POINTER(gbt_var_union(entryvec, size, &tinfo)); } - + Datum gbt_numeric_same(PG_FUNCTION_ARGS) { - Datum d1 = PG_GETARG_DATUM(0); - Datum d2 = PG_GETARG_DATUM(1); - bool *result = (bool *) PG_GETARG_POINTER(2); - PG_RETURN_POINTER( gbt_var_same ( result, d1 , d2 , &tinfo )); + Datum d1 = PG_GETARG_DATUM(0); + Datum d2 = PG_GETARG_DATUM(1); + bool *result = (bool *) PG_GETARG_POINTER(2); + + PG_RETURN_POINTER(gbt_var_same(result, d1, d2, &tinfo)); } Datum -gbt_numeric_penalty (PG_FUNCTION_ARGS) +gbt_numeric_penalty(PG_FUNCTION_ARGS) { - GISTENTRY * o = (GISTENTRY *) PG_GETARG_POINTER(0); - GISTENTRY * n = (GISTENTRY *) PG_GETARG_POINTER(1); - float *result = (float *) PG_GETARG_POINTER(2); + GISTENTRY *o = (GISTENTRY *) PG_GETARG_POINTER(0); + GISTENTRY *n = (GISTENTRY *) PG_GETARG_POINTER(1); + float *result = (float *) PG_GETARG_POINTER(2); - Numeric us, os, ds ; + Numeric us, + os, + ds; - GBT_VARKEY *org = (GBT_VARKEY *) DatumGetPointer(o->key); - GBT_VARKEY *newe = (GBT_VARKEY *) DatumGetPointer(n->key); - Datum uni ; - GBT_VARKEY_R rk , ok, uk ; + GBT_VARKEY *org = (GBT_VARKEY *) DatumGetPointer(o->key); + GBT_VARKEY *newe = (GBT_VARKEY *) DatumGetPointer(n->key); + Datum uni; + GBT_VARKEY_R rk, + ok, + uk; - rk = gbt_var_key_readable ( org ); - uni = PointerGetDatum( gbt_var_key_copy( &rk, TRUE ) ); - gbt_var_bin_union ( &uni , newe, &tinfo ); - ok = gbt_var_key_readable ( org ); - uk = gbt_var_key_readable ( (GBT_VARKEY *) DatumGetPointer(uni) ); + rk = gbt_var_key_readable(org); + uni = PointerGetDatum(gbt_var_key_copy(&rk, TRUE)); + gbt_var_bin_union(&uni, newe, &tinfo); + ok = gbt_var_key_readable(org); + uk = gbt_var_key_readable((GBT_VARKEY *) DatumGetPointer(uni)); - us = DatumGetNumeric(DirectFunctionCall2( - numeric_sub, - PointerGetDatum(uk.upper), - PointerGetDatum(uk.lower) - )); + us = DatumGetNumeric(DirectFunctionCall2( + numeric_sub, + PointerGetDatum(uk.upper), + PointerGetDatum(uk.lower) + )); - pfree ( DatumGetPointer(uni) ); + pfree(DatumGetPointer(uni)); - os = DatumGetNumeric(DirectFunctionCall2( - numeric_sub, - PointerGetDatum(ok.upper), - PointerGetDatum(ok.lower) - )); + os = DatumGetNumeric(DirectFunctionCall2( + numeric_sub, + PointerGetDatum(ok.upper), + PointerGetDatum(ok.lower) + )); - ds = DatumGetNumeric(DirectFunctionCall2( - numeric_sub, - NumericGetDatum(us), - NumericGetDatum(os) - )); + ds = DatumGetNumeric(DirectFunctionCall2( + numeric_sub, + NumericGetDatum(us), + NumericGetDatum(os) + )); - pfree ( os ); + pfree(os); - if ( NUMERIC_IS_NAN( us ) ) - { + if (NUMERIC_IS_NAN(us)) + { - if ( NUMERIC_IS_NAN( os ) ) - { - *result = 0.0; - } else { - *result = 1.0; - } + if (NUMERIC_IS_NAN(os)) + *result = 0.0; + else + *result = 1.0; - } else { + } + else + { - Numeric nul = DatumGetNumeric(DirectFunctionCall1( int4_numeric , Int32GetDatum (0) ) ); + Numeric nul = DatumGetNumeric(DirectFunctionCall1(int4_numeric, Int32GetDatum(0))); - *result = 0.0; + *result = 0.0; - if ( DirectFunctionCall2( numeric_gt , NumericGetDatum(ds), NumericGetDatum(nul) ) ) - { + if (DirectFunctionCall2(numeric_gt, NumericGetDatum(ds), NumericGetDatum(nul))) + { - *result += FLT_MIN ; - os = DatumGetNumeric(DirectFunctionCall2( - numeric_div, - NumericGetDatum(ds), - NumericGetDatum(us) - )); - *result += ( float4 ) DatumGetFloat8( DirectFunctionCall1( numeric_float8_no_overflow , NumericGetDatum(os) ) ); - pfree ( os ); + *result += FLT_MIN; + os = DatumGetNumeric(DirectFunctionCall2( + numeric_div, + NumericGetDatum(ds), + NumericGetDatum(us) + )); + *result += (float4) DatumGetFloat8(DirectFunctionCall1(numeric_float8_no_overflow, NumericGetDatum(os))); + pfree(os); - } + } - pfree ( nul ); - } + pfree(nul); + } - if ( *result > 0 ) - *result *= ( FLT_MAX / ( ( (GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1 ) ); + if (*result > 0) + *result *= (FLT_MAX / (((GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1)); - pfree ( us ); - pfree ( ds ); + pfree(us); + pfree(ds); - PG_RETURN_POINTER( result ); + PG_RETURN_POINTER(result); } @@ -219,9 +230,9 @@ gbt_numeric_penalty (PG_FUNCTION_ARGS) Datum gbt_numeric_picksplit(PG_FUNCTION_ARGS) { - GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); - GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1); - gbt_var_picksplit ( entryvec, v, &tinfo ); - PG_RETURN_POINTER(v); -} + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1); + gbt_var_picksplit(entryvec, v, &tinfo); + PG_RETURN_POINTER(v); +} diff --git a/contrib/btree_gist/btree_oid.c b/contrib/btree_gist/btree_oid.c index d7d98e4a7b..db4182fc04 100644 --- a/contrib/btree_gist/btree_oid.c +++ b/contrib/btree_gist/btree_oid.c @@ -3,9 +3,9 @@ typedef struct { - Oid lower; - Oid upper; -} oidKEY; + Oid lower; + Oid upper; +} oidKEY; /* ** OID ops @@ -17,60 +17,63 @@ PG_FUNCTION_INFO_V1(gbt_oid_consistent); PG_FUNCTION_INFO_V1(gbt_oid_penalty); PG_FUNCTION_INFO_V1(gbt_oid_same); -Datum gbt_oid_compress(PG_FUNCTION_ARGS); -Datum gbt_oid_union(PG_FUNCTION_ARGS); -Datum gbt_oid_picksplit(PG_FUNCTION_ARGS); -Datum gbt_oid_consistent(PG_FUNCTION_ARGS); -Datum gbt_oid_penalty(PG_FUNCTION_ARGS); -Datum gbt_oid_same(PG_FUNCTION_ARGS); +Datum gbt_oid_compress(PG_FUNCTION_ARGS); +Datum gbt_oid_union(PG_FUNCTION_ARGS); +Datum gbt_oid_picksplit(PG_FUNCTION_ARGS); +Datum gbt_oid_consistent(PG_FUNCTION_ARGS); +Datum gbt_oid_penalty(PG_FUNCTION_ARGS); +Datum gbt_oid_same(PG_FUNCTION_ARGS); -static bool gbt_oidgt (const void *a, const void *b) +static bool +gbt_oidgt(const void *a, const void *b) { - return ( *((Oid*)a) > *((Oid*)b) ); + return (*((Oid *) a) > *((Oid *) b)); } -static bool gbt_oidge (const void *a, const void *b) +static bool +gbt_oidge(const void *a, const void *b) { - return ( *((Oid*)a) >= *((Oid*)b) ); + return (*((Oid *) a) >= *((Oid *) b)); } -static bool gbt_oideq (const void *a, const void *b) +static bool +gbt_oideq(const void *a, const void *b) { - return ( *((Oid*)a) == *((Oid*)b) ); + return (*((Oid *) a) == *((Oid *) b)); } -static bool gbt_oidle (const void *a, const void *b) +static bool +gbt_oidle(const void *a, const void *b) { - return ( *((Oid*)a) <= *((Oid*)b) ); + return (*((Oid *) a) <= *((Oid *) b)); } -static bool gbt_oidlt (const void *a, const void *b) +static bool +gbt_oidlt(const void *a, const void *b) { - return ( *((Oid*)a) < *((Oid*)b) ); + return (*((Oid *) a) < *((Oid *) b)); } static int gbt_oidkey_cmp(const void *a, const void *b) { - if ( *(Oid*)&(((Nsrt *) a)->t[0]) > *(Oid*)&(((Nsrt *) b)->t[0]) ){ - return 1; - } else - if ( *(Oid*)&(((Nsrt *) a)->t[0]) < *(Oid*)&(((Nsrt *) b)->t[0]) ){ - return -1; - } - return 0; + if (*(Oid *) &(((Nsrt *) a)->t[0]) > *(Oid *) &(((Nsrt *) b)->t[0])) + return 1; + else if (*(Oid *) &(((Nsrt *) a)->t[0]) < *(Oid *) &(((Nsrt *) b)->t[0])) + return -1; + return 0; } -static const gbtree_ninfo tinfo = -{ - gbt_t_oid, - sizeof(Oid), - gbt_oidgt, - gbt_oidge, - gbt_oideq, - gbt_oidle, - gbt_oidlt, - gbt_oidkey_cmp +static const gbtree_ninfo tinfo = +{ + gbt_t_oid, + sizeof(Oid), + gbt_oidgt, + gbt_oidge, + gbt_oideq, + gbt_oidle, + gbt_oidlt, + gbt_oidkey_cmp }; @@ -82,9 +85,10 @@ static const gbtree_ninfo tinfo = Datum gbt_oid_compress(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - GISTENTRY *retval = NULL; - PG_RETURN_POINTER( gbt_num_compress( retval , entry , &tinfo )); + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + GISTENTRY *retval = NULL; + + PG_RETURN_POINTER(gbt_num_compress(retval, entry, &tinfo)); } @@ -92,69 +96,72 @@ Datum gbt_oid_consistent(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - Oid query = PG_GETARG_OID(1); - oidKEY *kkk = (oidKEY *) DatumGetPointer(entry->key); - GBT_NUMKEY_R key ; - StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); - key.lower = (GBT_NUMKEY*) &kkk->lower ; - key.upper = (GBT_NUMKEY*) &kkk->upper ; - - PG_RETURN_BOOL( - gbt_num_consistent( &key, (void*)&query,&strategy,GIST_LEAF(entry),&tinfo) - ); + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + Oid query = PG_GETARG_OID(1); + oidKEY *kkk = (oidKEY *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + + key.lower = (GBT_NUMKEY *) & kkk->lower; + key.upper = (GBT_NUMKEY *) & kkk->upper; + + PG_RETURN_BOOL( + gbt_num_consistent(&key, (void *) &query, &strategy, GIST_LEAF(entry), &tinfo) + ); } Datum gbt_oid_union(PG_FUNCTION_ARGS) { - GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); - void *out = palloc(sizeof(oidKEY)); - *(int *) PG_GETARG_POINTER(1) = sizeof(oidKEY); - PG_RETURN_POINTER( gbt_num_union ( (void*)out, entryvec, &tinfo ) ); + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + void *out = palloc(sizeof(oidKEY)); + + *(int *) PG_GETARG_POINTER(1) = sizeof(oidKEY); + PG_RETURN_POINTER(gbt_num_union((void *) out, entryvec, &tinfo)); } Datum gbt_oid_penalty(PG_FUNCTION_ARGS) { - oidKEY *origentry = (oidKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); - oidKEY *newentry = (oidKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); - float *result = (float *) PG_GETARG_POINTER(2); + oidKEY *origentry = (oidKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); + oidKEY *newentry = (oidKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); + float *result = (float *) PG_GETARG_POINTER(2); + + Oid res = 0; - Oid res = 0 ; + *result = 0.0; - *result = 0.0; - - penalty_range_enlarge ( origentry->lower, origentry->upper, newentry->lower , newentry->upper ); + penalty_range_enlarge(origentry->lower, origentry->upper, newentry->lower, newentry->upper); - if ( res > 0 ){ - *result += FLT_MIN ; - *result += (float) ( res / ( (double) ( res + origentry->upper - origentry->lower ) ) ); - *result *= ( FLT_MAX / ( ( (GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1 ) ); - } + if (res > 0) + { + *result += FLT_MIN; + *result += (float) (res / ((double) (res + origentry->upper - origentry->lower))); + *result *= (FLT_MAX / (((GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1)); + } - PG_RETURN_POINTER(result); + PG_RETURN_POINTER(result); } Datum gbt_oid_picksplit(PG_FUNCTION_ARGS) { - PG_RETURN_POINTER(gbt_num_picksplit( - (GistEntryVector *) PG_GETARG_POINTER(0), - (GIST_SPLITVEC *) PG_GETARG_POINTER(1), - &tinfo - )); + PG_RETURN_POINTER(gbt_num_picksplit( + (GistEntryVector *) PG_GETARG_POINTER(0), + (GIST_SPLITVEC *) PG_GETARG_POINTER(1), + &tinfo + )); } Datum gbt_oid_same(PG_FUNCTION_ARGS) { - oidKEY *b1 = (oidKEY *) PG_GETARG_POINTER(0); - oidKEY *b2 = (oidKEY *) PG_GETARG_POINTER(1); - bool *result = (bool *) PG_GETARG_POINTER(2); + oidKEY *b1 = (oidKEY *) PG_GETARG_POINTER(0); + oidKEY *b2 = (oidKEY *) PG_GETARG_POINTER(1); + bool *result = (bool *) PG_GETARG_POINTER(2); - *result = gbt_num_same ( (void*)b1, (void*)b2, &tinfo ); - PG_RETURN_POINTER(result); + *result = gbt_num_same((void *) b1, (void *) b2, &tinfo); + PG_RETURN_POINTER(result); } diff --git a/contrib/btree_gist/btree_text.c b/contrib/btree_gist/btree_text.c index fac9f554c0..d2603e1d91 100644 --- a/contrib/btree_gist/btree_text.c +++ b/contrib/btree_gist/btree_text.c @@ -14,95 +14,102 @@ PG_FUNCTION_INFO_V1(gbt_bpchar_consistent); PG_FUNCTION_INFO_V1(gbt_text_penalty); PG_FUNCTION_INFO_V1(gbt_text_same); -Datum gbt_text_compress(PG_FUNCTION_ARGS); -Datum gbt_bpchar_compress(PG_FUNCTION_ARGS); -Datum gbt_text_union(PG_FUNCTION_ARGS); -Datum gbt_text_picksplit(PG_FUNCTION_ARGS); -Datum gbt_text_consistent(PG_FUNCTION_ARGS); -Datum gbt_bpchar_consistent(PG_FUNCTION_ARGS); -Datum gbt_text_penalty(PG_FUNCTION_ARGS); -Datum gbt_text_same(PG_FUNCTION_ARGS); +Datum gbt_text_compress(PG_FUNCTION_ARGS); +Datum gbt_bpchar_compress(PG_FUNCTION_ARGS); +Datum gbt_text_union(PG_FUNCTION_ARGS); +Datum gbt_text_picksplit(PG_FUNCTION_ARGS); +Datum gbt_text_consistent(PG_FUNCTION_ARGS); +Datum gbt_bpchar_consistent(PG_FUNCTION_ARGS); +Datum gbt_text_penalty(PG_FUNCTION_ARGS); +Datum gbt_text_same(PG_FUNCTION_ARGS); /* define for comparison */ -static bool gbt_textgt (const void *a, const void *b) +static bool +gbt_textgt(const void *a, const void *b) { - return ( DatumGetBool(DirectFunctionCall2( text_gt ,PointerGetDatum( a ),PointerGetDatum( b ) ) ) ); + return (DatumGetBool(DirectFunctionCall2(text_gt, PointerGetDatum(a), PointerGetDatum(b)))); } -static bool gbt_textge (const void *a, const void *b) +static bool +gbt_textge(const void *a, const void *b) { - return ( DatumGetBool(DirectFunctionCall2( text_ge ,PointerGetDatum( a ),PointerGetDatum( b ) ) ) ); + return (DatumGetBool(DirectFunctionCall2(text_ge, PointerGetDatum(a), PointerGetDatum(b)))); } -static bool gbt_texteq (const void *a, const void *b) +static bool +gbt_texteq(const void *a, const void *b) { - return ( DatumGetBool(DirectFunctionCall2( texteq ,PointerGetDatum( a ),PointerGetDatum( b ) ) ) ); + return (DatumGetBool(DirectFunctionCall2(texteq, PointerGetDatum(a), PointerGetDatum(b)))); } -static bool gbt_textle (const void *a, const void *b) +static bool +gbt_textle(const void *a, const void *b) { - return ( DatumGetBool(DirectFunctionCall2( text_le ,PointerGetDatum( a ),PointerGetDatum( b ) ) ) ); + return (DatumGetBool(DirectFunctionCall2(text_le, PointerGetDatum(a), PointerGetDatum(b)))); } -static bool gbt_textlt (const void *a, const void *b) +static bool +gbt_textlt(const void *a, const void *b) { - return ( DatumGetBool(DirectFunctionCall2( text_lt ,PointerGetDatum( a ),PointerGetDatum( b ) ) ) ); + return (DatumGetBool(DirectFunctionCall2(text_lt, PointerGetDatum(a), PointerGetDatum(b)))); } -static int32 gbt_textcmp ( const bytea * a , const bytea * b ) +static int32 +gbt_textcmp(const bytea *a, const bytea *b) { - return strcmp( VARDATA(a), VARDATA(b) ); + return strcmp(VARDATA(a), VARDATA(b)); } - + /* * Converts data of leaf using strxfrm ( locale support ) */ static bytea * -gbt_text_xfrm ( bytea * leaf ) +gbt_text_xfrm(bytea *leaf) { - bytea * out = leaf; - int32 ilen = VARSIZE (leaf) - VARHDRSZ; - int32 olen ; - char * sin; - char * sou; + bytea *out = leaf; + int32 ilen = VARSIZE(leaf) - VARHDRSZ; + int32 olen; + char *sin; + char *sou; sin = palloc(ilen + 1); - memcpy (sin, (void*) VARDATA(leaf) ,ilen ); - sin[ilen] = '\0'; - - olen = strxfrm ( NULL, &sin[0], 0 ) + 1; - sou = palloc ( olen ); - olen = strxfrm ( sou , &sin[0] , olen ); - olen += VARHDRSZ; - out = palloc ( olen + 1 ); - out->vl_len = olen+1; - memcpy( (void*) VARDATA(out), sou, olen-VARHDRSZ ); - ((char*)out)[olen] = '\0'; - - pfree(sou); - pfree(sin); - - return out; + memcpy(sin, (void *) VARDATA(leaf), ilen); + sin[ilen] = '\0'; + + olen = strxfrm(NULL, &sin[0], 0) + 1; + sou = palloc(olen); + olen = strxfrm(sou, &sin[0], olen); + olen += VARHDRSZ; + out = palloc(olen + 1); + out->vl_len = olen + 1; + memcpy((void *) VARDATA(out), sou, olen - VARHDRSZ); + ((char *) out)[olen] = '\0'; + + pfree(sou); + pfree(sin); + + return out; } -static GBT_VARKEY * gbt_text_l2n ( GBT_VARKEY * leaf ) +static GBT_VARKEY * +gbt_text_l2n(GBT_VARKEY * leaf) { - - GBT_VARKEY *out = leaf ; - GBT_VARKEY_R r = gbt_var_key_readable ( leaf ); - bytea * o ; - o = gbt_text_xfrm ( r.lower ); - r.lower = r.upper = o; - out = gbt_var_key_copy ( &r , TRUE ); - pfree(o); + GBT_VARKEY *out = leaf; + GBT_VARKEY_R r = gbt_var_key_readable(leaf); + bytea *o; + + o = gbt_text_xfrm(r.lower); + r.lower = r.upper = o; + out = gbt_var_key_copy(&r, TRUE); + pfree(o); - return out; + return out; } @@ -112,16 +119,16 @@ static GBT_VARKEY * gbt_text_l2n ( GBT_VARKEY * leaf ) static const gbtree_vinfo tinfo = { - gbt_t_text, - TRUE, - TRUE, - gbt_textgt, - gbt_textge, - gbt_texteq, - gbt_textle, - gbt_textlt, - gbt_textcmp, - gbt_text_l2n + gbt_t_text, + TRUE, + TRUE, + gbt_textgt, + gbt_textge, + gbt_texteq, + gbt_textle, + gbt_textlt, + gbt_textcmp, + gbt_text_l2n }; @@ -132,36 +139,38 @@ static const gbtree_vinfo tinfo = Datum -gbt_text_compress (PG_FUNCTION_ARGS) +gbt_text_compress(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - PG_RETURN_POINTER ( gbt_var_compress( entry, &tinfo ) ); + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + + PG_RETURN_POINTER(gbt_var_compress(entry, &tinfo)); } Datum -gbt_bpchar_compress (PG_FUNCTION_ARGS) +gbt_bpchar_compress(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - GISTENTRY * retval ; + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + GISTENTRY *retval; - if (entry->leafkey) - { + if (entry->leafkey) + { - Datum d = DirectFunctionCall1 ( rtrim1, entry->key ); - GISTENTRY * trim = palloc(sizeof(GISTENTRY)); + Datum d = DirectFunctionCall1(rtrim1, entry->key); + GISTENTRY *trim = palloc(sizeof(GISTENTRY)); - gistentryinit(*trim, d , - entry->rel, entry->page, - entry->offset, VARSIZE(DatumGetPointer(d)), TRUE); - retval = gbt_var_compress( trim , &tinfo ) ; + gistentryinit(*trim, d, + entry->rel, entry->page, + entry->offset, VARSIZE(DatumGetPointer(d)), TRUE); + retval = gbt_var_compress(trim, &tinfo); - pfree ( trim ); - pfree ( DatumGetPointer(d) ); - } else - retval = entry; + pfree(trim); + pfree(DatumGetPointer(d)); + } + else + retval = entry; - PG_RETURN_POINTER ( retval ); + PG_RETURN_POINTER(retval); } @@ -169,68 +178,66 @@ gbt_bpchar_compress (PG_FUNCTION_ARGS) Datum gbt_text_consistent(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - GBT_VARKEY *ktst = (GBT_VARKEY *) DatumGetPointer ( entry->key ) ; - GBT_VARKEY *key = (GBT_VARKEY *) DatumGetPointer ( PG_DETOAST_DATUM( entry->key ) ); - void *qtst = ( void * ) DatumGetPointer( PG_GETARG_DATUM(1) ); - void *query = ( void * ) DatumGetTextP ( PG_GETARG_DATUM(1) ); - StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); - bool retval = FALSE; - GBT_VARKEY_R r = gbt_var_key_readable ( key ); - - if ( GIST_LEAF(entry) ) - { - retval = gbt_var_consistent( &r, query, &strategy, TRUE, &tinfo ); - } else { - bytea * q = gbt_text_xfrm ( ( bytea * ) query ); - retval = gbt_var_consistent( &r, (void*)q, &strategy, FALSE, &tinfo ); - if ( q != query ) - pfree(q); - } - - if ( ktst != key ){ - pfree ( key ); - } - if ( qtst != query ){ - pfree ( query ); - } - - PG_RETURN_BOOL(retval); + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + GBT_VARKEY *ktst = (GBT_VARKEY *) DatumGetPointer(entry->key); + GBT_VARKEY *key = (GBT_VARKEY *) DatumGetPointer(PG_DETOAST_DATUM(entry->key)); + void *qtst = (void *) DatumGetPointer(PG_GETARG_DATUM(1)); + void *query = (void *) DatumGetTextP(PG_GETARG_DATUM(1)); + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + bool retval = FALSE; + GBT_VARKEY_R r = gbt_var_key_readable(key); + + if (GIST_LEAF(entry)) + retval = gbt_var_consistent(&r, query, &strategy, TRUE, &tinfo); + else + { + bytea *q = gbt_text_xfrm((bytea *) query); + + retval = gbt_var_consistent(&r, (void *) q, &strategy, FALSE, &tinfo); + if (q != query) + pfree(q); + } + + if (ktst != key) + pfree(key); + if (qtst != query) + pfree(query); + + PG_RETURN_BOOL(retval); } Datum gbt_bpchar_consistent(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - GBT_VARKEY *ktst = (GBT_VARKEY *) DatumGetPointer ( entry->key ) ; - GBT_VARKEY *key = (GBT_VARKEY *) DatumGetPointer ( PG_DETOAST_DATUM( entry->key ) ); - void *qtst = ( void * ) DatumGetPointer ( PG_GETARG_DATUM(1) ); - void *query = ( void * ) DatumGetPointer (PG_DETOAST_DATUM( PG_GETARG_DATUM(1) ) ); - void *trim = ( void * ) DatumGetPointer ( DirectFunctionCall1 ( rtrim1, PointerGetDatum ( query ) ) ) ; - StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); - bool retval = FALSE; - GBT_VARKEY_R r = gbt_var_key_readable ( key ); - - if ( GIST_LEAF(entry) ) - { - retval = gbt_var_consistent( &r, trim , &strategy, TRUE, &tinfo ); - } else { - bytea * q = gbt_text_xfrm ( ( bytea * ) trim ); - retval = gbt_var_consistent( &r, (void*)q, &strategy, FALSE, &tinfo ); - if ( q != trim ) - pfree(q); - } - - pfree(trim); - - if ( ktst != key ){ - pfree ( key ); - } - if ( qtst != query ){ - pfree ( query ); - } - PG_RETURN_BOOL(retval); + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + GBT_VARKEY *ktst = (GBT_VARKEY *) DatumGetPointer(entry->key); + GBT_VARKEY *key = (GBT_VARKEY *) DatumGetPointer(PG_DETOAST_DATUM(entry->key)); + void *qtst = (void *) DatumGetPointer(PG_GETARG_DATUM(1)); + void *query = (void *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(1))); + void *trim = (void *) DatumGetPointer(DirectFunctionCall1(rtrim1, PointerGetDatum(query))); + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + bool retval = FALSE; + GBT_VARKEY_R r = gbt_var_key_readable(key); + + if (GIST_LEAF(entry)) + retval = gbt_var_consistent(&r, trim, &strategy, TRUE, &tinfo); + else + { + bytea *q = gbt_text_xfrm((bytea *) trim); + + retval = gbt_var_consistent(&r, (void *) q, &strategy, FALSE, &tinfo); + if (q != trim) + pfree(q); + } + + pfree(trim); + + if (ktst != key) + pfree(key); + if (qtst != query) + pfree(query); + PG_RETURN_BOOL(retval); } @@ -239,37 +246,40 @@ gbt_bpchar_consistent(PG_FUNCTION_ARGS) Datum gbt_text_union(PG_FUNCTION_ARGS) { - GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); - int32 *size = (int *) PG_GETARG_POINTER(1); - PG_RETURN_POINTER( gbt_var_union ( entryvec , size , &tinfo ) ); + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + int32 *size = (int *) PG_GETARG_POINTER(1); + + PG_RETURN_POINTER(gbt_var_union(entryvec, size, &tinfo)); } - + Datum gbt_text_picksplit(PG_FUNCTION_ARGS) { - GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); - GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1); - gbt_var_picksplit ( entryvec, v, &tinfo ); - PG_RETURN_POINTER(v); + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1); + + gbt_var_picksplit(entryvec, v, &tinfo); + PG_RETURN_POINTER(v); } Datum gbt_text_same(PG_FUNCTION_ARGS) { - Datum d1 = PG_GETARG_DATUM(0); - Datum d2 = PG_GETARG_DATUM(1); - bool *result = (bool *) PG_GETARG_POINTER(2); - PG_RETURN_POINTER( gbt_var_same ( result, d1 , d2 , &tinfo )); + Datum d1 = PG_GETARG_DATUM(0); + Datum d2 = PG_GETARG_DATUM(1); + bool *result = (bool *) PG_GETARG_POINTER(2); + + PG_RETURN_POINTER(gbt_var_same(result, d1, d2, &tinfo)); } Datum gbt_text_penalty(PG_FUNCTION_ARGS) { - float *result = (float *) PG_GETARG_POINTER(2); - GISTENTRY * o = (GISTENTRY *) PG_GETARG_POINTER(0); - GISTENTRY * n = (GISTENTRY *) PG_GETARG_POINTER(1); - PG_RETURN_POINTER( gbt_var_penalty ( result ,o , n, &tinfo ) ); -} + float *result = (float *) PG_GETARG_POINTER(2); + GISTENTRY *o = (GISTENTRY *) PG_GETARG_POINTER(0); + GISTENTRY *n = (GISTENTRY *) PG_GETARG_POINTER(1); + PG_RETURN_POINTER(gbt_var_penalty(result, o, n, &tinfo)); +} diff --git a/contrib/btree_gist/btree_time.c b/contrib/btree_gist/btree_time.c index 410bec0fe4..cbbe05dc27 100644 --- a/contrib/btree_gist/btree_time.c +++ b/contrib/btree_gist/btree_time.c @@ -4,9 +4,9 @@ typedef struct { - TimeADT lower; - TimeADT upper; -} timeKEY; + TimeADT lower; + TimeADT upper; +} timeKEY; /* ** time ops @@ -20,49 +20,54 @@ PG_FUNCTION_INFO_V1(gbt_timetz_consistent); PG_FUNCTION_INFO_V1(gbt_time_penalty); PG_FUNCTION_INFO_V1(gbt_time_same); -Datum gbt_time_compress(PG_FUNCTION_ARGS); -Datum gbt_timetz_compress(PG_FUNCTION_ARGS); -Datum gbt_time_union(PG_FUNCTION_ARGS); -Datum gbt_time_picksplit(PG_FUNCTION_ARGS); -Datum gbt_time_consistent(PG_FUNCTION_ARGS); -Datum gbt_timetz_consistent(PG_FUNCTION_ARGS); -Datum gbt_time_penalty(PG_FUNCTION_ARGS); -Datum gbt_time_same(PG_FUNCTION_ARGS); +Datum gbt_time_compress(PG_FUNCTION_ARGS); +Datum gbt_timetz_compress(PG_FUNCTION_ARGS); +Datum gbt_time_union(PG_FUNCTION_ARGS); +Datum gbt_time_picksplit(PG_FUNCTION_ARGS); +Datum gbt_time_consistent(PG_FUNCTION_ARGS); +Datum gbt_timetz_consistent(PG_FUNCTION_ARGS); +Datum gbt_time_penalty(PG_FUNCTION_ARGS); +Datum gbt_time_same(PG_FUNCTION_ARGS); -static bool gbt_timegt (const void *a, const void *b) +static bool +gbt_timegt(const void *a, const void *b) { - return DatumGetBool( - DirectFunctionCall2(time_gt,TimeADTGetDatum( *((TimeADT*)a) ), TimeADTGetDatum( *((TimeADT*)b) ) ) - ); + return DatumGetBool( + DirectFunctionCall2(time_gt, TimeADTGetDatum(*((TimeADT *) a)), TimeADTGetDatum(*((TimeADT *) b))) + ); } -static bool gbt_timege (const void *a, const void *b) +static bool +gbt_timege(const void *a, const void *b) { - return DatumGetBool( - DirectFunctionCall2(time_ge,TimeADTGetDatum( *((TimeADT*)a) ), TimeADTGetDatum( *((TimeADT*)b) ) ) - ); + return DatumGetBool( + DirectFunctionCall2(time_ge, TimeADTGetDatum(*((TimeADT *) a)), TimeADTGetDatum(*((TimeADT *) b))) + ); } -static bool gbt_timeeq (const void *a, const void *b) +static bool +gbt_timeeq(const void *a, const void *b) { - return DatumGetBool( - DirectFunctionCall2(time_eq,TimeADTGetDatum( *((TimeADT*)a) ), TimeADTGetDatum( *((TimeADT*)b) ) ) - ); + return DatumGetBool( + DirectFunctionCall2(time_eq, TimeADTGetDatum(*((TimeADT *) a)), TimeADTGetDatum(*((TimeADT *) b))) + ); } -static bool gbt_timele (const void *a, const void *b) +static bool +gbt_timele(const void *a, const void *b) { - return DatumGetBool( - DirectFunctionCall2(time_le,TimeADTGetDatum( *((TimeADT*)a) ), TimeADTGetDatum( *((TimeADT*)b) ) ) - ); + return DatumGetBool( + DirectFunctionCall2(time_le, TimeADTGetDatum(*((TimeADT *) a)), TimeADTGetDatum(*((TimeADT *) b))) + ); } -static bool gbt_timelt (const void *a, const void *b) +static bool +gbt_timelt(const void *a, const void *b) { - return DatumGetBool( - DirectFunctionCall2(time_lt,TimeADTGetDatum( *((TimeADT*)a) ), TimeADTGetDatum( *((TimeADT*)b) ) ) - ); + return DatumGetBool( + DirectFunctionCall2(time_lt, TimeADTGetDatum(*((TimeADT *) a)), TimeADTGetDatum(*((TimeADT *) b))) + ); } @@ -70,26 +75,24 @@ static bool gbt_timelt (const void *a, const void *b) static int gbt_timekey_cmp(const void *a, const void *b) { - if ( gbt_timegt( (void*)&(((Nsrt *) a)->t[0]) , (void*)&(((Nsrt *) b)->t[0]) ) ){ - return 1; - } else - if ( gbt_timelt( (void*)&(((Nsrt *) a)->t[0]) , (void*)&(((Nsrt *) b)->t[0]) ) ){ - return -1; - } - return 0; + if (gbt_timegt((void *) &(((Nsrt *) a)->t[0]), (void *) &(((Nsrt *) b)->t[0]))) + return 1; + else if (gbt_timelt((void *) &(((Nsrt *) a)->t[0]), (void *) &(((Nsrt *) b)->t[0]))) + return -1; + return 0; } -static const gbtree_ninfo tinfo = +static const gbtree_ninfo tinfo = { - gbt_t_time, - sizeof(TimeADT), - gbt_timegt, - gbt_timege, - gbt_timeeq, - gbt_timele, - gbt_timelt, - gbt_timekey_cmp + gbt_t_time, + sizeof(TimeADT), + gbt_timegt, + gbt_timege, + gbt_timeeq, + gbt_timele, + gbt_timelt, + gbt_timekey_cmp }; @@ -102,150 +105,154 @@ static const gbtree_ninfo tinfo = Datum gbt_time_compress(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - GISTENTRY *retval = NULL; - PG_RETURN_POINTER( gbt_num_compress( retval , entry , &tinfo )); + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + GISTENTRY *retval = NULL; + + PG_RETURN_POINTER(gbt_num_compress(retval, entry, &tinfo)); } Datum gbt_timetz_compress(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - GISTENTRY *retval; - - if (entry->leafkey) - { - timeKEY *r = (timeKEY *) palloc(sizeof(timeKEY)); - TimeTzADT *tz = DatumGetTimeTzADTP(entry->key); - - retval = palloc(sizeof(GISTENTRY)); - - /* We are using the time + zone only to compress */ - r->lower = r->upper = ( tz->time + tz->zone ) ; - gistentryinit(*retval, PointerGetDatum(r), - entry->rel, entry->page, - entry->offset, sizeof(timeKEY), FALSE); - } - else - retval = entry; - PG_RETURN_POINTER(retval); + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + GISTENTRY *retval; + + if (entry->leafkey) + { + timeKEY *r = (timeKEY *) palloc(sizeof(timeKEY)); + TimeTzADT *tz = DatumGetTimeTzADTP(entry->key); + + retval = palloc(sizeof(GISTENTRY)); + + /* We are using the time + zone only to compress */ + r->lower = r->upper = (tz->time + tz->zone); + gistentryinit(*retval, PointerGetDatum(r), + entry->rel, entry->page, + entry->offset, sizeof(timeKEY), FALSE); + } + else + retval = entry; + PG_RETURN_POINTER(retval); } Datum gbt_time_consistent(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - TimeADT query = PG_GETARG_TIMEADT( 1 ); - timeKEY *kkk = (timeKEY*) DatumGetPointer(entry->key); - GBT_NUMKEY_R key ; - StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); - - key.lower = (GBT_NUMKEY*) &kkk->lower ; - key.upper = (GBT_NUMKEY*) &kkk->upper ; - - - PG_RETURN_BOOL( - gbt_num_consistent( &key, (void*)&query,&strategy,GIST_LEAF(entry),&tinfo) - ); + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + TimeADT query = PG_GETARG_TIMEADT(1); + timeKEY *kkk = (timeKEY *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + + key.lower = (GBT_NUMKEY *) & kkk->lower; + key.upper = (GBT_NUMKEY *) & kkk->upper; + + + PG_RETURN_BOOL( + gbt_num_consistent(&key, (void *) &query, &strategy, GIST_LEAF(entry), &tinfo) + ); } Datum gbt_timetz_consistent(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - TimeTzADT *query = PG_GETARG_TIMETZADT_P( 1 ); - TimeADT qqq = query->time + query->zone ; - timeKEY *kkk = (timeKEY*) DatumGetPointer(entry->key); - GBT_NUMKEY_R key ; - StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); - - key.lower = (GBT_NUMKEY*) &kkk->lower ; - key.upper = (GBT_NUMKEY*) &kkk->upper ; - - PG_RETURN_BOOL( - gbt_num_consistent( &key, (void*)&qqq, &strategy,GIST_LEAF(entry),&tinfo) - ); + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + TimeTzADT *query = PG_GETARG_TIMETZADT_P(1); + TimeADT qqq = query->time + query->zone; + timeKEY *kkk = (timeKEY *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + + key.lower = (GBT_NUMKEY *) & kkk->lower; + key.upper = (GBT_NUMKEY *) & kkk->upper; + + PG_RETURN_BOOL( + gbt_num_consistent(&key, (void *) &qqq, &strategy, GIST_LEAF(entry), &tinfo) + ); } Datum gbt_time_union(PG_FUNCTION_ARGS) { - GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); - void *out = palloc(sizeof(timeKEY)); - *(int *) PG_GETARG_POINTER(1) = sizeof(timeKEY); - PG_RETURN_POINTER( gbt_num_union ( (void*)out, entryvec, &tinfo ) ); + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + void *out = palloc(sizeof(timeKEY)); + + *(int *) PG_GETARG_POINTER(1) = sizeof(timeKEY); + PG_RETURN_POINTER(gbt_num_union((void *) out, entryvec, &tinfo)); } Datum gbt_time_penalty(PG_FUNCTION_ARGS) { - timeKEY *origentry = (timeKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); - timeKEY *newentry = (timeKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); - float *result = (float *) PG_GETARG_POINTER(2); - Interval *intr; + timeKEY *origentry = (timeKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); + timeKEY *newentry = (timeKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); + float *result = (float *) PG_GETARG_POINTER(2); + Interval *intr; + #ifdef HAVE_INT64_TIMESTAMP - int64 res; + int64 res; + #else - double res; + double res; #endif - intr = DatumGetIntervalP(DirectFunctionCall2( - time_mi_time, - TimeADTGetDatum(newentry->upper), - TimeADTGetDatum(origentry->upper))); - - /* see interval_larger */ - res = Max(intr->time + intr->month * (30 * 86400), 0); - pfree(intr); - - intr = DatumGetIntervalP(DirectFunctionCall2( - time_mi_time, - TimeADTGetDatum(origentry->lower), - TimeADTGetDatum(newentry->lower))); - - /* see interval_larger */ - res += Max(intr->time + intr->month * (30 * 86400), 0); - pfree(intr); - - *result = 0.0; - - if ( res > 0 ){ - intr = DatumGetIntervalP(DirectFunctionCall2( - time_mi_time, - TimeADTGetDatum(origentry->upper), - TimeADTGetDatum(origentry->lower))); - *result += FLT_MIN ; - *result += (float) ( res / ( (double) ( res + intr->time + intr->month * (30 * 86400) ) ) ); - *result *= ( FLT_MAX / ( ( (GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1 ) ); - pfree ( intr ); - } - - PG_RETURN_POINTER(result); + intr = DatumGetIntervalP(DirectFunctionCall2( + time_mi_time, + TimeADTGetDatum(newentry->upper), + TimeADTGetDatum(origentry->upper))); + + /* see interval_larger */ + res = Max(intr->time + intr->month * (30 * 86400), 0); + pfree(intr); + + intr = DatumGetIntervalP(DirectFunctionCall2( + time_mi_time, + TimeADTGetDatum(origentry->lower), + TimeADTGetDatum(newentry->lower))); + + /* see interval_larger */ + res += Max(intr->time + intr->month * (30 * 86400), 0); + pfree(intr); + + *result = 0.0; + + if (res > 0) + { + intr = DatumGetIntervalP(DirectFunctionCall2( + time_mi_time, + TimeADTGetDatum(origentry->upper), + TimeADTGetDatum(origentry->lower))); + *result += FLT_MIN; + *result += (float) (res / ((double) (res + intr->time + intr->month * (30 * 86400)))); + *result *= (FLT_MAX / (((GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1)); + pfree(intr); + } + + PG_RETURN_POINTER(result); } Datum gbt_time_picksplit(PG_FUNCTION_ARGS) { - PG_RETURN_POINTER(gbt_num_picksplit( - (GistEntryVector *) PG_GETARG_POINTER(0), - (GIST_SPLITVEC *) PG_GETARG_POINTER(1), - &tinfo - )); + PG_RETURN_POINTER(gbt_num_picksplit( + (GistEntryVector *) PG_GETARG_POINTER(0), + (GIST_SPLITVEC *) PG_GETARG_POINTER(1), + &tinfo + )); } Datum gbt_time_same(PG_FUNCTION_ARGS) { - timeKEY *b1 = (timeKEY *) PG_GETARG_POINTER(0); - timeKEY *b2 = (timeKEY *) PG_GETARG_POINTER(1); - bool *result = (bool *) PG_GETARG_POINTER(2); + timeKEY *b1 = (timeKEY *) PG_GETARG_POINTER(0); + timeKEY *b2 = (timeKEY *) PG_GETARG_POINTER(1); + bool *result = (bool *) PG_GETARG_POINTER(2); - *result = gbt_num_same ( (void*)b1, (void*)b2, &tinfo ); - PG_RETURN_POINTER(result); + *result = gbt_num_same((void *) b1, (void *) b2, &tinfo); + PG_RETURN_POINTER(result); } - diff --git a/contrib/btree_gist/btree_ts.c b/contrib/btree_gist/btree_ts.c index 97f209ed74..f9d801a3fc 100644 --- a/contrib/btree_gist/btree_ts.c +++ b/contrib/btree_gist/btree_ts.c @@ -3,9 +3,9 @@ typedef struct { - Timestamp lower; - Timestamp upper; -} tsKEY; + Timestamp lower; + Timestamp upper; +} tsKEY; /* ** timestamp ops @@ -19,75 +19,78 @@ PG_FUNCTION_INFO_V1(gbt_tstz_consistent); PG_FUNCTION_INFO_V1(gbt_ts_penalty); PG_FUNCTION_INFO_V1(gbt_ts_same); -Datum gbt_ts_compress(PG_FUNCTION_ARGS); -Datum gbt_tstz_compress(PG_FUNCTION_ARGS); -Datum gbt_ts_union(PG_FUNCTION_ARGS); -Datum gbt_ts_picksplit(PG_FUNCTION_ARGS); -Datum gbt_ts_consistent(PG_FUNCTION_ARGS); -Datum gbt_tstz_consistent(PG_FUNCTION_ARGS); -Datum gbt_ts_penalty(PG_FUNCTION_ARGS); -Datum gbt_ts_same(PG_FUNCTION_ARGS); +Datum gbt_ts_compress(PG_FUNCTION_ARGS); +Datum gbt_tstz_compress(PG_FUNCTION_ARGS); +Datum gbt_ts_union(PG_FUNCTION_ARGS); +Datum gbt_ts_picksplit(PG_FUNCTION_ARGS); +Datum gbt_ts_consistent(PG_FUNCTION_ARGS); +Datum gbt_tstz_consistent(PG_FUNCTION_ARGS); +Datum gbt_ts_penalty(PG_FUNCTION_ARGS); +Datum gbt_ts_same(PG_FUNCTION_ARGS); -static bool gbt_tsgt (const void *a, const void *b) +static bool +gbt_tsgt(const void *a, const void *b) { - return DatumGetBool( - DirectFunctionCall2(timestamp_gt,PointerGetDatum( a ), PointerGetDatum( b ) ) - ); + return DatumGetBool( + DirectFunctionCall2(timestamp_gt, PointerGetDatum(a), PointerGetDatum(b)) + ); } -static bool gbt_tsge (const void *a, const void *b) +static bool +gbt_tsge(const void *a, const void *b) { - return DatumGetBool( - DirectFunctionCall2(timestamp_ge,PointerGetDatum( a ), PointerGetDatum( b ) ) - ); + return DatumGetBool( + DirectFunctionCall2(timestamp_ge, PointerGetDatum(a), PointerGetDatum(b)) + ); } -static bool gbt_tseq (const void *a, const void *b) +static bool +gbt_tseq(const void *a, const void *b) { - return DatumGetBool( - DirectFunctionCall2(timestamp_eq,PointerGetDatum( a ), PointerGetDatum( b ) ) - ); + return DatumGetBool( + DirectFunctionCall2(timestamp_eq, PointerGetDatum(a), PointerGetDatum(b)) + ); } -static bool gbt_tsle (const void *a, const void *b) +static bool +gbt_tsle(const void *a, const void *b) { - return DatumGetBool( - DirectFunctionCall2(timestamp_le,PointerGetDatum( a ), PointerGetDatum( b ) ) - ); + return DatumGetBool( + DirectFunctionCall2(timestamp_le, PointerGetDatum(a), PointerGetDatum(b)) + ); } -static bool gbt_tslt (const void *a, const void *b) +static bool +gbt_tslt(const void *a, const void *b) { - return DatumGetBool( - DirectFunctionCall2(timestamp_lt,PointerGetDatum( a ), PointerGetDatum( b ) ) - ); + return DatumGetBool( + DirectFunctionCall2(timestamp_lt, PointerGetDatum(a), PointerGetDatum(b)) + ); } static int gbt_tskey_cmp(const void *a, const void *b) { - if ( gbt_tsgt( (void*)&(((Nsrt *) a)->t[0]) , (void*)&(((Nsrt *) b)->t[0]) ) ){ - return 1; - } else - if ( gbt_tslt( (void*)&(((Nsrt *) a)->t[0]) , (void*)&(((Nsrt *) b)->t[0]) ) ){ - return -1; - } - return 0; + if (gbt_tsgt((void *) &(((Nsrt *) a)->t[0]), (void *) &(((Nsrt *) b)->t[0]))) + return 1; + else if (gbt_tslt((void *) &(((Nsrt *) a)->t[0]), (void *) &(((Nsrt *) b)->t[0]))) + return -1; + return 0; } -static const gbtree_ninfo tinfo = -{ - gbt_t_ts, - sizeof(Timestamp), - gbt_tsgt, - gbt_tsge, - gbt_tseq, - gbt_tsle, - gbt_tslt, - gbt_tskey_cmp +static const gbtree_ninfo tinfo = +{ + gbt_t_ts, + sizeof(Timestamp), + gbt_tsgt, + gbt_tsge, + gbt_tseq, + gbt_tsle, + gbt_tslt, + gbt_tskey_cmp }; @@ -97,26 +100,28 @@ static const gbtree_ninfo tinfo = -static Timestamp * tstz_to_ts_gmt ( Timestamp * gmt, TimestampTz * ts ) +static Timestamp * +tstz_to_ts_gmt(Timestamp *gmt, TimestampTz *ts) { - int val, tz ; + int val, + tz; + + *gmt = *ts; + DecodeSpecial(0, "gmt", &val); - *gmt = *ts; - DecodeSpecial(0, "gmt", &val); - - if ( ! TIMESTAMP_NOT_FINITE(*ts)) - { - tz = val * 60; + if (!TIMESTAMP_NOT_FINITE(*ts)) + { + tz = val * 60; #ifdef HAVE_INT64_TIMESTAMP - *gmt -= (tz * INT64CONST(1000000)); + *gmt -= (tz * INT64CONST(1000000)); #else - *gmt -= tz; - *gmt = JROUND(*gmt); + *gmt -= tz; + *gmt = JROUND(*gmt); #endif - - } - return gmt; + + } + return gmt; } @@ -125,84 +130,86 @@ static Timestamp * tstz_to_ts_gmt ( Timestamp * gmt, TimestampTz * ts ) Datum gbt_ts_compress(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - GISTENTRY *retval = NULL; - PG_RETURN_POINTER( gbt_num_compress( retval , entry , &tinfo )); + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + GISTENTRY *retval = NULL; + + PG_RETURN_POINTER(gbt_num_compress(retval, entry, &tinfo)); } Datum gbt_tstz_compress(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - GISTENTRY *retval ; + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + GISTENTRY *retval; - if (entry->leafkey) - { - tsKEY *r = (tsKEY *) palloc(sizeof(tsKEY)); + if (entry->leafkey) + { + tsKEY *r = (tsKEY *) palloc(sizeof(tsKEY)); - TimestampTz ts = *(TimestampTz *) DatumGetPointer(entry->key); - Timestamp gmt ; + TimestampTz ts = *(TimestampTz *) DatumGetPointer(entry->key); + Timestamp gmt; - tstz_to_ts_gmt ( &gmt, &ts ); + tstz_to_ts_gmt(&gmt, &ts); - retval = palloc(sizeof(GISTENTRY)); - r->lower = r->upper = gmt ; - gistentryinit(*retval, PointerGetDatum(r), - entry->rel, entry->page, - entry->offset, sizeof(tsKEY), FALSE); - } - else - retval = entry; + retval = palloc(sizeof(GISTENTRY)); + r->lower = r->upper = gmt; + gistentryinit(*retval, PointerGetDatum(r), + entry->rel, entry->page, + entry->offset, sizeof(tsKEY), FALSE); + } + else + retval = entry; - PG_RETURN_POINTER( retval ); + PG_RETURN_POINTER(retval); } Datum gbt_ts_consistent(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - Timestamp *query = (Timestamp *) PG_GETARG_POINTER(1); - tsKEY *kkk = (tsKEY *) DatumGetPointer(entry->key); - GBT_NUMKEY_R key ; - StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); - - key.lower = (GBT_NUMKEY*) &kkk->lower ; - key.upper = (GBT_NUMKEY*) &kkk->upper ; - - PG_RETURN_BOOL( - gbt_num_consistent( &key, (void*)query,&strategy,GIST_LEAF(entry),&tinfo) - ); + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + Timestamp *query = (Timestamp *) PG_GETARG_POINTER(1); + tsKEY *kkk = (tsKEY *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + + key.lower = (GBT_NUMKEY *) & kkk->lower; + key.upper = (GBT_NUMKEY *) & kkk->upper; + + PG_RETURN_BOOL( + gbt_num_consistent(&key, (void *) query, &strategy, GIST_LEAF(entry), &tinfo) + ); } Datum gbt_tstz_consistent(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - TimestampTz *query = (Timestamp *) PG_GETARG_POINTER(1); - char *kkk = (char *) DatumGetPointer(entry->key); - GBT_NUMKEY_R key ; - StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); - Timestamp qqq ; - - key.lower = (GBT_NUMKEY*) &kkk[0]; - key.upper = (GBT_NUMKEY*) &kkk[MAXALIGN(tinfo.size)]; - tstz_to_ts_gmt ( &qqq, query ); - - PG_RETURN_BOOL( - gbt_num_consistent( &key, (void*)&qqq,&strategy,GIST_LEAF(entry),&tinfo) - ); + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + TimestampTz *query = (Timestamp *) PG_GETARG_POINTER(1); + char *kkk = (char *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + Timestamp qqq; + + key.lower = (GBT_NUMKEY *) & kkk[0]; + key.upper = (GBT_NUMKEY *) & kkk[MAXALIGN(tinfo.size)]; + tstz_to_ts_gmt(&qqq, query); + + PG_RETURN_BOOL( + gbt_num_consistent(&key, (void *) &qqq, &strategy, GIST_LEAF(entry), &tinfo) + ); } Datum gbt_ts_union(PG_FUNCTION_ARGS) { - GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); - void *out = palloc(sizeof(tsKEY)); - *(int *) PG_GETARG_POINTER(1) = sizeof(tsKEY); - PG_RETURN_POINTER( gbt_num_union ( (void*)out, entryvec, &tinfo ) ); + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + void *out = palloc(sizeof(tsKEY)); + + *(int *) PG_GETARG_POINTER(1) = sizeof(tsKEY); + PG_RETURN_POINTER(gbt_num_union((void *) out, entryvec, &tinfo)); } @@ -210,52 +217,55 @@ Datum gbt_ts_penalty(PG_FUNCTION_ARGS) { - tsKEY *origentry = (tsKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); - tsKEY *newentry = (tsKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); - float *result = (float *) PG_GETARG_POINTER(2); - Interval *intr; + tsKEY *origentry = (tsKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); + tsKEY *newentry = (tsKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); + float *result = (float *) PG_GETARG_POINTER(2); + Interval *intr; + #ifdef HAVE_INT64_TIMESTAMP - int64 res; + int64 res; + #else - double res; + double res; #endif - intr = DatumGetIntervalP(DirectFunctionCall2( - timestamp_mi, - TimestampGetDatum(newentry->upper), - TimestampGetDatum(origentry->upper) - )); + intr = DatumGetIntervalP(DirectFunctionCall2( + timestamp_mi, + TimestampGetDatum(newentry->upper), + TimestampGetDatum(origentry->upper) + )); - /* see interval_larger */ + /* see interval_larger */ - res = Max(intr->time + intr->month * (30 * 86400), 0); - pfree(intr); + res = Max(intr->time + intr->month * (30 * 86400), 0); + pfree(intr); - intr = DatumGetIntervalP(DirectFunctionCall2( - timestamp_mi, - TimestampGetDatum(origentry->lower), - TimestampGetDatum(newentry->lower) - )); + intr = DatumGetIntervalP(DirectFunctionCall2( + timestamp_mi, + TimestampGetDatum(origentry->lower), + TimestampGetDatum(newentry->lower) + )); - /* see interval_larger */ - res += Max(intr->time + intr->month * (30 * 86400), 0); - pfree(intr); + /* see interval_larger */ + res += Max(intr->time + intr->month * (30 * 86400), 0); + pfree(intr); - *result = 0.0; + *result = 0.0; - if ( res > 0 ){ - intr = DatumGetIntervalP(DirectFunctionCall2( - timestamp_mi, - TimestampGetDatum(origentry->upper), - TimestampGetDatum(origentry->lower) - )); - *result += FLT_MIN ; - *result += (float) ( res / ( (double) ( res + intr->time + intr->month * (30 * 86400) ) ) ); - *result *= ( FLT_MAX / ( ( (GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1 ) ); - pfree(intr); - } + if (res > 0) + { + intr = DatumGetIntervalP(DirectFunctionCall2( + timestamp_mi, + TimestampGetDatum(origentry->upper), + TimestampGetDatum(origentry->lower) + )); + *result += FLT_MIN; + *result += (float) (res / ((double) (res + intr->time + intr->month * (30 * 86400)))); + *result *= (FLT_MAX / (((GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1)); + pfree(intr); + } - PG_RETURN_POINTER(result); + PG_RETURN_POINTER(result); } @@ -263,21 +273,20 @@ gbt_ts_penalty(PG_FUNCTION_ARGS) Datum gbt_ts_picksplit(PG_FUNCTION_ARGS) { - PG_RETURN_POINTER(gbt_num_picksplit( - (GistEntryVector *) PG_GETARG_POINTER(0), - (GIST_SPLITVEC *) PG_GETARG_POINTER(1), - &tinfo - )); + PG_RETURN_POINTER(gbt_num_picksplit( + (GistEntryVector *) PG_GETARG_POINTER(0), + (GIST_SPLITVEC *) PG_GETARG_POINTER(1), + &tinfo + )); } Datum gbt_ts_same(PG_FUNCTION_ARGS) { - tsKEY *b1 = (tsKEY *) PG_GETARG_POINTER(0); - tsKEY *b2 = (tsKEY *) PG_GETARG_POINTER(1); - bool *result = (bool *) PG_GETARG_POINTER(2); + tsKEY *b1 = (tsKEY *) PG_GETARG_POINTER(0); + tsKEY *b2 = (tsKEY *) PG_GETARG_POINTER(1); + bool *result = (bool *) PG_GETARG_POINTER(2); - *result = gbt_num_same ( (void*)b1, (void*)b2, &tinfo ); - PG_RETURN_POINTER(result); + *result = gbt_num_same((void *) b1, (void *) b2, &tinfo); + PG_RETURN_POINTER(result); } - diff --git a/contrib/btree_gist/btree_utils_num.c b/contrib/btree_gist/btree_utils_num.c index bc104de96b..f524427424 100644 --- a/contrib/btree_gist/btree_utils_num.c +++ b/contrib/btree_gist/btree_utils_num.c @@ -3,58 +3,60 @@ #include "utils/date.h" extern GISTENTRY * -gbt_num_compress( GISTENTRY *retval , GISTENTRY *entry , const gbtree_ninfo * tinfo ) +gbt_num_compress(GISTENTRY *retval, GISTENTRY *entry, const gbtree_ninfo * tinfo) { - if (entry->leafkey) - { - - union { - int16 i2; - int32 i4; - TimeADT ts; - DateADT dt; - } v ; - - GBT_NUMKEY *r = ( GBT_NUMKEY * ) palloc(2 * tinfo->size ); - void *leaf = NULL; - - switch ( tinfo->t ) - { - case gbt_t_int2 : - v.i2 = DatumGetInt16(entry->key); - leaf = &v.i2; - break; - case gbt_t_int4 : - v.i4 = DatumGetInt32(entry->key); - leaf = &v.i4; - break; - case gbt_t_oid : - v.i4 = DatumGetObjectId(entry->key); - leaf = &v.i4; - break; - case gbt_t_time : - v.ts = DatumGetTimeADT(entry->key); - leaf = &v.ts; - break; - case gbt_t_date : - v.dt = DatumGetDateADT(entry->key); - leaf = &v.dt; - break; - default : - leaf = DatumGetPointer(entry->key); - } - - memset ( (void*) &r[0] , 0 , 2*tinfo->size ); - memcpy ( (void*) &r[0] , leaf, tinfo->size ); - memcpy ( (void*) &r[tinfo->size] , leaf, tinfo->size ); - retval = palloc(sizeof(GISTENTRY)); - gistentryinit(*retval, PointerGetDatum(r), entry->rel, entry->page, - entry->offset,( 2 * tinfo->size ), FALSE); - } else - retval = entry; - - return retval; + if (entry->leafkey) + { + + union + { + int16 i2; + int32 i4; + TimeADT ts; + DateADT dt; + } v; + + GBT_NUMKEY *r = (GBT_NUMKEY *) palloc(2 * tinfo->size); + void *leaf = NULL; + + switch (tinfo->t) + { + case gbt_t_int2: + v.i2 = DatumGetInt16(entry->key); + leaf = &v.i2; + break; + case gbt_t_int4: + v.i4 = DatumGetInt32(entry->key); + leaf = &v.i4; + break; + case gbt_t_oid: + v.i4 = DatumGetObjectId(entry->key); + leaf = &v.i4; + break; + case gbt_t_time: + v.ts = DatumGetTimeADT(entry->key); + leaf = &v.ts; + break; + case gbt_t_date: + v.dt = DatumGetDateADT(entry->key); + leaf = &v.dt; + break; + default: + leaf = DatumGetPointer(entry->key); + } + + memset((void *) &r[0], 0, 2 * tinfo->size); + memcpy((void *) &r[0], leaf, tinfo->size); + memcpy((void *) &r[tinfo->size], leaf, tinfo->size); + retval = palloc(sizeof(GISTENTRY)); + gistentryinit(*retval, PointerGetDatum(r), entry->rel, entry->page, + entry->offset, (2 * tinfo->size), FALSE); + } + else + retval = entry; + + return retval; } @@ -65,34 +67,35 @@ gbt_num_compress( GISTENTRY *retval , GISTENTRY *entry , const gbtree_ninfo * */ extern void * -gbt_num_union( GBT_NUMKEY * out, const GistEntryVector * entryvec, const gbtree_ninfo * tinfo ) +gbt_num_union(GBT_NUMKEY * out, const GistEntryVector *entryvec, const gbtree_ninfo * tinfo) { - int i, - numranges; - GBT_NUMKEY * cur ; - GBT_NUMKEY_R o, c; + int i, + numranges; + GBT_NUMKEY *cur; + GBT_NUMKEY_R o, + c; - numranges = entryvec->n; - cur = (GBT_NUMKEY *) DatumGetPointer((entryvec->vector[0].key)); + numranges = entryvec->n; + cur = (GBT_NUMKEY *) DatumGetPointer((entryvec->vector[0].key)); - o.lower = &((GBT_NUMKEY *)out)[0]; - o.upper = &((GBT_NUMKEY *)out)[tinfo->size]; + o.lower = &((GBT_NUMKEY *) out)[0]; + o.upper = &((GBT_NUMKEY *) out)[tinfo->size]; - memcpy( (void*)out, (void*) cur, 2*tinfo->size ); + memcpy((void *) out, (void *) cur, 2 * tinfo->size); - for (i = 1; i < numranges; i++) - { - cur = (GBT_NUMKEY *) DatumGetPointer((entryvec->vector[i].key)); - c.lower = &cur[0]; - c.upper = &cur[tinfo->size]; - if ( (*tinfo->f_gt)(o.lower, c.lower) ) /* out->lower > cur->lower */ - memcpy( (void* ) o.lower, (void*) c.lower, tinfo->size ); - if ( (*tinfo->f_lt)(o.upper, c.upper) ) /* out->upper < cur->upper */ - memcpy( (void*) o.upper, (void*) c.upper, tinfo->size ); - } + for (i = 1; i < numranges; i++) + { + cur = (GBT_NUMKEY *) DatumGetPointer((entryvec->vector[i].key)); + c.lower = &cur[0]; + c.upper = &cur[tinfo->size]; + if ((*tinfo->f_gt) (o.lower, c.lower)) /* out->lower > cur->lower */ + memcpy((void *) o.lower, (void *) c.lower, tinfo->size); + if ((*tinfo->f_lt) (o.upper, c.upper)) /* out->upper < cur->upper */ + memcpy((void *) o.upper, (void *) c.upper, tinfo->size); + } - return out; + return out; } @@ -101,51 +104,54 @@ gbt_num_union( GBT_NUMKEY * out, const GistEntryVector * entryvec, const gbtree_ ** The GiST same method for numerical values */ -extern bool gbt_num_same ( const GBT_NUMKEY * a, const GBT_NUMKEY * b, const gbtree_ninfo * tinfo ) +extern bool +gbt_num_same(const GBT_NUMKEY * a, const GBT_NUMKEY * b, const gbtree_ninfo * tinfo) { - GBT_NUMKEY_R b1, b2 ; + GBT_NUMKEY_R b1, + b2; - b1.lower = &(((GBT_NUMKEY *)a)[0]); - b1.upper = &(((GBT_NUMKEY *)a)[tinfo->size]); - b2.lower = &(((GBT_NUMKEY *)b)[0]); - b2.upper = &(((GBT_NUMKEY *)b)[tinfo->size]); + b1.lower = &(((GBT_NUMKEY *) a)[0]); + b1.upper = &(((GBT_NUMKEY *) a)[tinfo->size]); + b2.lower = &(((GBT_NUMKEY *) b)[0]); + b2.upper = &(((GBT_NUMKEY *) b)[tinfo->size]); + + if ( + (*tinfo->f_eq) (b1.lower, b2.lower) && + (*tinfo->f_eq) (b1.upper, b2.upper) + ) + return TRUE; + return FALSE; - if ( - (*tinfo->f_eq)( b1.lower, b2.lower) && - (*tinfo->f_eq)( b1.upper, b2.upper) - ) - return TRUE; - return FALSE; - } extern void -gbt_num_bin_union(Datum * u , GBT_NUMKEY * e , const gbtree_ninfo * tinfo ) +gbt_num_bin_union(Datum *u, GBT_NUMKEY * e, const gbtree_ninfo * tinfo) { - GBT_NUMKEY_R rd; - - rd.lower = &e[0]; - rd.upper = &e[tinfo->size]; - - if (!DatumGetPointer(*u)) - { - *u = PointerGetDatum(palloc(2 * tinfo->size)); - memcpy( (void* ) &( ( (GBT_NUMKEY *) DatumGetPointer(*u) )[0] ) , (void*)rd.lower , tinfo->size ); - memcpy( (void* ) &( ( (GBT_NUMKEY *) DatumGetPointer(*u) )[tinfo->size]) , (void*)rd.upper , tinfo->size ); - } - else - { - GBT_NUMKEY_R ur ; - ur.lower = &( ( (GBT_NUMKEY *) DatumGetPointer(*u) )[0] ) ; - ur.upper = &( ( (GBT_NUMKEY *) DatumGetPointer(*u) )[tinfo->size]) ; - if ( (*tinfo->f_gt)((void*)ur.lower, (void*)rd.lower) ) - memcpy( (void*) ur.lower, (void*) rd.lower, tinfo->size ); - if ( (*tinfo->f_lt)((void*)ur.upper, (void*)rd.upper) ) - memcpy( (void*) ur.upper, (void*) rd.upper, tinfo->size ); - } + GBT_NUMKEY_R rd; + + rd.lower = &e[0]; + rd.upper = &e[tinfo->size]; + + if (!DatumGetPointer(*u)) + { + *u = PointerGetDatum(palloc(2 * tinfo->size)); + memcpy((void *) &(((GBT_NUMKEY *) DatumGetPointer(*u))[0]), (void *) rd.lower, tinfo->size); + memcpy((void *) &(((GBT_NUMKEY *) DatumGetPointer(*u))[tinfo->size]), (void *) rd.upper, tinfo->size); + } + else + { + GBT_NUMKEY_R ur; + + ur.lower = &(((GBT_NUMKEY *) DatumGetPointer(*u))[0]); + ur.upper = &(((GBT_NUMKEY *) DatumGetPointer(*u))[tinfo->size]); + if ((*tinfo->f_gt) ((void *) ur.lower, (void *) rd.lower)) + memcpy((void *) ur.lower, (void *) rd.lower, tinfo->size); + if ((*tinfo->f_lt) ((void *) ur.upper, (void *) rd.upper)) + memcpy((void *) ur.upper, (void *) rd.upper, tinfo->size); + } } @@ -154,98 +160,98 @@ gbt_num_bin_union(Datum * u , GBT_NUMKEY * e , const gbtree_ninfo * tinfo ) ** The GiST consistent method */ -extern bool +extern bool gbt_num_consistent( - const GBT_NUMKEY_R * key, - const void * query, - const StrategyNumber * strategy, - bool is_leaf, - const gbtree_ninfo * tinfo + const GBT_NUMKEY_R * key, + const void *query, + const StrategyNumber *strategy, + bool is_leaf, + const gbtree_ninfo * tinfo ) { - bool retval = FALSE; - - switch (*strategy) - { - case BTLessEqualStrategyNumber: - retval = (*tinfo->f_ge)(query, key->lower); - break; - case BTLessStrategyNumber: - if ( is_leaf ) - retval = (*tinfo->f_gt)(query, key->lower); - else - retval = (*tinfo->f_ge)(query, key->lower); - break; - case BTEqualStrategyNumber: - if ( is_leaf ) - retval = (*tinfo->f_eq)(query, key->lower); - else - retval = (*tinfo->f_le)(key->lower, query) && (*tinfo->f_le)(query, key->upper ); - break; - case BTGreaterStrategyNumber: - if ( is_leaf ) - retval = (*tinfo->f_lt)(query, key->upper); - else - retval = (*tinfo->f_le)(query, key->upper); - break; - case BTGreaterEqualStrategyNumber: - retval = (*tinfo->f_le)(query, key->upper); - break; - default: - retval = FALSE; - } - - return (retval); + bool retval = FALSE; + + switch (*strategy) + { + case BTLessEqualStrategyNumber: + retval = (*tinfo->f_ge) (query, key->lower); + break; + case BTLessStrategyNumber: + if (is_leaf) + retval = (*tinfo->f_gt) (query, key->lower); + else + retval = (*tinfo->f_ge) (query, key->lower); + break; + case BTEqualStrategyNumber: + if (is_leaf) + retval = (*tinfo->f_eq) (query, key->lower); + else + retval = (*tinfo->f_le) (key->lower, query) && (*tinfo->f_le) (query, key->upper); + break; + case BTGreaterStrategyNumber: + if (is_leaf) + retval = (*tinfo->f_lt) (query, key->upper); + else + retval = (*tinfo->f_le) (query, key->upper); + break; + case BTGreaterEqualStrategyNumber: + retval = (*tinfo->f_le) (query, key->upper); + break; + default: + retval = FALSE; + } + + return (retval); } GIST_SPLITVEC * -gbt_num_picksplit( const GistEntryVector *entryvec, GIST_SPLITVEC *v, - const gbtree_ninfo * tinfo ) +gbt_num_picksplit(const GistEntryVector *entryvec, GIST_SPLITVEC *v, + const gbtree_ninfo * tinfo) { - OffsetNumber i, - maxoff = entryvec->n - 1; - Nsrt *arr; - int nbytes; - - arr = (Nsrt *) palloc((maxoff+1) * sizeof(Nsrt)); - nbytes = (maxoff + 2) * sizeof(OffsetNumber); - v->spl_left = (OffsetNumber *) palloc(nbytes); - v->spl_right = (OffsetNumber *) palloc(nbytes); - v->spl_ldatum = PointerGetDatum(0); - v->spl_rdatum = PointerGetDatum(0); - v->spl_nleft = 0; - v->spl_nright = 0; - - /* Sort entries */ - - for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) - { - arr[i].t = (GBT_NUMKEY *) DatumGetPointer((entryvec->vector[i].key)); - arr[i].i = i; - } - qsort ( (void*) &arr[FirstOffsetNumber], maxoff-FirstOffsetNumber+1,sizeof(Nsrt), tinfo->f_cmp ); - - /* We do simply create two parts */ - - for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) - { - if (i <= (maxoff - FirstOffsetNumber + 1) / 2) - { - gbt_num_bin_union(&v->spl_ldatum, arr[i].t, tinfo); - v->spl_left[v->spl_nleft] = arr[i].i; - v->spl_nleft++; - } - else - { - gbt_num_bin_union(&v->spl_rdatum, arr[i].t, tinfo); - v->spl_right[v->spl_nright] = arr[i].i; - v->spl_nright++; - } - } + OffsetNumber i, + maxoff = entryvec->n - 1; + Nsrt *arr; + int nbytes; + + arr = (Nsrt *) palloc((maxoff + 1) * sizeof(Nsrt)); + nbytes = (maxoff + 2) * sizeof(OffsetNumber); + v->spl_left = (OffsetNumber *) palloc(nbytes); + v->spl_right = (OffsetNumber *) palloc(nbytes); + v->spl_ldatum = PointerGetDatum(0); + v->spl_rdatum = PointerGetDatum(0); + v->spl_nleft = 0; + v->spl_nright = 0; + + /* Sort entries */ + + for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) + { + arr[i].t = (GBT_NUMKEY *) DatumGetPointer((entryvec->vector[i].key)); + arr[i].i = i; + } + qsort((void *) &arr[FirstOffsetNumber], maxoff - FirstOffsetNumber + 1, sizeof(Nsrt), tinfo->f_cmp); + + /* We do simply create two parts */ + + for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) + { + if (i <= (maxoff - FirstOffsetNumber + 1) / 2) + { + gbt_num_bin_union(&v->spl_ldatum, arr[i].t, tinfo); + v->spl_left[v->spl_nleft] = arr[i].i; + v->spl_nleft++; + } + else + { + gbt_num_bin_union(&v->spl_rdatum, arr[i].t, tinfo); + v->spl_right[v->spl_nright] = arr[i].i; + v->spl_nright++; + } + } pfree(arr); - return v; + return v; } diff --git a/contrib/btree_gist/btree_utils_num.h b/contrib/btree_gist/btree_utils_num.h index 122fba379a..714144f676 100644 --- a/contrib/btree_gist/btree_utils_num.h +++ b/contrib/btree_gist/btree_utils_num.h @@ -4,16 +4,17 @@ typedef char GBT_NUMKEY; /* Better readable key */ typedef struct { - const GBT_NUMKEY * lower, * upper; -} GBT_NUMKEY_R; + const GBT_NUMKEY *lower, + *upper; +} GBT_NUMKEY_R; /* for sorting */ typedef struct { - int i; - GBT_NUMKEY * t; -} Nsrt; + int i; + GBT_NUMKEY *t; +} Nsrt; /* type description */ @@ -21,53 +22,53 @@ typedef struct typedef struct { - /* Attribs */ + /* Attribs */ - enum gbtree_type t ; /* data type */ - int32 size ; /* size of type , 0 means variable */ + enum gbtree_type t; /* data type */ + int32 size; /* size of type , 0 means variable */ - /* Methods */ + /* Methods */ - bool (*f_gt) ( const void * , const void * ); /* greater then */ - bool (*f_ge) ( const void * , const void * ); /* greater equal */ - bool (*f_eq) ( const void * , const void * ); /* equal */ - bool (*f_le) ( const void * , const void * ); /* less equal */ - bool (*f_lt) ( const void * , const void * ); /* less then */ - int (*f_cmp) ( const void * , const void * ); /* key compare function */ -} gbtree_ninfo; + bool (*f_gt) (const void *, const void *); /* greater then */ + bool (*f_ge) (const void *, const void *); /* greater equal */ + bool (*f_eq) (const void *, const void *); /* equal */ + bool (*f_le) (const void *, const void *); /* less equal */ + bool (*f_lt) (const void *, const void *); /* less then */ + int (*f_cmp) (const void *, const void *); /* key compare function */ +} gbtree_ninfo; /* - * Numeric btree functions + * Numeric btree functions */ #define penalty_range_enlarge(olower,oupper,nlower,nupper) do { \ res = 0; \ if ( (nupper) > (oupper) ) \ - res += ( (nupper) - (oupper) ); \ - if ( (olower) > (nlower) ) \ - res += ( (olower) - (nlower) ); \ + res += ( (nupper) - (oupper) ); \ + if ( (olower) > (nlower) ) \ + res += ( (olower) - (nlower) ); \ } while (0); -extern bool gbt_num_consistent( const GBT_NUMKEY_R * key , const void * query, - const StrategyNumber * strategy , bool is_leaf, - const gbtree_ninfo * tinfo ); +extern bool gbt_num_consistent(const GBT_NUMKEY_R * key, const void *query, + const StrategyNumber *strategy, bool is_leaf, + const gbtree_ninfo * tinfo); -extern GIST_SPLITVEC *gbt_num_picksplit ( const GistEntryVector *entryvec, GIST_SPLITVEC *v, - const gbtree_ninfo * tinfo ); +extern GIST_SPLITVEC *gbt_num_picksplit(const GistEntryVector *entryvec, GIST_SPLITVEC *v, + const gbtree_ninfo * tinfo); -extern GISTENTRY *gbt_num_compress( GISTENTRY *retval , GISTENTRY *entry , - const gbtree_ninfo * tinfo ); +extern GISTENTRY *gbt_num_compress(GISTENTRY *retval, GISTENTRY *entry, + const gbtree_ninfo * tinfo); -extern void *gbt_num_union ( GBT_NUMKEY * out, const GistEntryVector * entryvec, - const gbtree_ninfo * tinfo ); +extern void *gbt_num_union(GBT_NUMKEY * out, const GistEntryVector *entryvec, + const gbtree_ninfo * tinfo); -extern bool gbt_num_same ( const GBT_NUMKEY * a, const GBT_NUMKEY * b, - const gbtree_ninfo * tinfo ); +extern bool gbt_num_same(const GBT_NUMKEY * a, const GBT_NUMKEY * b, + const gbtree_ninfo * tinfo); -extern void gbt_num_bin_union(Datum * u , GBT_NUMKEY * e , - const gbtree_ninfo * tinfo ); +extern void gbt_num_bin_union(Datum *u, GBT_NUMKEY * e, + const gbtree_ninfo * tinfo); diff --git a/contrib/btree_gist/btree_utils_var.c b/contrib/btree_gist/btree_utils_var.c index f8ced12226..01e2903816 100644 --- a/contrib/btree_gist/btree_utils_var.c +++ b/contrib/btree_gist/btree_utils_var.c @@ -4,52 +4,59 @@ /* Returns a better readable representaion of variable key ( sets pointer ) */ -extern GBT_VARKEY_R gbt_var_key_readable ( const GBT_VARKEY * k ){ - - GBT_VARKEY_R r ; - r.lower = ( bytea * ) &(((char*)k)[VARHDRSZ] ) ; - if ( VARSIZE(k) > ( VARHDRSZ+(VARSIZE(r.lower)) ) ) - r.upper = ( bytea * ) &(((char*)k)[VARHDRSZ+INTALIGN(VARSIZE(r.lower))] ) ; - else - r.upper = r.lower; - return r; +extern GBT_VARKEY_R +gbt_var_key_readable(const GBT_VARKEY * k) +{ + + GBT_VARKEY_R r; + + r.lower = (bytea *) &(((char *) k)[VARHDRSZ]); + if (VARSIZE(k) > (VARHDRSZ + (VARSIZE(r.lower)))) + r.upper = (bytea *) &(((char *) k)[VARHDRSZ + INTALIGN(VARSIZE(r.lower))]); + else + r.upper = r.lower; + return r; } -extern GBT_VARKEY * gbt_var_key_copy ( const GBT_VARKEY_R * u , bool force_node ){ +extern GBT_VARKEY * +gbt_var_key_copy(const GBT_VARKEY_R * u, bool force_node) +{ - GBT_VARKEY * r = NULL; + GBT_VARKEY *r = NULL; - if ( u->lower == u->upper && !force_node ){ /* leaf key mode */ + if (u->lower == u->upper && !force_node) + { /* leaf key mode */ - r = (GBT_VARKEY *) palloc(VARSIZE(u->lower) + VARHDRSZ ); - memcpy ( (void*) VARDATA(r), (void*) u->lower , VARSIZE(u->lower) ); - r->vl_len = VARSIZE(u->lower) + VARHDRSZ ; + r = (GBT_VARKEY *) palloc(VARSIZE(u->lower) + VARHDRSZ); + memcpy((void *) VARDATA(r), (void *) u->lower, VARSIZE(u->lower)); + r->vl_len = VARSIZE(u->lower) + VARHDRSZ; - } else { /* node key mode */ + } + else + { /* node key mode */ - r = (GBT_VARKEY *) palloc(INTALIGN(VARSIZE(u->lower)) + VARSIZE(u->upper) + VARHDRSZ ); - memcpy ( (void*) VARDATA(r) , (void*) u->lower , VARSIZE(u->lower) ); - memcpy ( (void*)&(((char *)r)[VARHDRSZ+INTALIGN(VARSIZE(u->lower))]), (void*) u->upper , VARSIZE(u->upper) ); - r->vl_len = INTALIGN(VARSIZE(u->lower)) + VARSIZE(u->upper) + VARHDRSZ ; + r = (GBT_VARKEY *) palloc(INTALIGN(VARSIZE(u->lower)) + VARSIZE(u->upper) + VARHDRSZ); + memcpy((void *) VARDATA(r), (void *) u->lower, VARSIZE(u->lower)); + memcpy((void *) &(((char *) r)[VARHDRSZ + INTALIGN(VARSIZE(u->lower))]), (void *) u->upper, VARSIZE(u->upper)); + r->vl_len = INTALIGN(VARSIZE(u->lower)) + VARSIZE(u->upper) + VARHDRSZ; - } - return r; + } + return r; } -static GBT_VARKEY * gbt_var_leaf2node ( GBT_VARKEY * leaf, const gbtree_vinfo * tinfo ) +static GBT_VARKEY * +gbt_var_leaf2node(GBT_VARKEY * leaf, const gbtree_vinfo * tinfo) { - GBT_VARKEY *out = leaf ; + GBT_VARKEY *out = leaf; - if ( tinfo->f_l2n ) - { - out = (*tinfo->f_l2n) (leaf); - } + if (tinfo->f_l2n) + out = (*tinfo->f_l2n) (leaf); - return out; + return out; } @@ -57,28 +64,27 @@ static GBT_VARKEY * gbt_var_leaf2node ( GBT_VARKEY * leaf, const gbtree_vinfo * /* * returns the common prefix length of a node key */ -static int32 gbt_var_node_cp_len ( const GBT_VARKEY * node , const gbtree_vinfo * tinfo ) +static int32 +gbt_var_node_cp_len(const GBT_VARKEY * node, const gbtree_vinfo * tinfo) { - int32 i ; - int32 s = (tinfo->str)?(1):(0); - GBT_VARKEY_R r = gbt_var_key_readable ( node ); - int32 t1len = VARSIZE(r.lower) - VARHDRSZ - s; - int32 t2len = VARSIZE(r.upper) - VARHDRSZ - s; - int32 ml = Min(t1len,t2len) ; - - char * p1 = VARDATA(r.lower) , - * p2 = VARDATA(r.upper) ; - - for ( i=0 ; i<ml; i++ ) - { - if ( *p1 != *p2 ) - { - return i; - } - p1++; - p2++; - } - return ( ml ); + int32 i; + int32 s = (tinfo->str) ? (1) : (0); + GBT_VARKEY_R r = gbt_var_key_readable(node); + int32 t1len = VARSIZE(r.lower) - VARHDRSZ - s; + int32 t2len = VARSIZE(r.upper) - VARHDRSZ - s; + int32 ml = Min(t1len, t2len); + + char *p1 = VARDATA(r.lower), + *p2 = VARDATA(r.upper); + + for (i = 0; i < ml; i++) + { + if (*p1 != *p2) + return i; + p1++; + p2++; + } + return (ml); } @@ -87,34 +93,38 @@ static int32 gbt_var_node_cp_len ( const GBT_VARKEY * node , const gbtree_vinfo * returns true, if query matches prefix using common prefix */ -static bool gbt_bytea_pf_match ( const bytea * pf , const bytea * query , const gbtree_vinfo * tinfo ) +static bool +gbt_bytea_pf_match(const bytea *pf, const bytea *query, const gbtree_vinfo * tinfo) { - int k ; - int32 s = (tinfo->str)?(1):(0); - bool out = FALSE ; - int32 qlen = VARSIZE(query) - VARHDRSZ - s ; - int32 nlen = VARSIZE(pf) - VARHDRSZ - s ; - if ( nlen <= qlen ) - { - char *q = VARDATA(query) ; - char *n = VARDATA(pf) ; - out = TRUE; - for ( k=0 ; k<nlen; k++ ) - { - if ( *n != *q ){ - out = FALSE; - break; - } - if ( k < (nlen-1) ) - { - q++; - n++; - } - } - } - - return out; + int k; + int32 s = (tinfo->str) ? (1) : (0); + bool out = FALSE; + int32 qlen = VARSIZE(query) - VARHDRSZ - s; + int32 nlen = VARSIZE(pf) - VARHDRSZ - s; + + if (nlen <= qlen) + { + char *q = VARDATA(query); + char *n = VARDATA(pf); + + out = TRUE; + for (k = 0; k < nlen; k++) + { + if (*n != *q) + { + out = FALSE; + break; + } + if (k < (nlen - 1)) + { + q++; + n++; + } + } + } + + return out; } @@ -124,13 +134,14 @@ static bool gbt_bytea_pf_match ( const bytea * pf , const bytea * query , const * returns true, if query matches node using common prefix */ -static bool gbt_var_node_pf_match ( const GBT_VARKEY_R * node , const bytea * query , const gbtree_vinfo * tinfo ) +static bool +gbt_var_node_pf_match(const GBT_VARKEY_R * node, const bytea *query, const gbtree_vinfo * tinfo) { - return ( - gbt_bytea_pf_match ( node->lower, query , tinfo ) || - gbt_bytea_pf_match ( node->upper, query , tinfo ) - ); + return ( + gbt_bytea_pf_match(node->lower, query, tinfo) || + gbt_bytea_pf_match(node->upper, query, tinfo) + ); } @@ -138,280 +149,299 @@ static bool gbt_var_node_pf_match ( const GBT_VARKEY_R * node , const bytea * qu /* * truncates / compresses the node key */ -static GBT_VARKEY * gbt_var_node_truncate ( const GBT_VARKEY * node , int32 length , const gbtree_vinfo * tinfo ) +static GBT_VARKEY * +gbt_var_node_truncate(const GBT_VARKEY * node, int32 length, const gbtree_vinfo * tinfo) { - int32 s = (tinfo->str)?(1):(0); - GBT_VARKEY * out = NULL; - GBT_VARKEY_R r = gbt_var_key_readable ( node ); - int32 len1 = VARSIZE(r.lower) - VARHDRSZ; - int32 len2 = VARSIZE(r.upper) - VARHDRSZ; - int32 si = 0; - - if (tinfo->str) - length++; /* because of tailing '\0' */ - - len1 = Min( len1, length ) ; - len2 = Min( len2, length ) ; - si = 2*VARHDRSZ + INTALIGN(VARHDRSZ+len1) + len2; - out = (GBT_VARKEY *) palloc ( si ); - out->vl_len = si; - memcpy ( (void*) &(((char*)out)[VARHDRSZ]) , (void*)r.lower, len1+VARHDRSZ-s ); - memcpy ( (void*) &(((char*)out)[VARHDRSZ+INTALIGN(VARHDRSZ+len1)]) , (void*)r.upper, len2+VARHDRSZ-s ); - - if (tinfo->str) - { - ((char*)out)[VARHDRSZ+INTALIGN(VARHDRSZ+len1)-1] = '\0'; - ((char*)out)[2*VARHDRSZ+INTALIGN(VARHDRSZ+len1)+len2-1] = '\0'; - } - *((int32*)&(((char*)out)[VARHDRSZ])) = len1 + VARHDRSZ; - *((int32*)&(((char*)out)[VARHDRSZ+INTALIGN(VARHDRSZ+len1)])) = len2 + VARHDRSZ; - - return out; + int32 s = (tinfo->str) ? (1) : (0); + GBT_VARKEY *out = NULL; + GBT_VARKEY_R r = gbt_var_key_readable(node); + int32 len1 = VARSIZE(r.lower) - VARHDRSZ; + int32 len2 = VARSIZE(r.upper) - VARHDRSZ; + int32 si = 0; + + if (tinfo->str) + length++; /* because of tailing '\0' */ + + len1 = Min(len1, length); + len2 = Min(len2, length); + si = 2 * VARHDRSZ + INTALIGN(VARHDRSZ + len1) + len2; + out = (GBT_VARKEY *) palloc(si); + out->vl_len = si; + memcpy((void *) &(((char *) out)[VARHDRSZ]), (void *) r.lower, len1 + VARHDRSZ - s); + memcpy((void *) &(((char *) out)[VARHDRSZ + INTALIGN(VARHDRSZ + len1)]), (void *) r.upper, len2 + VARHDRSZ - s); + + if (tinfo->str) + { + ((char *) out)[VARHDRSZ + INTALIGN(VARHDRSZ + len1) - 1] = '\0'; + ((char *) out)[2 * VARHDRSZ + INTALIGN(VARHDRSZ + len1) + len2 - 1] = '\0'; + } + *((int32 *) &(((char *) out)[VARHDRSZ])) = len1 + VARHDRSZ; + *((int32 *) &(((char *) out)[VARHDRSZ + INTALIGN(VARHDRSZ + len1)])) = len2 + VARHDRSZ; + + return out; } extern void -gbt_var_bin_union ( Datum * u , GBT_VARKEY * e , const gbtree_vinfo * tinfo ) +gbt_var_bin_union(Datum *u, GBT_VARKEY * e, const gbtree_vinfo * tinfo) { - GBT_VARKEY * nk = NULL; - GBT_VARKEY * tmp = NULL; - GBT_VARKEY_R nr ; - GBT_VARKEY_R eo = gbt_var_key_readable ( e ); - - - if ( eo.lower == eo.upper ) /* leaf */ - { - tmp = gbt_var_leaf2node ( e , tinfo ); - if ( tmp != e ) - eo = gbt_var_key_readable ( tmp ); - } - - if ( DatumGetPointer(*u)) - { - - GBT_VARKEY_R ro = gbt_var_key_readable ( ( GBT_VARKEY *) DatumGetPointer (*u) ); - - if ( (*tinfo->f_cmp) ( (bytea*)ro.lower, (bytea*)eo.lower ) > 0 ) { - nr.lower = eo.lower; - nr.upper = ro.upper; - nk = gbt_var_key_copy ( &nr, TRUE ); - } - if ( (*tinfo->f_cmp) ( (bytea*)ro.upper, (bytea*)eo.upper ) < 0 ) { - nr.upper = eo.upper; - nr.lower = ro.lower; - nk = gbt_var_key_copy ( &nr, TRUE ); - } - if ( nk ) - { - pfree( DatumGetPointer (*u) ); - *u = PointerGetDatum(nk); - } - - - - } - else - { - nr.lower = eo.lower; - nr.upper = eo.upper; - *u = PointerGetDatum( gbt_var_key_copy ( &nr, TRUE ) ); - } - - if ( tmp && tmp != e ) - pfree ( tmp ); + GBT_VARKEY *nk = NULL; + GBT_VARKEY *tmp = NULL; + GBT_VARKEY_R nr; + GBT_VARKEY_R eo = gbt_var_key_readable(e); + + + if (eo.lower == eo.upper) /* leaf */ + { + tmp = gbt_var_leaf2node(e, tinfo); + if (tmp != e) + eo = gbt_var_key_readable(tmp); + } + + if (DatumGetPointer(*u)) + { + + GBT_VARKEY_R ro = gbt_var_key_readable((GBT_VARKEY *) DatumGetPointer(*u)); + + if ((*tinfo->f_cmp) ((bytea *) ro.lower, (bytea *) eo.lower) > 0) + { + nr.lower = eo.lower; + nr.upper = ro.upper; + nk = gbt_var_key_copy(&nr, TRUE); + } + if ((*tinfo->f_cmp) ((bytea *) ro.upper, (bytea *) eo.upper) < 0) + { + nr.upper = eo.upper; + nr.lower = ro.lower; + nk = gbt_var_key_copy(&nr, TRUE); + } + if (nk) + { + pfree(DatumGetPointer(*u)); + *u = PointerGetDatum(nk); + } + + + + } + else + { + nr.lower = eo.lower; + nr.upper = eo.upper; + *u = PointerGetDatum(gbt_var_key_copy(&nr, TRUE)); + } + + if (tmp && tmp != e) + pfree(tmp); } -extern GISTENTRY * -gbt_var_compress ( GISTENTRY *entry , const gbtree_vinfo * tinfo ) +extern GISTENTRY * +gbt_var_compress(GISTENTRY *entry, const gbtree_vinfo * tinfo) { - GISTENTRY * retval; + GISTENTRY *retval; - if (entry->leafkey) - { - GBT_VARKEY * r = NULL; - bytea * tstd = ( bytea * ) DatumGetPointer ( entry->key ); /* toasted */ - bytea * leaf = ( bytea * ) DatumGetPointer ( PG_DETOAST_DATUM ( entry->key ) ); /* untoasted */ - GBT_VARKEY_R u ; + if (entry->leafkey) + { + GBT_VARKEY *r = NULL; + bytea *tstd = (bytea *) DatumGetPointer(entry->key); /* toasted */ + bytea *leaf = (bytea *) DatumGetPointer(PG_DETOAST_DATUM(entry->key)); /* untoasted */ + GBT_VARKEY_R u; - u.lower = u.upper = leaf; - r = gbt_var_key_copy ( &u , FALSE ); + u.lower = u.upper = leaf; + r = gbt_var_key_copy(&u, FALSE); - if ( tstd != leaf ){ - pfree(leaf); - } - retval = palloc(sizeof(GISTENTRY)); - gistentryinit(*retval, PointerGetDatum(r), - entry->rel, entry->page, - entry->offset, VARSIZE(r), TRUE); - } else { - retval = entry; + if (tstd != leaf) + pfree(leaf); + retval = palloc(sizeof(GISTENTRY)); + gistentryinit(*retval, PointerGetDatum(r), + entry->rel, entry->page, + entry->offset, VARSIZE(r), TRUE); + } + else + { + retval = entry; - } + } - return (retval); + return (retval); } extern GBT_VARKEY * -gbt_var_union ( const GistEntryVector * entryvec , int32 * size , const gbtree_vinfo * tinfo ) +gbt_var_union(const GistEntryVector *entryvec, int32 *size, const gbtree_vinfo * tinfo) { - int i = 0, - numranges = entryvec->n; - GBT_VARKEY *cur, - *tst=NULL; - Datum out; - GBT_VARKEY_R rk; + int i = 0, + numranges = entryvec->n; + GBT_VARKEY *cur, + *tst = NULL; + Datum out; + GBT_VARKEY_R rk; - *size = sizeof(GBT_VARKEY); + *size = sizeof(GBT_VARKEY); - tst = (GBT_VARKEY *) DatumGetPointer((entryvec->vector[0].key)); - cur = (GBT_VARKEY *) DatumGetPointer(PG_DETOAST_DATUM((entryvec->vector[0].key))); - rk = gbt_var_key_readable ( cur ); - out = PointerGetDatum ( gbt_var_key_copy( &rk, TRUE ) ); - if ( tst != cur ) pfree ( cur ); + tst = (GBT_VARKEY *) DatumGetPointer((entryvec->vector[0].key)); + cur = (GBT_VARKEY *) DatumGetPointer(PG_DETOAST_DATUM((entryvec->vector[0].key))); + rk = gbt_var_key_readable(cur); + out = PointerGetDatum(gbt_var_key_copy(&rk, TRUE)); + if (tst != cur) + pfree(cur); - for (i = 1; i < numranges; i++) - { - tst = (GBT_VARKEY *) DatumGetPointer((entryvec->vector[i].key)); - cur = (GBT_VARKEY *) DatumGetPointer(PG_DETOAST_DATUM((entryvec->vector[i].key))); - gbt_var_bin_union ( &out , cur , tinfo ); - if ( tst != cur ) pfree ( cur ); - } + for (i = 1; i < numranges; i++) + { + tst = (GBT_VARKEY *) DatumGetPointer((entryvec->vector[i].key)); + cur = (GBT_VARKEY *) DatumGetPointer(PG_DETOAST_DATUM((entryvec->vector[i].key))); + gbt_var_bin_union(&out, cur, tinfo); + if (tst != cur) + pfree(cur); + } - /* Truncate (=compress) key */ + /* Truncate (=compress) key */ - if ( tinfo->trnc ) - { - int32 plen ; - GBT_VARKEY *trc = NULL; + if (tinfo->trnc) + { + int32 plen; + GBT_VARKEY *trc = NULL; - plen = gbt_var_node_cp_len ( (GBT_VARKEY *) DatumGetPointer(out) , tinfo ); - trc = gbt_var_node_truncate ( (GBT_VARKEY *) DatumGetPointer(out) , plen+1 , tinfo ) ; + plen = gbt_var_node_cp_len((GBT_VARKEY *) DatumGetPointer(out), tinfo); + trc = gbt_var_node_truncate((GBT_VARKEY *) DatumGetPointer(out), plen + 1, tinfo); - pfree ( DatumGetPointer(out) ); - out = PointerGetDatum ( trc ); - } + pfree(DatumGetPointer(out)); + out = PointerGetDatum(trc); + } - return ( (GBT_VARKEY *) DatumGetPointer ( out ) ); + return ((GBT_VARKEY *) DatumGetPointer(out)); } -extern bool gbt_var_same ( bool * result, const Datum d1 , const Datum d2 , const gbtree_vinfo * tinfo ){ - - GBT_VARKEY *tst1 = (GBT_VARKEY *) DatumGetPointer(d1); - GBT_VARKEY *t1 = (GBT_VARKEY *) DatumGetPointer( PG_DETOAST_DATUM(d1) ); - GBT_VARKEY *tst2 = (GBT_VARKEY *) DatumGetPointer(d2); - GBT_VARKEY *t2 = (GBT_VARKEY *) DatumGetPointer( PG_DETOAST_DATUM(d2) ); - GBT_VARKEY_R r1, r2; - r1 = gbt_var_key_readable ( t1 ); - r2 = gbt_var_key_readable ( t2 ); - - if (t1 && t2){ - *result = ( ( (*tinfo->f_cmp ) ( (bytea*)r1.lower, (bytea*)r2.lower) == 0 - && (*tinfo->f_cmp) ( (bytea*)r1.upper, (bytea*)r2.upper) == 0 ) ? TRUE : FALSE ); - } else - *result = (t1 == NULL && t2 == NULL) ? TRUE : FALSE; - - if ( tst1 != t1 ) pfree (t1); - if ( tst2 != t2 ) pfree (t2); +extern bool +gbt_var_same(bool *result, const Datum d1, const Datum d2, const gbtree_vinfo * tinfo) +{ - PG_RETURN_POINTER(result); + GBT_VARKEY *tst1 = (GBT_VARKEY *) DatumGetPointer(d1); + GBT_VARKEY *t1 = (GBT_VARKEY *) DatumGetPointer(PG_DETOAST_DATUM(d1)); + GBT_VARKEY *tst2 = (GBT_VARKEY *) DatumGetPointer(d2); + GBT_VARKEY *t2 = (GBT_VARKEY *) DatumGetPointer(PG_DETOAST_DATUM(d2)); + GBT_VARKEY_R r1, + r2; + + r1 = gbt_var_key_readable(t1); + r2 = gbt_var_key_readable(t2); + + if (t1 && t2) + { + *result = (((*tinfo->f_cmp) ((bytea *) r1.lower, (bytea *) r2.lower) == 0 + && (*tinfo->f_cmp) ((bytea *) r1.upper, (bytea *) r2.upper) == 0) ? TRUE : FALSE); + } + else + *result = (t1 == NULL && t2 == NULL) ? TRUE : FALSE; + + if (tst1 != t1) + pfree(t1); + if (tst2 != t2) + pfree(t2); + + PG_RETURN_POINTER(result); } extern float * -gbt_var_penalty ( float * res , const GISTENTRY * o , const GISTENTRY * n, const gbtree_vinfo * tinfo ) +gbt_var_penalty(float *res, const GISTENTRY *o, const GISTENTRY *n, const gbtree_vinfo * tinfo) { - GBT_VARKEY *orgt = (GBT_VARKEY *) DatumGetPointer(o->key); - GBT_VARKEY *orge = (GBT_VARKEY *) DatumGetPointer( PG_DETOAST_DATUM(o->key) ); - GBT_VARKEY *newt = (GBT_VARKEY *) DatumGetPointer(n->key); - GBT_VARKEY *newe = (GBT_VARKEY *) DatumGetPointer( PG_DETOAST_DATUM(n->key) ); - GBT_VARKEY_R ok , nk; - GBT_VARKEY *tmp = NULL; - int32 s = (tinfo->str)?(1):(0); - - *res = 0.0; - - nk = gbt_var_key_readable ( newe ); - if ( nk.lower == nk.upper ) /* leaf */ - { - tmp = gbt_var_leaf2node ( newe , tinfo ); - if ( tmp != newe ) - nk = gbt_var_key_readable ( tmp ); - } - ok = gbt_var_key_readable ( orge ); - - if ( ( VARSIZE(ok.lower) - VARHDRSZ ) == s && ( VARSIZE(ok.upper) - VARHDRSZ ) == s ) - { - *res = 0.0; - } else - if ( ! ( - ( - ( (*tinfo->f_cmp) (nk.lower, ok.lower)>=0 || gbt_bytea_pf_match(ok.lower, nk.lower, tinfo ) ) && - ( (*tinfo->f_cmp) (nk.upper, ok.upper)<=0 || gbt_bytea_pf_match(ok.upper, nk.upper, tinfo ) ) - ) - ) ) - { - Datum d = PointerGetDatum (0); - double dres = 0.0; - int32 ol, ul; - - gbt_var_bin_union ( &d , orge , tinfo ); - ol = gbt_var_node_cp_len ( ( GBT_VARKEY *) DatumGetPointer(d), tinfo ); - gbt_var_bin_union ( &d , newe , tinfo ); - ul = gbt_var_node_cp_len ( ( GBT_VARKEY *) DatumGetPointer(d), tinfo ); - - if ( ul < ol ) { - dres = ( ol-ul ) ; /* lost of common prefix len */ - } else { - GBT_VARKEY_R uk = gbt_var_key_readable ( ( GBT_VARKEY *) DatumGetPointer(d) ); - if ( tinfo->str ) - { - dres = ( VARDATA(ok.lower)[ul]-VARDATA(uk.lower)[ul] ) + - ( VARDATA(uk.upper)[ul]-VARDATA(ok.upper)[ul] ); - } else { - char tmp[4]; - tmp[0] = ( ( VARSIZE(ok.lower) - VARHDRSZ ) == ul )?(CHAR_MIN):(VARDATA(ok.lower)[ul]); - tmp[1] = ( ( VARSIZE(uk.lower) - VARHDRSZ ) == ul )?(CHAR_MIN):(VARDATA(uk.lower)[ul]); - tmp[2] = ( ( VARSIZE(ok.upper) - VARHDRSZ ) == ul )?(CHAR_MIN):(VARDATA(ok.upper)[ul]); - tmp[3] = ( ( VARSIZE(uk.upper) - VARHDRSZ ) == ul )?(CHAR_MIN):(VARDATA(uk.upper)[ul]); - dres = ( tmp[0] - tmp[1] ) + - ( tmp[3] - tmp[2] ); - } - dres /= 256.0; - } - pfree ( DatumGetPointer(d) ); - - *res += FLT_MIN ; - *res += (float) ( dres / ( (double) ( ol +1 ) ) ); - *res *= ( FLT_MAX / ( o->rel->rd_att->natts + 1 ) ); - - } - - if ( tmp && tmp != newe ) - pfree (tmp); - - if ( newe != newt ){ - pfree ( newe ); - } - - if ( orge != orgt ){ - pfree ( orge ); - } - return res ; + GBT_VARKEY *orgt = (GBT_VARKEY *) DatumGetPointer(o->key); + GBT_VARKEY *orge = (GBT_VARKEY *) DatumGetPointer(PG_DETOAST_DATUM(o->key)); + GBT_VARKEY *newt = (GBT_VARKEY *) DatumGetPointer(n->key); + GBT_VARKEY *newe = (GBT_VARKEY *) DatumGetPointer(PG_DETOAST_DATUM(n->key)); + GBT_VARKEY_R ok, + nk; + GBT_VARKEY *tmp = NULL; + int32 s = (tinfo->str) ? (1) : (0); + + *res = 0.0; + + nk = gbt_var_key_readable(newe); + if (nk.lower == nk.upper) /* leaf */ + { + tmp = gbt_var_leaf2node(newe, tinfo); + if (tmp != newe) + nk = gbt_var_key_readable(tmp); + } + ok = gbt_var_key_readable(orge); + + if ((VARSIZE(ok.lower) - VARHDRSZ) == s && (VARSIZE(ok.upper) - VARHDRSZ) == s) + *res = 0.0; + else if (!( + ( + ((*tinfo->f_cmp) (nk.lower, ok.lower) >= 0 || gbt_bytea_pf_match(ok.lower, nk.lower, tinfo)) && + ((*tinfo->f_cmp) (nk.upper, ok.upper) <= 0 || gbt_bytea_pf_match(ok.upper, nk.upper, tinfo)) + ) + )) + { + Datum d = PointerGetDatum(0); + double dres = 0.0; + int32 ol, + ul; + + gbt_var_bin_union(&d, orge, tinfo); + ol = gbt_var_node_cp_len((GBT_VARKEY *) DatumGetPointer(d), tinfo); + gbt_var_bin_union(&d, newe, tinfo); + ul = gbt_var_node_cp_len((GBT_VARKEY *) DatumGetPointer(d), tinfo); + + if (ul < ol) + { + dres = (ol - ul); /* lost of common prefix len */ + } + else + { + GBT_VARKEY_R uk = gbt_var_key_readable((GBT_VARKEY *) DatumGetPointer(d)); + + if (tinfo->str) + { + dres = (VARDATA(ok.lower)[ul] - VARDATA(uk.lower)[ul]) + + (VARDATA(uk.upper)[ul] - VARDATA(ok.upper)[ul]); + } + else + { + char tmp[4]; + + tmp[0] = ((VARSIZE(ok.lower) - VARHDRSZ) == ul) ? (CHAR_MIN) : (VARDATA(ok.lower)[ul]); + tmp[1] = ((VARSIZE(uk.lower) - VARHDRSZ) == ul) ? (CHAR_MIN) : (VARDATA(uk.lower)[ul]); + tmp[2] = ((VARSIZE(ok.upper) - VARHDRSZ) == ul) ? (CHAR_MIN) : (VARDATA(ok.upper)[ul]); + tmp[3] = ((VARSIZE(uk.upper) - VARHDRSZ) == ul) ? (CHAR_MIN) : (VARDATA(uk.upper)[ul]); + dres = (tmp[0] - tmp[1]) + + (tmp[3] - tmp[2]); + } + dres /= 256.0; + } + pfree(DatumGetPointer(d)); + + *res += FLT_MIN; + *res += (float) (dres / ((double) (ol + 1))); + *res *= (FLT_MAX / (o->rel->rd_att->natts + 1)); + + } + + if (tmp && tmp != newe) + pfree(tmp); + + if (newe != newt) + pfree(newe); + + if (orge != orgt) + pfree(orge); + return res; } @@ -419,198 +449,194 @@ gbt_var_penalty ( float * res , const GISTENTRY * o , const GISTENTRY * n, const /* * Fortunately, this sort comparsion routine needn't be reentrant... */ -static const gbtree_vinfo * gbt_vsrt_cmp_tinfo; +static const gbtree_vinfo *gbt_vsrt_cmp_tinfo; static int gbt_vsrt_cmp(const void *a, const void *b) { - GBT_VARKEY_R ar = gbt_var_key_readable ( ((const Vsrt *) a)->t ); - GBT_VARKEY_R br = gbt_var_key_readable ( ((const Vsrt *) b)->t ); + GBT_VARKEY_R ar = gbt_var_key_readable(((const Vsrt *) a)->t); + GBT_VARKEY_R br = gbt_var_key_readable(((const Vsrt *) b)->t); - return (*gbt_vsrt_cmp_tinfo->f_cmp) ( ar.lower, br.lower ); + return (*gbt_vsrt_cmp_tinfo->f_cmp) (ar.lower, br.lower); } extern GIST_SPLITVEC * -gbt_var_picksplit( const GistEntryVector *entryvec, GIST_SPLITVEC *v, const gbtree_vinfo * tinfo ) +gbt_var_picksplit(const GistEntryVector *entryvec, GIST_SPLITVEC *v, const gbtree_vinfo * tinfo) { - OffsetNumber i, - maxoff = entryvec->n - 1; - Vsrt *arr; - int pfrcntr = 0 , - svcntr = 0 , - nbytes ; - char * tst , - * cur ; - char **pfr = NULL ; - GBT_VARKEY **sv = NULL; - - arr = (Vsrt *) palloc((maxoff+1) * sizeof(Vsrt)); - nbytes = (maxoff + 2) * sizeof(OffsetNumber); - v->spl_left = (OffsetNumber *) palloc(nbytes); - v->spl_right = (OffsetNumber *) palloc(nbytes); - v->spl_ldatum = PointerGetDatum(0); - v->spl_rdatum = PointerGetDatum(0); - v->spl_nleft = 0; - v->spl_nright = 0; - - pfr = palloc ( sizeof ( GBT_VARKEY* ) * (maxoff+1) ); - sv = palloc ( sizeof ( bytea * ) * (maxoff+1) ); - - /* Sort entries */ - - for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) - { - GBT_VARKEY_R ro; - tst = (char *) DatumGetPointer((entryvec->vector[i].key)); - cur = (char *) DatumGetPointer(PG_DETOAST_DATUM((entryvec->vector[i].key))); - if ( tst != cur ){ - pfr[pfrcntr] = cur ; - pfrcntr++; - } - ro = gbt_var_key_readable( ( GBT_VARKEY *) cur ); - if ( ro.lower == ro.upper ) /* leaf */ - { - sv[svcntr] = gbt_var_leaf2node ( ( GBT_VARKEY *) cur , tinfo ); - arr[i].t = sv[svcntr]; - if ( sv[svcntr] != ( GBT_VARKEY *) cur ) - svcntr++; - } else { - arr[i].t = ( GBT_VARKEY *) cur; - } - arr[i].i = i; - } - - /* sort */ + OffsetNumber i, + maxoff = entryvec->n - 1; + Vsrt *arr; + int pfrcntr = 0, + svcntr = 0, + nbytes; + char *tst, + *cur; + char **pfr = NULL; + GBT_VARKEY **sv = NULL; + + arr = (Vsrt *) palloc((maxoff + 1) * sizeof(Vsrt)); + nbytes = (maxoff + 2) * sizeof(OffsetNumber); + v->spl_left = (OffsetNumber *) palloc(nbytes); + v->spl_right = (OffsetNumber *) palloc(nbytes); + v->spl_ldatum = PointerGetDatum(0); + v->spl_rdatum = PointerGetDatum(0); + v->spl_nleft = 0; + v->spl_nright = 0; + + pfr = palloc(sizeof(GBT_VARKEY *) * (maxoff + 1)); + sv = palloc(sizeof(bytea *) * (maxoff + 1)); + + /* Sort entries */ + + for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) + { + GBT_VARKEY_R ro; + + tst = (char *) DatumGetPointer((entryvec->vector[i].key)); + cur = (char *) DatumGetPointer(PG_DETOAST_DATUM((entryvec->vector[i].key))); + if (tst != cur) + { + pfr[pfrcntr] = cur; + pfrcntr++; + } + ro = gbt_var_key_readable((GBT_VARKEY *) cur); + if (ro.lower == ro.upper) /* leaf */ + { + sv[svcntr] = gbt_var_leaf2node((GBT_VARKEY *) cur, tinfo); + arr[i].t = sv[svcntr]; + if (sv[svcntr] != (GBT_VARKEY *) cur) + svcntr++; + } + else + arr[i].t = (GBT_VARKEY *) cur; + arr[i].i = i; + } + + /* sort */ gbt_vsrt_cmp_tinfo = tinfo; - qsort((void*) &arr[FirstOffsetNumber], - maxoff-FirstOffsetNumber+1, + qsort((void *) &arr[FirstOffsetNumber], + maxoff - FirstOffsetNumber + 1, sizeof(Vsrt), gbt_vsrt_cmp); - /* We do simply create two parts */ - - for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) - { - if (i <= (maxoff - FirstOffsetNumber + 1) / 2) - { - gbt_var_bin_union(&v->spl_ldatum, arr[i].t, tinfo); - v->spl_left[v->spl_nleft] = arr[i].i; - v->spl_nleft++; - } - else - { - gbt_var_bin_union(&v->spl_rdatum, arr[i].t, tinfo); - v->spl_right[v->spl_nright] = arr[i].i; - v->spl_nright++; - } - } - - /* Free detoasted keys */ - for ( i=0 ; i<pfrcntr; i++ ){ - pfree( pfr[i] ); - } - - /* Free strxfrm'ed leafs */ - for ( i=0 ; i<svcntr; i++ ){ - pfree( sv[i] ); - } - - if ( pfr ) - { - pfree (pfr); - } - - if ( sv ) - { - pfree (sv); - } - - /* Truncate (=compress) key */ - - if ( tinfo->trnc ) - { - - int32 ll = gbt_var_node_cp_len ( (GBT_VARKEY *) DatumGetPointer(v->spl_ldatum) , tinfo ); - int32 lr = gbt_var_node_cp_len ( (GBT_VARKEY *) DatumGetPointer(v->spl_rdatum) , tinfo ); - GBT_VARKEY * dl ; - GBT_VARKEY * dr ; - - ll = Max (ll,lr); - ll++; - - dl = gbt_var_node_truncate ( (GBT_VARKEY *) DatumGetPointer(v->spl_ldatum) , ll, tinfo ) ; - dr = gbt_var_node_truncate ( (GBT_VARKEY *) DatumGetPointer(v->spl_rdatum) , ll, tinfo ) ; - pfree( DatumGetPointer(v->spl_ldatum) ); - pfree( DatumGetPointer(v->spl_rdatum) ); - v->spl_ldatum = PointerGetDatum ( dl ); - v->spl_rdatum = PointerGetDatum ( dr ); - - } + /* We do simply create two parts */ + + for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) + { + if (i <= (maxoff - FirstOffsetNumber + 1) / 2) + { + gbt_var_bin_union(&v->spl_ldatum, arr[i].t, tinfo); + v->spl_left[v->spl_nleft] = arr[i].i; + v->spl_nleft++; + } + else + { + gbt_var_bin_union(&v->spl_rdatum, arr[i].t, tinfo); + v->spl_right[v->spl_nright] = arr[i].i; + v->spl_nright++; + } + } + + /* Free detoasted keys */ + for (i = 0; i < pfrcntr; i++) + pfree(pfr[i]); + + /* Free strxfrm'ed leafs */ + for (i = 0; i < svcntr; i++) + pfree(sv[i]); + + if (pfr) + pfree(pfr); + + if (sv) + pfree(sv); + + /* Truncate (=compress) key */ + + if (tinfo->trnc) + { + + int32 ll = gbt_var_node_cp_len((GBT_VARKEY *) DatumGetPointer(v->spl_ldatum), tinfo); + int32 lr = gbt_var_node_cp_len((GBT_VARKEY *) DatumGetPointer(v->spl_rdatum), tinfo); + GBT_VARKEY *dl; + GBT_VARKEY *dr; + + ll = Max(ll, lr); + ll++; + + dl = gbt_var_node_truncate((GBT_VARKEY *) DatumGetPointer(v->spl_ldatum), ll, tinfo); + dr = gbt_var_node_truncate((GBT_VARKEY *) DatumGetPointer(v->spl_rdatum), ll, tinfo); + pfree(DatumGetPointer(v->spl_ldatum)); + pfree(DatumGetPointer(v->spl_rdatum)); + v->spl_ldatum = PointerGetDatum(dl); + v->spl_rdatum = PointerGetDatum(dr); + + } pfree(arr); - return v; + return v; } /* * The GiST consistent method */ -extern bool -gbt_var_consistent( - GBT_VARKEY_R * key, - const void * query, - const StrategyNumber * strategy, - bool is_leaf, - const gbtree_vinfo * tinfo +extern bool +gbt_var_consistent( + GBT_VARKEY_R * key, + const void *query, + const StrategyNumber *strategy, + bool is_leaf, + const gbtree_vinfo * tinfo ) { - bool retval = FALSE; - - switch (*strategy) - { - case BTLessEqualStrategyNumber: - if ( is_leaf ) - retval = (*tinfo->f_ge)(query, (void*) key->lower); - else - retval = (*tinfo->f_cmp)((bytea*) query, key->lower) >= 0 - || gbt_var_node_pf_match( key ,query, tinfo ); - break; - case BTLessStrategyNumber: - if ( is_leaf ) - retval = (*tinfo->f_gt)(query, (void*) key->lower); - else - retval = (*tinfo->f_cmp)((bytea*)query, key->lower) >= 0 - || gbt_var_node_pf_match( key, query , tinfo ); - break; - case BTEqualStrategyNumber: - if ( is_leaf ) - retval = (*tinfo->f_eq)(query, (void*) key->lower); - else - retval = ( - ( - (*tinfo->f_cmp) (key->lower,(bytea*) query)<=0 && - (*tinfo->f_cmp) ((bytea*)query, (void*) key->upper)<=0 - ) || gbt_var_node_pf_match( key, query, tinfo ) - ); - break; - case BTGreaterStrategyNumber: - if ( is_leaf ) - retval = (*tinfo->f_lt)(query, (void*) key->upper); - else - retval = (*tinfo->f_cmp)((bytea*)query, key->upper)<=0 - || gbt_var_node_pf_match( key, query, tinfo ); - break; - case BTGreaterEqualStrategyNumber: - if ( is_leaf ) - retval = (*tinfo->f_le)(query, (void*) key->upper); - else - retval = (*tinfo->f_cmp)((bytea*) query, key->upper)<=0 - || gbt_var_node_pf_match( key, query, tinfo ); - break; - default: - retval = FALSE; - } - - return (retval); + bool retval = FALSE; + + switch (*strategy) + { + case BTLessEqualStrategyNumber: + if (is_leaf) + retval = (*tinfo->f_ge) (query, (void *) key->lower); + else + retval = (*tinfo->f_cmp) ((bytea *) query, key->lower) >= 0 + || gbt_var_node_pf_match(key, query, tinfo); + break; + case BTLessStrategyNumber: + if (is_leaf) + retval = (*tinfo->f_gt) (query, (void *) key->lower); + else + retval = (*tinfo->f_cmp) ((bytea *) query, key->lower) >= 0 + || gbt_var_node_pf_match(key, query, tinfo); + break; + case BTEqualStrategyNumber: + if (is_leaf) + retval = (*tinfo->f_eq) (query, (void *) key->lower); + else + retval = ( + ( + (*tinfo->f_cmp) (key->lower, (bytea *) query) <= 0 && + (*tinfo->f_cmp) ((bytea *) query, (void *) key->upper) <= 0 + ) || gbt_var_node_pf_match(key, query, tinfo) + ); + break; + case BTGreaterStrategyNumber: + if (is_leaf) + retval = (*tinfo->f_lt) (query, (void *) key->upper); + else + retval = (*tinfo->f_cmp) ((bytea *) query, key->upper) <= 0 + || gbt_var_node_pf_match(key, query, tinfo); + break; + case BTGreaterEqualStrategyNumber: + if (is_leaf) + retval = (*tinfo->f_le) (query, (void *) key->upper); + else + retval = (*tinfo->f_cmp) ((bytea *) query, key->upper) <= 0 + || gbt_var_node_pf_match(key, query, tinfo); + break; + default: + retval = FALSE; + } + + return (retval); } diff --git a/contrib/btree_gist/btree_utils_var.h b/contrib/btree_gist/btree_utils_var.h index 086891b158..ecb3f3f3f1 100644 --- a/contrib/btree_gist/btree_utils_var.h +++ b/contrib/btree_gist/btree_utils_var.h @@ -5,15 +5,16 @@ typedef bytea GBT_VARKEY; /* Better readable key */ typedef struct { - bytea * lower, * upper; -} GBT_VARKEY_R; + bytea *lower, + *upper; +} GBT_VARKEY_R; /* used for key sorting */ typedef struct { - int i ; - GBT_VARKEY * t ; -} Vsrt ; + int i; + GBT_VARKEY *t; +} Vsrt; /* type description @@ -23,45 +24,45 @@ typedef struct typedef struct { - /* Attribs */ + /* Attribs */ - enum gbtree_type t ; /* data type */ - bool str ; /* true, if string ( else binary ) */ - bool trnc ; /* truncate (=compress) key */ + enum gbtree_type t; /* data type */ + bool str; /* true, if string ( else binary ) */ + bool trnc; /* truncate (=compress) key */ - /* Methods */ + /* Methods */ - bool (*f_gt) ( const void * , const void * ); /* greater then */ - bool (*f_ge) ( const void * , const void * ); /* greater equal */ - bool (*f_eq) ( const void * , const void * ); /* equal */ - bool (*f_le) ( const void * , const void * ); /* less equal */ - bool (*f_lt) ( const void * , const void * ); /* less then */ - int32 (*f_cmp) ( const bytea * , const bytea * ); /* node compare */ - GBT_VARKEY* (*f_l2n) ( GBT_VARKEY * ); /* convert leaf to node */ -} gbtree_vinfo; + bool (*f_gt) (const void *, const void *); /* greater then */ + bool (*f_ge) (const void *, const void *); /* greater equal */ + bool (*f_eq) (const void *, const void *); /* equal */ + bool (*f_le) (const void *, const void *); /* less equal */ + bool (*f_lt) (const void *, const void *); /* less then */ + int32 (*f_cmp) (const bytea *, const bytea *); /* node compare */ + GBT_VARKEY *(*f_l2n) (GBT_VARKEY *); /* convert leaf to node */ +} gbtree_vinfo; -extern GBT_VARKEY_R gbt_var_key_readable ( const GBT_VARKEY * k ); +extern GBT_VARKEY_R gbt_var_key_readable(const GBT_VARKEY * k); -extern GBT_VARKEY *gbt_var_key_copy ( const GBT_VARKEY_R * u, bool force_node ); +extern GBT_VARKEY *gbt_var_key_copy(const GBT_VARKEY_R * u, bool force_node); -extern GISTENTRY *gbt_var_compress ( GISTENTRY *entry , const gbtree_vinfo * tinfo ); +extern GISTENTRY *gbt_var_compress(GISTENTRY *entry, const gbtree_vinfo * tinfo); -extern GBT_VARKEY *gbt_var_union ( const GistEntryVector * entryvec , int32 * size , - const gbtree_vinfo * tinfo ); +extern GBT_VARKEY *gbt_var_union(const GistEntryVector *entryvec, int32 *size, + const gbtree_vinfo * tinfo); -extern bool gbt_var_same ( bool * result, const Datum d1 , const Datum d2 , - const gbtree_vinfo * tinfo ); +extern bool gbt_var_same(bool *result, const Datum d1, const Datum d2, + const gbtree_vinfo * tinfo); -extern float *gbt_var_penalty ( float * res , const GISTENTRY * o , const GISTENTRY * n, - const gbtree_vinfo * tinfo ); +extern float *gbt_var_penalty(float *res, const GISTENTRY *o, const GISTENTRY *n, + const gbtree_vinfo * tinfo); -extern bool gbt_var_consistent( GBT_VARKEY_R * key , const void * query, - const StrategyNumber * strategy , bool is_leaf, - const gbtree_vinfo * tinfo ); +extern bool gbt_var_consistent(GBT_VARKEY_R * key, const void *query, + const StrategyNumber *strategy, bool is_leaf, + const gbtree_vinfo * tinfo); -extern GIST_SPLITVEC *gbt_var_picksplit ( const GistEntryVector *entryvec, GIST_SPLITVEC *v, - const gbtree_vinfo * tinfo ); -extern void gbt_var_bin_union ( Datum * u , GBT_VARKEY * e , - const gbtree_vinfo * tinfo ); +extern GIST_SPLITVEC *gbt_var_picksplit(const GistEntryVector *entryvec, GIST_SPLITVEC *v, + const gbtree_vinfo * tinfo); +extern void gbt_var_bin_union(Datum *u, GBT_VARKEY * e, + const gbtree_vinfo * tinfo); diff --git a/contrib/cube/cube.c b/contrib/cube/cube.c index b2cf5cf551..66b7334543 100644 --- a/contrib/cube/cube.c +++ b/contrib/cube/cube.c @@ -230,7 +230,7 @@ g_cube_union(GistEntryVector *entryvec, int *sizep) for (i = 1; i < entryvec->n; i++) { out = g_cube_binary_union(tmp, (NDBOX *) - DatumGetPointer(entryvec->vector[i].key), + DatumGetPointer(entryvec->vector[i].key), sizep); if (i > 1) pfree(tmp); diff --git a/contrib/dbase/dbf2pg.c b/contrib/dbase/dbf2pg.c index 1c01f7d1d6..9a1f89ea1f 100644 --- a/contrib/dbase/dbf2pg.c +++ b/contrib/dbase/dbf2pg.c @@ -700,8 +700,8 @@ main(int argc, char **argv) if (verbose > 1) printf("Opening dbf-file\n"); - setlocale(LC_ALL, ""); /* fix for isprint() */ - + setlocale(LC_ALL, ""); /* fix for isprint() */ + if ((dbh = dbf_open(argv[0], O_RDONLY)) == (dbhead *) - 1) { fprintf(stderr, "Couldn't open xbase-file %s\n", argv[0]); diff --git a/contrib/dblink/dblink.c b/contrib/dblink/dblink.c index 217497bc99..17f36f1306 100644 --- a/contrib/dblink/dblink.c +++ b/contrib/dblink/dblink.c @@ -571,8 +571,8 @@ dblink_fetch(PG_FUNCTION_ARGS) rsinfo->expectedDesc == NULL) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), - errmsg("function returning record called in context " - "that cannot accept type record"))); + errmsg("function returning record called in context " + "that cannot accept type record"))); /* get the requested return tuple description */ tupdesc = CreateTupleDescCopy(rsinfo->expectedDesc); @@ -777,8 +777,8 @@ dblink_record(PG_FUNCTION_ARGS) rsinfo->expectedDesc == NULL) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), - errmsg("function returning record called in context " - "that cannot accept type record"))); + errmsg("function returning record called in context " + "that cannot accept type record"))); /* get the requested return tuple description */ tupdesc = CreateTupleDescCopy(rsinfo->expectedDesc); diff --git a/contrib/dbmirror/pending.c b/contrib/dbmirror/pending.c index 638737dc53..287b2b31b4 100644 --- a/contrib/dbmirror/pending.c +++ b/contrib/dbmirror/pending.c @@ -43,17 +43,17 @@ enum FieldUsage }; int storePending(char *cpTableName, HeapTuple tBeforeTuple, - HeapTuple tAfterTuple, - TupleDesc tTupdesc, - Oid tableOid, - char cOp); + HeapTuple tAfterTuple, + TupleDesc tTupdesc, + Oid tableOid, + char cOp); int storeKeyInfo(char *cpTableName, HeapTuple tTupleData, TupleDesc tTuplDesc, - Oid tableOid); -int storeData(char *cpTableName, HeapTuple tTupleData, - TupleDesc tTupleDesc,Oid tableOid,int iIncludeKeyData); + Oid tableOid); +int storeData(char *cpTableName, HeapTuple tTupleData, + TupleDesc tTupleDesc, Oid tableOid, int iIncludeKeyData); int2vector *getPrimaryKey(Oid tblOid); @@ -74,10 +74,9 @@ PG_FUNCTION_INFO_V1(recordchange); #define debug_msg(x) elog(NOTICE,x) #define debug_msg3(x,y,z) elog(NOTICE,x,y,z) #else -#define debug_msg2(x,y) +#define debug_msg2(x,y) #define debug_msg(x) #define debug_msg3(x,y,z) - #endif @@ -85,8 +84,8 @@ PG_FUNCTION_INFO_V1(recordchange); extern Datum nextval(PG_FUNCTION_ARGS); extern Datum setval(PG_FUNCTION_ARGS); -int saveSequenceUpdate(const text * sequenceName, - int nextSequenceValue); +int saveSequenceUpdate(const text *sequenceName, + int nextSequenceValue); /***************************************************************************** @@ -107,15 +106,15 @@ recordchange(PG_FUNCTION_ARGS) char op = 0; char *schemaname; char *fullyqualtblname; - char *pkxpress=NULL; + char *pkxpress = NULL; if (fcinfo->context != NULL) { if (SPI_connect() < 0) { - ereport(ERROR,(errcode(ERRCODE_CONNECTION_FAILURE), - errmsg("dbmirror:recordchange could not connect to SPI"))); + ereport(ERROR, (errcode(ERRCODE_CONNECTION_FAILURE), + errmsg("dbmirror:recordchange could not connect to SPI"))); return -1; } trigdata = (TriggerData *) fcinfo->context; @@ -154,13 +153,13 @@ recordchange(PG_FUNCTION_ARGS) } else { - ereport(ERROR,(errcode(ERRCODE_TRIGGERED_ACTION_EXCEPTION), - errmsg("dbmirror:recordchange Unknown operation"))); - + ereport(ERROR, (errcode(ERRCODE_TRIGGERED_ACTION_EXCEPTION), + errmsg("dbmirror:recordchange Unknown operation"))); + } - if (storePending(fullyqualtblname, beforeTuple, afterTuple, - tupdesc, retTuple->t_tableOid, op)) + if (storePending(fullyqualtblname, beforeTuple, afterTuple, + tupdesc, retTuple->t_tableOid, op)) { /* An error occoured. Skip the operation. */ ereport(ERROR, @@ -173,8 +172,8 @@ recordchange(PG_FUNCTION_ARGS) debug_msg("dbmirror:recordchange returning on success"); SPI_pfree(fullyqualtblname); - if(pkxpress != NULL) - SPI_pfree(pkxpress); + if (pkxpress != NULL) + SPI_pfree(pkxpress); SPI_finish(); return PointerGetDatum(retTuple); } @@ -196,20 +195,20 @@ int storePending(char *cpTableName, HeapTuple tBeforeTuple, HeapTuple tAfterTuple, TupleDesc tTupDesc, - Oid tableOid, + Oid tableOid, char cOp) { char *cpQueryBase = "INSERT INTO dbmirror_pending (TableName,Op,XID) VALUES ($1,$2,$3)"; int iResult = 0; HeapTuple tCurTuple; - char nulls[3]=" "; + char nulls[3] = " "; /* Points the current tuple(before or after) */ Datum saPlanData[3]; - Oid taPlanArgTypes[4] = {NAMEOID, - CHAROID, - INT4OID}; + Oid taPlanArgTypes[4] = {NAMEOID, + CHAROID, + INT4OID}; void *vpPlan; tCurTuple = tBeforeTuple ? tBeforeTuple : tAfterTuple; @@ -218,8 +217,8 @@ storePending(char *cpTableName, HeapTuple tBeforeTuple, vpPlan = SPI_prepare(cpQueryBase, 3, taPlanArgTypes); if (vpPlan == NULL) - ereport(ERROR,(errcode(ERRCODE_TRIGGERED_ACTION_EXCEPTION), - errmsg("dbmirror:storePending error creating plan"))); + ereport(ERROR, (errcode(ERRCODE_TRIGGERED_ACTION_EXCEPTION), + errmsg("dbmirror:storePending error creating plan"))); saPlanData[0] = PointerGetDatum(cpTableName); @@ -228,8 +227,8 @@ storePending(char *cpTableName, HeapTuple tBeforeTuple, iResult = SPI_execp(vpPlan, saPlanData, nulls, 1); if (iResult < 0) - elog(NOTICE, "storedPending fired (%s) returned %d", - cpQueryBase, iResult); + elog(NOTICE, "storedPending fired (%s) returned %d", + cpQueryBase, iResult); @@ -242,8 +241,8 @@ storePending(char *cpTableName, HeapTuple tBeforeTuple, * This is a record of a delete operation. * Just store the key data. */ - iResult = storeKeyInfo(cpTableName, - tBeforeTuple, tTupDesc, tableOid); + iResult = storeKeyInfo(cpTableName, + tBeforeTuple, tTupDesc, tableOid); } else if (cOp == 'i') { @@ -251,18 +250,18 @@ storePending(char *cpTableName, HeapTuple tBeforeTuple, * An Insert operation. * Store all data */ - iResult = storeData(cpTableName, tAfterTuple, - tTupDesc, tableOid,TRUE); + iResult = storeData(cpTableName, tAfterTuple, + tTupDesc, tableOid, TRUE); } else { /* op must be an update. */ - iResult = storeKeyInfo(cpTableName, tBeforeTuple, - tTupDesc, tableOid); - iResult = iResult ? iResult : - storeData(cpTableName, tAfterTuple, tTupDesc, - tableOid,TRUE); + iResult = storeKeyInfo(cpTableName, tBeforeTuple, + tTupDesc, tableOid); + iResult = iResult ? iResult : + storeData(cpTableName, tAfterTuple, tTupDesc, + tableOid, TRUE); } @@ -292,7 +291,7 @@ storeKeyInfo(char *cpTableName, HeapTuple tTupleData, } /* pplan = SPI_saveplan(pplan); */ - cpKeyData = packageData(tTupleData, tTupleDesc,tableOid, PRIMARY); + cpKeyData = packageData(tTupleData, tTupleDesc, tableOid, PRIMARY); if (cpKeyData == NULL) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), @@ -312,8 +311,8 @@ storeKeyInfo(char *cpTableName, HeapTuple tTupleData, if (iRetCode != SPI_OK_INSERT) { - ereport(ERROR,(errcode(ERRCODE_TRIGGERED_ACTION_EXCEPTION) - ,errmsg("error inserting row in pendingDelete"))); + ereport(ERROR, (errcode(ERRCODE_TRIGGERED_ACTION_EXCEPTION) + ,errmsg("error inserting row in pendingDelete"))); return -1; } @@ -360,8 +359,8 @@ getPrimaryKey(Oid tblOid) * Stores a copy of the non-key data for the row. *****************************************************************************/ int -storeData(char *cpTableName, HeapTuple tTupleData, - TupleDesc tTupleDesc,Oid tableOid, int iIncludeKeyData) +storeData(char *cpTableName, HeapTuple tTupleData, + TupleDesc tTupleDesc, Oid tableOid, int iIncludeKeyData) { Oid planArgTypes[1] = {NAMEOID}; @@ -380,10 +379,10 @@ storeData(char *cpTableName, HeapTuple tTupleData, /* pplan = SPI_saveplan(pplan); */ if (iIncludeKeyData == 0) - cpKeyData = packageData(tTupleData, tTupleDesc, - tableOid, NONPRIMARY); + cpKeyData = packageData(tTupleData, tTupleDesc, + tableOid, NONPRIMARY); else - cpKeyData = packageData(tTupleData, tTupleDesc,tableOid, ALL); + cpKeyData = packageData(tTupleData, tTupleDesc, tableOid, ALL); planData[0] = PointerGetDatum(cpKeyData); iRetValue = SPI_execp(pplan, planData, NULL, 1); @@ -439,10 +438,10 @@ packageData(HeapTuple tTupleData, TupleDesc tTupleDesc, Oid tableOid, } if (tpPKeys != NULL) - { - debug_msg("dbmirror:packageData have primary keys"); + { + debug_msg("dbmirror:packageData have primary keys"); - } + } cpDataBlock = SPI_palloc(BUFFER_SIZE); iDataBlockSize = BUFFER_SIZE; @@ -463,18 +462,18 @@ packageData(HeapTuple tTupleData, TupleDesc tTupleDesc, Oid tableOid, /* Determine if this is a primary key or not. */ iIsPrimaryKey = 0; for (iPrimaryKeyIndex = 0; - (*tpPKeys)[iPrimaryKeyIndex] != 0; + (*tpPKeys)[iPrimaryKeyIndex] != 0; iPrimaryKeyIndex++) { - if ((*tpPKeys)[iPrimaryKeyIndex] - == iColumnCounter) + if ((*tpPKeys)[iPrimaryKeyIndex] + == iColumnCounter) { iIsPrimaryKey = 1; break; } } - if (iIsPrimaryKey ? (eKeyUsage != PRIMARY) : - (eKeyUsage != NONPRIMARY)) + if (iIsPrimaryKey ? (eKeyUsage != PRIMARY) : + (eKeyUsage != NONPRIMARY)) { /** * Don't use. @@ -486,34 +485,34 @@ packageData(HeapTuple tTupleData, TupleDesc tTupleDesc, Oid tableOid, } } /* KeyUsage!=ALL */ - if(tTupleDesc->attrs[iColumnCounter-1]->attisdropped) - { - /** - * This column has been dropped. - * Do not mirror it. - */ - continue; - } + if (tTupleDesc->attrs[iColumnCounter - 1]->attisdropped) + { + /** + * This column has been dropped. + * Do not mirror it. + */ + continue; + } cpFieldName = DatumGetPointer(NameGetDatum - - (&tTupleDesc->attrs - [iColumnCounter - 1]->attname)); + + (&tTupleDesc->attrs + [iColumnCounter - 1]->attname)); debug_msg2("dbmirror:packageData field name: %s", cpFieldName); - while (iDataBlockSize - iUsedDataBlock < - strlen(cpFieldName) + 6) + while (iDataBlockSize - iUsedDataBlock < + strlen(cpFieldName) + 6) { - cpDataBlock = SPI_repalloc(cpDataBlock, - iDataBlockSize + - BUFFER_SIZE); + cpDataBlock = SPI_repalloc(cpDataBlock, + iDataBlockSize + + BUFFER_SIZE); iDataBlockSize = iDataBlockSize + BUFFER_SIZE; } sprintf(cpDataBlock + iUsedDataBlock, "\"%s\"=", cpFieldName); iUsedDataBlock = iUsedDataBlock + strlen(cpFieldName) + 3; - cpFieldData = SPI_getvalue(tTupleData, tTupleDesc, - iColumnCounter); + cpFieldData = SPI_getvalue(tTupleData, tTupleDesc, + iColumnCounter); cpUnFormatedPtr = cpFieldData; cpFormatedPtr = cpDataBlock + iUsedDataBlock; @@ -531,17 +530,17 @@ packageData(HeapTuple tTupleData, TupleDesc tTupleDesc, Oid tableOid, continue; } - debug_msg2("dbmirror:packageData field data: \"%s\"", - cpFieldData); + debug_msg2("dbmirror:packageData field data: \"%s\"", + cpFieldData); debug_msg("dbmirror:packageData starting format loop"); while (*cpUnFormatedPtr != 0) { while (iDataBlockSize - iUsedDataBlock < 2) { - cpDataBlock = SPI_repalloc(cpDataBlock, - iDataBlockSize - + BUFFER_SIZE); + cpDataBlock = SPI_repalloc(cpDataBlock, + iDataBlockSize + + BUFFER_SIZE); iDataBlockSize = iDataBlockSize + BUFFER_SIZE; cpFormatedPtr = cpDataBlock + iUsedDataBlock; } @@ -561,25 +560,25 @@ packageData(HeapTuple tTupleData, TupleDesc tTupleDesc, Oid tableOid, while (iDataBlockSize - iUsedDataBlock < 3) { - cpDataBlock = SPI_repalloc(cpDataBlock, - iDataBlockSize + - BUFFER_SIZE); + cpDataBlock = SPI_repalloc(cpDataBlock, + iDataBlockSize + + BUFFER_SIZE); iDataBlockSize = iDataBlockSize + BUFFER_SIZE; cpFormatedPtr = cpDataBlock + iUsedDataBlock; } sprintf(cpFormatedPtr, "' "); iUsedDataBlock = iUsedDataBlock + 2; - debug_msg2("dbmirror:packageData data block: \"%s\"", - cpDataBlock); + debug_msg2("dbmirror:packageData data block: \"%s\"", + cpDataBlock); } /* for iColumnCounter */ if (tpPKeys != NULL) SPI_pfree(tpPKeys); - debug_msg3("dbmirror:packageData returning DataBlockSize:%d iUsedDataBlock:%d", - iDataBlockSize, - iUsedDataBlock); + debug_msg3("dbmirror:packageData returning DataBlockSize:%d iUsedDataBlock:%d", + iDataBlockSize, + iUsedDataBlock); memset(cpDataBlock + iUsedDataBlock, 0, iDataBlockSize - iUsedDataBlock); @@ -590,54 +589,55 @@ packageData(HeapTuple tTupleData, TupleDesc tTupleDesc, Oid tableOid, PG_FUNCTION_INFO_V1(setval); -Datum setval(PG_FUNCTION_ARGS) +Datum +setval(PG_FUNCTION_ARGS) { - text * sequenceName; - - Oid setvalArgTypes[2] = {TEXTOID,INT4OID}; - int nextValue; - void * setvalPlan=NULL; - Datum setvalData[2]; - const char * setvalQuery = "SELECT setval_pg($1,$2)"; - int ret; - - sequenceName = PG_GETARG_TEXT_P(0); - nextValue = PG_GETARG_INT32(1); - - setvalData[0] = PointerGetDatum(sequenceName); - setvalData[1] = Int32GetDatum(nextValue); - - if (SPI_connect() < 0) - { - ereport(ERROR,(errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION), - errmsg("dbmirror:setval could not connect to SPI"))); - return -1; - } - - setvalPlan = SPI_prepare(setvalQuery,2,setvalArgTypes); - if(setvalPlan == NULL) - { - ereport(ERROR,(errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION), - errmsg("dbmirror:setval could not prepare plan"))); - return -1; - } - - ret = SPI_execp(setvalPlan,setvalData,NULL,1); - - if(ret != SPI_OK_SELECT || SPI_processed != 1) - return -1; - - debug_msg2("dbmirror:setval: setval_pg returned ok:%d",nextValue); - - ret = saveSequenceUpdate(sequenceName,nextValue); - - SPI_pfree(setvalPlan); - - SPI_finish(); - debug_msg("dbmirror:setval about to return"); - return Int64GetDatum(nextValue); + text *sequenceName; + + Oid setvalArgTypes[2] = {TEXTOID, INT4OID}; + int nextValue; + void *setvalPlan = NULL; + Datum setvalData[2]; + const char *setvalQuery = "SELECT setval_pg($1,$2)"; + int ret; + + sequenceName = PG_GETARG_TEXT_P(0); + nextValue = PG_GETARG_INT32(1); + + setvalData[0] = PointerGetDatum(sequenceName); + setvalData[1] = Int32GetDatum(nextValue); + + if (SPI_connect() < 0) + { + ereport(ERROR, (errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION), + errmsg("dbmirror:setval could not connect to SPI"))); + return -1; + } + + setvalPlan = SPI_prepare(setvalQuery, 2, setvalArgTypes); + if (setvalPlan == NULL) + { + ereport(ERROR, (errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION), + errmsg("dbmirror:setval could not prepare plan"))); + return -1; + } + + ret = SPI_execp(setvalPlan, setvalData, NULL, 1); + + if (ret != SPI_OK_SELECT || SPI_processed != 1) + return -1; + + debug_msg2("dbmirror:setval: setval_pg returned ok:%d", nextValue); + + ret = saveSequenceUpdate(sequenceName, nextValue); + + SPI_pfree(setvalPlan); + + SPI_finish(); + debug_msg("dbmirror:setval about to return"); + return Int64GetDatum(nextValue); } @@ -645,134 +645,131 @@ Datum setval(PG_FUNCTION_ARGS) PG_FUNCTION_INFO_V1(nextval); -Datum +Datum nextval(PG_FUNCTION_ARGS) { - text * sequenceName; - - const char * nextvalQuery = "SELECT nextval_pg($1)"; - Oid nextvalArgTypes[1] = {TEXTOID}; - void * nextvalPlan=NULL; - Datum nextvalData[1]; - - - int ret; - HeapTuple resTuple; - char isNull; - int nextSequenceValue; - + text *sequenceName; + const char *nextvalQuery = "SELECT nextval_pg($1)"; + Oid nextvalArgTypes[1] = {TEXTOID}; + void *nextvalPlan = NULL; + Datum nextvalData[1]; - debug_msg("dbmirror:nextval Starting pending.so:nextval"); + int ret; + HeapTuple resTuple; + char isNull; + int nextSequenceValue; - sequenceName = PG_GETARG_TEXT_P(0); - if (SPI_connect() < 0) - { - ereport(ERROR,(errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION), - errmsg("dbmirror:nextval could not connect to SPI"))); - return -1; - } - - nextvalPlan = SPI_prepare(nextvalQuery,1,nextvalArgTypes); - - debug_msg("prepared plan to call nextval_pg"); + debug_msg("dbmirror:nextval Starting pending.so:nextval"); - if(nextvalPlan==NULL) - { - ereport(ERROR,(errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION), - errmsg("dbmirror:nextval error creating plan"))); - return -1; - } - nextvalData[0] = PointerGetDatum(sequenceName); + sequenceName = PG_GETARG_TEXT_P(0); - ret = SPI_execp(nextvalPlan,nextvalData,NULL,1); + if (SPI_connect() < 0) + { + ereport(ERROR, (errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION), + errmsg("dbmirror:nextval could not connect to SPI"))); + return -1; + } - debug_msg("dbmirror:Executed call to nextval_pg"); + nextvalPlan = SPI_prepare(nextvalQuery, 1, nextvalArgTypes); - if(ret != SPI_OK_SELECT || SPI_processed != 1) - return -1; + debug_msg("prepared plan to call nextval_pg"); - resTuple = SPI_tuptable->vals[0]; - debug_msg("dbmirror:nextval Set resTuple"); + if (nextvalPlan == NULL) + { + ereport(ERROR, (errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION), + errmsg("dbmirror:nextval error creating plan"))); + return -1; + } + nextvalData[0] = PointerGetDatum(sequenceName); - nextSequenceValue =* (unsigned int *)(DatumGetPointer(SPI_getbinval(resTuple, - SPI_tuptable->tupdesc, - 1,&isNull))); + ret = SPI_execp(nextvalPlan, nextvalData, NULL, 1); - + debug_msg("dbmirror:Executed call to nextval_pg"); - debug_msg2("dbmirror:nextval Set SPI_getbinval:%d",nextSequenceValue); - - saveSequenceUpdate(sequenceName,nextSequenceValue); - SPI_pfree(resTuple); - SPI_pfree(nextvalPlan); + if (ret != SPI_OK_SELECT || SPI_processed != 1) + return -1; + + resTuple = SPI_tuptable->vals[0]; + + debug_msg("dbmirror:nextval Set resTuple"); + + nextSequenceValue = *(unsigned int *) (DatumGetPointer(SPI_getbinval(resTuple, + SPI_tuptable->tupdesc, + 1, &isNull))); + + + + debug_msg2("dbmirror:nextval Set SPI_getbinval:%d", nextSequenceValue); - SPI_finish(); - return Int64GetDatum(nextSequenceValue); + saveSequenceUpdate(sequenceName, nextSequenceValue); + SPI_pfree(resTuple); + SPI_pfree(nextvalPlan); + + SPI_finish(); + + return Int64GetDatum(nextSequenceValue); } int -saveSequenceUpdate(const text * sequenceName, - int nextSequenceVal) +saveSequenceUpdate(const text *sequenceName, + int nextSequenceVal) { - Oid insertArgTypes[2] = {TEXTOID,INT4OID}; - Oid insertDataArgTypes[1] = {NAMEOID}; - void * insertPlan=NULL; - void * insertDataPlan=NULL; - Datum insertDatum[2]; - Datum insertDataDatum[1]; - char nextSequenceText[32]; + Oid insertArgTypes[2] = {TEXTOID, INT4OID}; + Oid insertDataArgTypes[1] = {NAMEOID}; + void *insertPlan = NULL; + void *insertDataPlan = NULL; + Datum insertDatum[2]; + Datum insertDataDatum[1]; + char nextSequenceText[32]; + + const char *insertQuery = + "INSERT INTO dbmirror_Pending (TableName,Op,XID) VALUES" \ + "($1,'s',$2)"; + const char *insertDataQuery = + "INSERT INTO dbmirror_PendingData(SeqId,IsKey,Data) VALUES " \ + "(currval('dbmirror_pending_seqid_seq'),'t',$1)"; + + int ret; - const char * insertQuery = - "INSERT INTO dbmirror_Pending (TableName,Op,XID) VALUES" \ - "($1,'s',$2)"; - const char * insertDataQuery = - "INSERT INTO dbmirror_PendingData(SeqId,IsKey,Data) VALUES " \ - "(currval('dbmirror_pending_seqid_seq'),'t',$1)"; - - int ret; + insertPlan = SPI_prepare(insertQuery, 2, insertArgTypes); + insertDataPlan = SPI_prepare(insertDataQuery, 1, insertDataArgTypes); - insertPlan = SPI_prepare(insertQuery,2,insertArgTypes); - insertDataPlan = SPI_prepare(insertDataQuery,1,insertDataArgTypes); + debug_msg("Prepared insert query"); - debug_msg("Prepared insert query"); + if (insertPlan == NULL || insertDataPlan == NULL) + ereport(ERROR, (errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION), errmsg("dbmirror:nextval error creating plan"))); - if(insertPlan == NULL || insertDataPlan == NULL) - { - ereport(ERROR,(errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION),errmsg("dbmirror:nextval error creating plan"))); - } + insertDatum[1] = Int32GetDatum(GetCurrentTransactionId()); + insertDatum[0] = PointerGetDatum(sequenceName); - insertDatum[1] = Int32GetDatum(GetCurrentTransactionId()); - insertDatum[0] = PointerGetDatum(sequenceName); + sprintf(nextSequenceText, "%d", nextSequenceVal); + insertDataDatum[0] = PointerGetDatum(nextSequenceText); + debug_msg2("dbmirror:savesequenceupdate: Setting value %s", + nextSequenceText); - sprintf(nextSequenceText,"%d",nextSequenceVal); - insertDataDatum[0] = PointerGetDatum(nextSequenceText); - debug_msg2("dbmirror:savesequenceupdate: Setting value %s", - nextSequenceText); + debug_msg("dbmirror:About to execute insert query"); - debug_msg("dbmirror:About to execute insert query"); + ret = SPI_execp(insertPlan, insertDatum, NULL, 1); - ret = SPI_execp(insertPlan,insertDatum,NULL,1); - - ret = SPI_execp(insertDataPlan,insertDataDatum,NULL,1); + ret = SPI_execp(insertDataPlan, insertDataDatum, NULL, 1); - debug_msg("dbmirror:Insert query finished"); - SPI_pfree(insertPlan); - SPI_pfree(insertDataPlan); - - return ret; + debug_msg("dbmirror:Insert query finished"); + SPI_pfree(insertPlan); + SPI_pfree(insertDataPlan); -} + return ret; +} diff --git a/contrib/dbsize/dbsize.c b/contrib/dbsize/dbsize.c index b425a3979b..9cf2c0f936 100644 --- a/contrib/dbsize/dbsize.c +++ b/contrib/dbsize/dbsize.c @@ -16,7 +16,7 @@ static int64 -get_tablespace_size(Oid dbid, Oid spcid, bool baddirOK); + get_tablespace_size(Oid dbid, Oid spcid, bool baddirOK); static char * psnprintf(size_t len, const char *fmt,...) @@ -50,10 +50,11 @@ database_size(PG_FUNCTION_ARGS) Oid dbid; int64 totalsize; + #ifdef SYMLINK - Relation dbrel; - HeapScanDesc scan; - HeapTuple tuple; + Relation dbrel; + HeapScanDesc scan; + HeapTuple tuple; #endif dbid = get_database_oid(NameStr(*dbname)); @@ -62,17 +63,18 @@ database_size(PG_FUNCTION_ARGS) (errcode(ERRCODE_UNDEFINED_DATABASE), errmsg("database \"%s\" does not exist", NameStr(*dbname)))); -#ifdef SYMLINK +#ifdef SYMLINK - dbrel = heap_openr(TableSpaceRelationName, AccessShareLock); + dbrel = heap_openr(TableSpaceRelationName, AccessShareLock); scan = heap_beginscan(dbrel, SnapshotNow, 0, (ScanKey) NULL); totalsize = 0; - while((tuple = heap_getnext(scan, ForwardScanDirection))) + while ((tuple = heap_getnext(scan, ForwardScanDirection))) { - Oid spcid = HeapTupleGetOid(tuple); - if(spcid != GLOBALTABLESPACE_OID) + Oid spcid = HeapTupleGetOid(tuple); + + if (spcid != GLOBALTABLESPACE_OID) totalsize += get_tablespace_size(dbid, spcid, true); } heap_endscan(scan); @@ -94,8 +96,8 @@ database_size(PG_FUNCTION_ARGS) static int64 get_tablespace_size(Oid dbid, Oid spcid, bool baddirOK) { - char *dbpath; - DIR *dirdesc; + char *dbpath; + DIR *dirdesc; struct dirent *direntry; int64 totalsize; @@ -104,11 +106,11 @@ get_tablespace_size(Oid dbid, Oid spcid, bool baddirOK) dirdesc = AllocateDir(dbpath); if (!dirdesc) { - if(baddirOK) + if (baddirOK) return 0; else ereport(ERROR, - (errcode_for_file_access(), + (errcode_for_file_access(), errmsg("could not open directory \"%s\": %m", dbpath))); } totalsize = 0; diff --git a/contrib/fuzzystrmatch/dmetaphone.c b/contrib/fuzzystrmatch/dmetaphone.c index d8dc037ca0..e935c8a84a 100644 --- a/contrib/fuzzystrmatch/dmetaphone.c +++ b/contrib/fuzzystrmatch/dmetaphone.c @@ -1,36 +1,36 @@ /* * This is a port of the Double Metaphone algorithm for use in PostgreSQL. - * + * * Double Metaphone computes 2 "sounds like" strings - a primary and an * alternate. In most cases they are the same, but for foreign names * especially they can be a bit different, depending on pronunciation. * * Information on using Double Metaphone can be found at - * http://www.codeproject.com/useritems/dmetaphone1.asp + * http://www.codeproject.com/useritems/dmetaphone1.asp * and the original article describing it can be found at - * http://www.cuj.com/documents/s=8038/cuj0006philips/ + * http://www.cuj.com/documents/s=8038/cuj0006philips/ * * For PostgrSQL we provide 2 functions - one for the primary and one for * the alternate. That way the functions are pure text->text mappings that * are useful in functional indexes. These are 'dmetaphone' for the * primary and 'dmetaphone_alt' for the alternate. * - * Assuming that dmetaphone.so is in $libdir, the SQL to set up the + * Assuming that dmetaphone.so is in $libdir, the SQL to set up the * functions looks like this: * - * CREATE FUNCTION dmetaphone (text) RETURNS text - * LANGUAGE C IMMUTABLE STRICT - * AS '$libdir/dmetaphone', 'dmetaphone'; + * CREATE FUNCTION dmetaphone (text) RETURNS text + * LANGUAGE C IMMUTABLE STRICT + * AS '$libdir/dmetaphone', 'dmetaphone'; * - * CREATE FUNCTION dmetaphone_alt (text) RETURNS text - * LANGUAGE C IMMUTABLE STRICT - * AS '$libdir/dmetaphone', 'dmetaphone_alt'; + * CREATE FUNCTION dmetaphone_alt (text) RETURNS text + * LANGUAGE C IMMUTABLE STRICT + * AS '$libdir/dmetaphone', 'dmetaphone_alt'; * * Note that you have to declare the functions IMMUTABLE if you want to * use them in functional indexes, and you have to declare them as STRICT - * as they do not check for NULL input, and will segfault if given NULL input. - * (See below for alternative ) Declaring them as STRICT means PostgreSQL - * will never call them with NULL, but instead assume the result is NULL, + * as they do not check for NULL input, and will segfault if given NULL input. + * (See below for alternative ) Declaring them as STRICT means PostgreSQL + * will never call them with NULL, but instead assume the result is NULL, * which is what we (I) want. * * Alternatively, compile with -DDMETAPHONE_NOSTRICT and the functions @@ -42,13 +42,13 @@ * need. That's the way the perl module was written, because perl can handle * a list return more easily than we can in PostgreSQL. The result has been * fast enough for my needs, but it could maybe be optimized a bit to remove - * that behaviour. + * that behaviour. * */ /* - * $Revision: 1.2 $ + * $Revision: 1.3 $ * $Id$ */ @@ -56,11 +56,11 @@ /***************************** COPYRIGHT NOTICES *********************** Most of this code is directly from the Text::DoubleMetaphone perl module -version 0.05 available from http://www.cpan.org. +version 0.05 available from http://www.cpan.org. It bears this copyright notice: - Copyright 2000, Maurice Aubrey <[email protected]>. + Copyright 2000, Maurice Aubrey <[email protected]>. All rights reserved. This code is based heavily on the C++ implementation by @@ -73,7 +73,7 @@ It bears this copyright notice: The remaining code is authored by Andrew Dunstan <[email protected]> and <[email protected]> and is covered this copyright: - Copyright 2003, North Carolina State Highway Patrol. + Copyright 2003, North Carolina State Highway Patrol. All rights reserved. Permission to use, copy, modify, and distribute this software and its @@ -81,14 +81,14 @@ The remaining code is authored by Andrew Dunstan <[email protected]> and is hereby granted, provided that the above copyright notice and this paragraph and the following two paragraphs appear in all copies. - IN NO EVENT SHALL THE NORTH CAROLINA STATE HIGHWAY PATROL BE LIABLE TO ANY - PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, + IN NO EVENT SHALL THE NORTH CAROLINA STATE HIGHWAY PATROL BE LIABLE TO ANY + PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS - DOCUMENTATION, EVEN IF THE NORTH CAROLINA STATE HIGHWAY PATROL HAS BEEN + DOCUMENTATION, EVEN IF THE NORTH CAROLINA STATE HIGHWAY PATROL HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - THE NORTH CAROLINA STATE HIGHWAY PATROL SPECIFICALLY DISCLAIMS ANY - WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + THE NORTH CAROLINA STATE HIGHWAY PATROL SPECIFICALLY DISCLAIMS ANY + WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE NORTH CAROLINA STATE HIGHWAY PATROL HAS NO OBLIGATIONS TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR @@ -109,7 +109,6 @@ The remaining code is authored by Andrew Dunstan <[email protected]> and /* turn off assertions for embedded function */ #define NDEBUG - #endif #include <stdio.h> @@ -124,7 +123,7 @@ extern Datum dmetaphone_alt(PG_FUNCTION_ARGS); /* prototype for the main function we got from the perl module */ static void -DoubleMetaphone(char *, char **); + DoubleMetaphone(char *, char **); #ifndef DMETAPHONE_MAIN @@ -138,37 +137,41 @@ PG_FUNCTION_INFO_V1(dmetaphone); Datum dmetaphone(PG_FUNCTION_ARGS) { - text * arg, * result; - int alen, rsize; - char * aptr, *codes[2], * code, * rptr; + text *arg, + *result; + int alen, + rsize; + char *aptr, + *codes[2], + *code, + *rptr; #ifdef DMETAPHONE_NOSTRICT if (PG_ARGISNULL(0)) PG_RETURNNULL(); #endif arg = PG_GETARG_TEXT_P(0); - alen = VARSIZE(arg)-VARHDRSZ; - - /* - * Postgres' string values might not have trailing nuls. - * The VARSIZE will not include the nul in any case - * so we copy things out and add a trailing nul. - * When we copy back we ignore the nul - * (and we don't make space for it). + alen = VARSIZE(arg) - VARHDRSZ; + + /* + * Postgres' string values might not have trailing nuls. The VARSIZE + * will not include the nul in any case so we copy things out and add + * a trailing nul. When we copy back we ignore the nul (and we don't + * make space for it). */ - aptr = palloc(alen+1); - memcpy(aptr,VARDATA(arg),alen); - aptr[alen]=0; - DoubleMetaphone(aptr,codes); + aptr = palloc(alen + 1); + memcpy(aptr, VARDATA(arg), alen); + aptr[alen] = 0; + DoubleMetaphone(aptr, codes); code = codes[0]; if (!code) code = ""; - rsize = VARHDRSZ + strlen(code) ; + rsize = VARHDRSZ + strlen(code); result = (text *) palloc(rsize); - memset(result,0,rsize); + memset(result, 0, rsize); rptr = VARDATA(result); - memcpy(rptr,code,strlen(code)); + memcpy(rptr, code, strlen(code)); VARATT_SIZEP(result) = rsize; PG_RETURN_TEXT_P(result); } @@ -183,28 +186,33 @@ PG_FUNCTION_INFO_V1(dmetaphone_alt); Datum dmetaphone_alt(PG_FUNCTION_ARGS) { - text * arg, * result; - int alen, rsize; - char * aptr, * codes[2], * code, * rptr; + text *arg, + *result; + int alen, + rsize; + char *aptr, + *codes[2], + *code, + *rptr; #ifdef DMETAPHONE_NOSTRICT if (PG_ARGISNULL(0)) PG_RETURNNULL(); #endif arg = PG_GETARG_TEXT_P(0); - alen = VARSIZE(arg)-VARHDRSZ; - aptr = palloc(alen+1); - memcpy(aptr,VARDATA(arg),alen); - aptr[alen]=0; - DoubleMetaphone(aptr,codes); + alen = VARSIZE(arg) - VARHDRSZ; + aptr = palloc(alen + 1); + memcpy(aptr, VARDATA(arg), alen); + aptr[alen] = 0; + DoubleMetaphone(aptr, codes); code = codes[1]; if (!code) code = ""; - rsize = VARHDRSZ + strlen(code) ; + rsize = VARHDRSZ + strlen(code); result = (text *) palloc(rsize); - memset(result,0,rsize); + memset(result, 0, rsize); rptr = VARDATA(result); - memcpy(rptr,code,strlen(code)); + memcpy(rptr, code, strlen(code)); VARATT_SIZEP(result) = rsize; PG_RETURN_TEXT_P(result); } @@ -215,141 +223,139 @@ dmetaphone_alt(PG_FUNCTION_ARGS) /* all memory handling is done with these macros */ #define META_MALLOC(v,n,t) \ - (v = (t*)palloc(((n)*sizeof(t)))) + (v = (t*)palloc(((n)*sizeof(t)))) #define META_REALLOC(v,n,t) \ - (v = (t*)repalloc((v),((n)*sizeof(t)))) + (v = (t*)repalloc((v),((n)*sizeof(t)))) -/* +/* * Don't do pfree - it seems to cause a segv sometimes - which might have just * been caused by reloading the module in development. * So we rely on context cleanup - Tom Lane says pfree shouldn't be necessary * in a case like this. */ -#define META_FREE(x) /* pfree((x)) */ +#define META_FREE(x) /* pfree((x)) */ -#else /* not defined DMETAPHONE_MAIN */ +#else /* not defined DMETAPHONE_MAIN */ /* use the standard malloc library when not running in PostgreSQL */ #define META_MALLOC(v,n,t) \ - (v = (t*)malloc(((n)*sizeof(t)))) + (v = (t*)malloc(((n)*sizeof(t)))) #define META_REALLOC(v,n,t) \ - (v = (t*)realloc((v),((n)*sizeof(t)))) + (v = (t*)realloc((v),((n)*sizeof(t)))) #define META_FREE(x) free((x)) - -#endif /* defined DMETAPHONE_MAIN */ +#endif /* defined DMETAPHONE_MAIN */ -/* this typedef was orignally in the perl module's .h file */ +/* this typedef was orignally in the perl module's .h file */ typedef struct { - char *str; - int length; - int bufsize; - int free_string_on_destroy; + char *str; + int length; + int bufsize; + int free_string_on_destroy; } -metastring; -/* + metastring; + +/* * remaining perl module funcs unchanged except for declaring them static * and reformatting to PostgreSQL indentation and to fit in 80 cols. * - */ + */ static metastring * NewMetaString(char *init_str) { - metastring *s; - char empty_string[] = ""; + metastring *s; + char empty_string[] = ""; - META_MALLOC(s, 1, metastring); - assert( s != NULL ); + META_MALLOC(s, 1, metastring); + assert(s != NULL); - if (init_str == NULL) + if (init_str == NULL) init_str = empty_string; - s->length = strlen(init_str); - /* preallocate a bit more for potential growth */ - s->bufsize = s->length + 7; + s->length = strlen(init_str); + /* preallocate a bit more for potential growth */ + s->bufsize = s->length + 7; + + META_MALLOC(s->str, s->bufsize, char); + assert(s->str != NULL); - META_MALLOC(s->str, s->bufsize, char); - assert( s->str != NULL ); - - strncpy(s->str, init_str, s->length + 1); - s->free_string_on_destroy = 1; + strncpy(s->str, init_str, s->length + 1); + s->free_string_on_destroy = 1; - return s; + return s; } static void DestroyMetaString(metastring * s) { - if (s == NULL) + if (s == NULL) return; - if (s->free_string_on_destroy && (s->str != NULL)) + if (s->free_string_on_destroy && (s->str != NULL)) META_FREE(s->str); - META_FREE(s); + META_FREE(s); } static void IncreaseBuffer(metastring * s, int chars_needed) { - META_REALLOC(s->str, (s->bufsize + chars_needed + 10), char); - assert( s->str != NULL ); - s->bufsize = s->bufsize + chars_needed + 10; + META_REALLOC(s->str, (s->bufsize + chars_needed + 10), char); + assert(s->str != NULL); + s->bufsize = s->bufsize + chars_needed + 10; } static void MakeUpper(metastring * s) { - char *i; + char *i; - for (i = s->str; *i; i++) - { + for (i = s->str; *i; i++) *i = toupper(*i); - } } static int IsVowel(metastring * s, int pos) { - char c; + char c; - if ((pos < 0) || (pos >= s->length)) + if ((pos < 0) || (pos >= s->length)) return 0; - c = *(s->str + pos); - if ((c == 'A') || (c == 'E') || (c == 'I') || (c =='O') || - (c =='U') || (c == 'Y')) + c = *(s->str + pos); + if ((c == 'A') || (c == 'E') || (c == 'I') || (c == 'O') || + (c == 'U') || (c == 'Y')) return 1; - return 0; + return 0; } static int SlavoGermanic(metastring * s) { - if ((char *) strstr(s->str, "W")) + if ((char *) strstr(s->str, "W")) return 1; - else if ((char *) strstr(s->str, "K")) + else if ((char *) strstr(s->str, "K")) return 1; - else if ((char *) strstr(s->str, "CZ")) + else if ((char *) strstr(s->str, "CZ")) return 1; - else if ((char *) strstr(s->str, "WITZ")) + else if ((char *) strstr(s->str, "WITZ")) return 1; - else + else return 0; } @@ -357,117 +363,115 @@ SlavoGermanic(metastring * s) static char GetAt(metastring * s, int pos) { - if ((pos < 0) || (pos >= s->length)) + if ((pos < 0) || (pos >= s->length)) return '\0'; - return ((char) *(s->str + pos)); + return ((char) *(s->str + pos)); } static void SetAt(metastring * s, int pos, char c) { - if ((pos < 0) || (pos >= s->length)) + if ((pos < 0) || (pos >= s->length)) return; - *(s->str + pos) = c; + *(s->str + pos) = c; } -/* +/* Caveats: the START value is 0 based */ static int -StringAt(metastring * s, int start, int length, ...) +StringAt(metastring * s, int start, int length,...) { - char *test; - char *pos; - va_list ap; + char *test; + char *pos; + va_list ap; - if ((start < 0) || (start >= s->length)) - return 0; + if ((start < 0) || (start >= s->length)) + return 0; - pos = (s->str + start); - va_start(ap, length); + pos = (s->str + start); + va_start(ap, length); - do + do { test = va_arg(ap, char *); if (*test && (strncmp(pos, test, length) == 0)) return 1; } - while (strcmp(test, "")); + while (strcmp(test, "")); - va_end(ap); + va_end(ap); - return 0; + return 0; } static void MetaphAdd(metastring * s, char *new_str) { - int add_length; + int add_length; - if (new_str == NULL) + if (new_str == NULL) return; - add_length = strlen(new_str); - if ((s->length + add_length) > (s->bufsize - 1)) - { + add_length = strlen(new_str); + if ((s->length + add_length) > (s->bufsize - 1)) IncreaseBuffer(s, add_length); - } - strcat(s->str, new_str); - s->length += add_length; + strcat(s->str, new_str); + s->length += add_length; } static void DoubleMetaphone(char *str, char **codes) { - int length; - metastring *original; - metastring *primary; - metastring *secondary; - int current; - int last; - - current = 0; - /* we need the real length and last prior to padding */ - length = strlen(str); - last = length - 1; - original = NewMetaString(str); - /* Pad original so we can index beyond end */ - MetaphAdd(original, " "); - - primary = NewMetaString(""); - secondary = NewMetaString(""); - primary->free_string_on_destroy = 0; - secondary->free_string_on_destroy = 0; - - MakeUpper(original); - - /* skip these when at start of word */ - if (StringAt(original, 0, 2, "GN", "KN", "PN", "WR", "PS", "")) + int length; + metastring *original; + metastring *primary; + metastring *secondary; + int current; + int last; + + current = 0; + /* we need the real length and last prior to padding */ + length = strlen(str); + last = length - 1; + original = NewMetaString(str); + /* Pad original so we can index beyond end */ + MetaphAdd(original, " "); + + primary = NewMetaString(""); + secondary = NewMetaString(""); + primary->free_string_on_destroy = 0; + secondary->free_string_on_destroy = 0; + + MakeUpper(original); + + /* skip these when at start of word */ + if (StringAt(original, 0, 2, "GN", "KN", "PN", "WR", "PS", "")) current += 1; - /* Initial 'X' is pronounced 'Z' e.g. 'Xavier' */ - if (GetAt(original, 0) == 'X') + /* Initial 'X' is pronounced 'Z' e.g. 'Xavier' */ + if (GetAt(original, 0) == 'X') { MetaphAdd(primary, "S"); /* 'Z' maps to 'S' */ MetaphAdd(secondary, "S"); current += 1; } - /* main loop */ - while ((primary->length < 4) || (secondary->length < 4)) + /* main loop */ + while ((primary->length < 4) || (secondary->length < 4)) { if (current >= length) break; switch (GetAt(original, current)) - { + { case 'A': case 'E': case 'I': @@ -508,8 +512,8 @@ DoubleMetaphone(char *str, char **codes) && StringAt(original, (current - 1), 3, "ACH", "") && ((GetAt(original, current + 2) != 'I') && ((GetAt(original, current + 2) != 'E') - || StringAt(original, (current - 2), 6, "BACHER", - "MACHER", "")))) + || StringAt(original, (current - 2), 6, "BACHER", + "MACHER", "")))) { MetaphAdd(primary, "K"); MetaphAdd(secondary, "K"); @@ -550,7 +554,7 @@ DoubleMetaphone(char *str, char **codes) /* greek roots e.g. 'chemistry', 'chorus' */ if ((current == 0) - && (StringAt(original, (current + 1), 5, + && (StringAt(original, (current + 1), 5, "HARAC", "HARIS", "") || StringAt(original, (current + 1), 3, "HOR", "HYM", "HIA", "HEM", "")) @@ -566,19 +570,21 @@ DoubleMetaphone(char *str, char **codes) if ( (StringAt(original, 0, 4, "VAN ", "VON ", "") || StringAt(original, 0, 3, "SCH", "")) - /* 'architect but not 'arch', 'orchestra', 'orchid' */ + /* 'architect but not 'arch', 'orchestra', 'orchid' */ || StringAt(original, (current - 2), 6, "ORCHES", "ARCHIT", "ORCHID", "") || StringAt(original, (current + 2), 1, "T", "S", "") - || ((StringAt(original, (current - 1), 1, - "A", "O", "U", "E", "") + || ((StringAt(original, (current - 1), 1, + "A", "O", "U", "E", "") || (current == 0)) - /* e.g., 'wachtler', 'wechsler', - but not 'tichner' */ - && StringAt(original, (current + 2), 1, "L", "R", - "N", "M", "B", "H", "F", "V", "W", - " ", ""))) + + /* + * e.g., 'wachtler', 'wechsler', but not 'tichner' + */ + && StringAt(original, (current + 2), 1, "L", "R", + "N", "M", "B", "H", "F", "V", "W", + " ", ""))) { MetaphAdd(primary, "K"); MetaphAdd(secondary, "K"); @@ -633,14 +639,14 @@ DoubleMetaphone(char *str, char **codes) { /* 'bellocchio' but not 'bacchus' */ if (StringAt(original, (current + 2), 1, "I", "E", "H", "") - && !StringAt(original, (current + 2), 2, "HU", "")) + && !StringAt(original, (current + 2), 2, "HU", "")) { /* 'accident', 'accede' 'succeed' */ if ( ((current == 1) && (GetAt(original, current - 1) == 'A')) - || StringAt(original, (current - 1), 5, "UCCEE", - "UCCES", "")) + || StringAt(original, (current - 1), 5, "UCCEE", + "UCCES", "")) { MetaphAdd(primary, "KS"); MetaphAdd(secondary, "KS"); @@ -655,7 +661,7 @@ DoubleMetaphone(char *str, char **codes) break; } else - { /* Pierce's rule */ + { /* Pierce's rule */ MetaphAdd(primary, "K"); MetaphAdd(secondary, "K"); current += 2; @@ -696,19 +702,18 @@ DoubleMetaphone(char *str, char **codes) /* name sent in 'mac caffrey', 'mac gregor */ if (StringAt(original, (current + 1), 2, " C", " Q", " G", "")) current += 3; + else if (StringAt(original, (current + 1), 1, "C", "K", "Q", "") + && !StringAt(original, (current + 1), 2, + "CE", "CI", "")) + current += 2; else - if (StringAt(original, (current + 1), 1, "C", "K", "Q", "") - && !StringAt(original, (current + 1), 2, - "CE", "CI", "")) - current += 2; - else - current += 1; + current += 1; break; case 'D': if (StringAt(original, current, 2, "DG", "")) { - if (StringAt(original, (current + 2), 1, + if (StringAt(original, (current + 2), 1, "I", "E", "Y", "")) { /* e.g. 'edge' */ @@ -780,19 +785,22 @@ DoubleMetaphone(char *str, char **codes) break; } } - /* Parker's rule (with some further refinements) - - e.g., 'hugh' */ + + /* + * Parker's rule (with some further refinements) - + * e.g., 'hugh' + */ if ( ((current > 1) - && StringAt(original, (current - 2), 1, + && StringAt(original, (current - 2), 1, "B", "H", "D", "")) - /* e.g., 'bough' */ + /* e.g., 'bough' */ || ((current > 2) - && StringAt(original, (current - 3), 1, + && StringAt(original, (current - 3), 1, "B", "H", "D", "")) - /* e.g., 'broughton' */ + /* e.g., 'broughton' */ || ((current > 3) - && StringAt(original, (current - 4), 1, + && StringAt(original, (current - 4), 1, "B", "H", ""))) { current += 2; @@ -800,8 +808,10 @@ DoubleMetaphone(char *str, char **codes) } else { - /* e.g., 'laugh', 'McLaughlin', 'cough', - 'gough', 'rough', 'tough' */ + /* + * e.g., 'laugh', 'McLaughlin', 'cough', 'gough', + * 'rough', 'tough' + */ if ((current > 2) && (GetAt(original, current - 1) == 'U') && StringAt(original, (current - 3), 1, "C", @@ -837,15 +847,15 @@ DoubleMetaphone(char *str, char **codes) if (!StringAt(original, (current + 2), 2, "EY", "") && (GetAt(original, current + 1) != 'Y') && !SlavoGermanic(original)) - { - MetaphAdd(primary, "N"); - MetaphAdd(secondary, "KN"); - } - else - { - MetaphAdd(primary, "KN"); - MetaphAdd(secondary, "KN"); - } + { + MetaphAdd(primary, "N"); + MetaphAdd(secondary, "KN"); + } + else + { + MetaphAdd(primary, "KN"); + MetaphAdd(secondary, "KN"); + } current += 2; break; } @@ -863,9 +873,9 @@ DoubleMetaphone(char *str, char **codes) /* -ges-,-gep-,-gel-, -gie- at beginning */ if ((current == 0) && ((GetAt(original, current + 1) == 'Y') - || StringAt(original, (current + 1), 2, "ES", "EP", - "EB", "EL", "EY", "IB", "IL", "IN", "IE", - "EI", "ER", ""))) + || StringAt(original, (current + 1), 2, "ES", "EP", + "EB", "EL", "EY", "IB", "IL", "IN", "IE", + "EI", "ER", ""))) { MetaphAdd(primary, "K"); MetaphAdd(secondary, "J"); @@ -873,11 +883,11 @@ DoubleMetaphone(char *str, char **codes) break; } - /* -ger-, -gy- */ + /* -ger-, -gy- */ if ( (StringAt(original, (current + 1), 2, "ER", "") || (GetAt(original, current + 1) == 'Y')) - && !StringAt(original, 0, 6, + && !StringAt(original, 0, 6, "DANGER", "RANGER", "MANGER", "") && !StringAt(original, (current - 1), 1, "E", "I", "") && !StringAt(original, (current - 1), 3, "RGY", "OGY", @@ -889,9 +899,9 @@ DoubleMetaphone(char *str, char **codes) break; } - /* italian e.g, 'biaggi' */ + /* italian e.g, 'biaggi' */ if (StringAt(original, (current + 1), 1, "E", "I", "Y", "") - || StringAt(original, (current - 1), 4, + || StringAt(original, (current - 1), 4, "AGGI", "OGGI", "")) { /* obvious germanic */ @@ -939,7 +949,8 @@ DoubleMetaphone(char *str, char **codes) MetaphAdd(secondary, "H"); current += 2; } - else /* also takes care of 'HH' */ + else +/* also takes care of 'HH' */ current += 1; break; @@ -991,9 +1002,9 @@ DoubleMetaphone(char *str, char **codes) else { if (!StringAt(original, (current + 1), 1, "L", "T", - "K", "S", "N", "M", "B", "Z", "") + "K", "S", "N", "M", "B", "Z", "") && !StringAt(original, (current - 1), 1, - "S", "K", "L", "")) + "S", "K", "L", "")) { MetaphAdd(primary, "J"); MetaphAdd(secondary, "J"); @@ -1002,7 +1013,7 @@ DoubleMetaphone(char *str, char **codes) } } - if (GetAt(original, current + 1) == 'J') /* it could happen! */ + if (GetAt(original, current + 1) == 'J') /* it could happen! */ current += 2; else current += 1; @@ -1024,10 +1035,10 @@ DoubleMetaphone(char *str, char **codes) if (((current == (length - 3)) && StringAt(original, (current - 1), 4, "ILLO", "ILLA", "ALLE", "")) - || ((StringAt(original, (last - 1), 2, "AS", "OS", "") - || StringAt(original, last, 1, "A", "O", "")) - && StringAt(original, (current - 1), 4, - "ALLE", ""))) + || ((StringAt(original, (last - 1), 2, "AS", "OS", "") + || StringAt(original, last, 1, "A", "O", "")) + && StringAt(original, (current - 1), 4, + "ALLE", ""))) { MetaphAdd(primary, "L"); MetaphAdd(secondary, ""); @@ -1045,8 +1056,8 @@ DoubleMetaphone(char *str, char **codes) case 'M': if ((StringAt(original, (current - 1), 3, "UMB", "") && (((current + 1) == last) - || StringAt(original, (current + 2), 2, "ER", ""))) - /* 'dumb','thumb' */ + || StringAt(original, (current + 2), 2, "ER", ""))) + /* 'dumb','thumb' */ || (GetAt(original, current + 1) == 'M')) current += 2; else @@ -1102,7 +1113,7 @@ DoubleMetaphone(char *str, char **codes) if ((current == last) && !SlavoGermanic(original) && StringAt(original, (current - 2), 2, "IE", "") - && !StringAt(original, (current - 4), 2, "ME", "MA", "")) + && !StringAt(original, (current - 4), 2, "ME", "MA", "")) { MetaphAdd(primary, ""); MetaphAdd(secondary, "R"); @@ -1141,8 +1152,8 @@ DoubleMetaphone(char *str, char **codes) { /* germanic */ if (StringAt - (original, (current + 1), 4, "HEIM", "HOEK", "HOLM", - "HOLZ", "")) + (original, (current + 1), 4, "HEIM", "HOEK", "HOLM", + "HOLZ", "")) { MetaphAdd(primary, "S"); MetaphAdd(secondary, "S"); @@ -1174,12 +1185,13 @@ DoubleMetaphone(char *str, char **codes) break; } - /* german & anglicisations, e.g. 'smith' match 'schmidt', - 'snider' match 'schneider' - also, -sz- in slavic language altho in hungarian it is - pronounced 's' */ + /* + * german & anglicisations, e.g. 'smith' match 'schmidt', + * 'snider' match 'schneider' also, -sz- in slavic + * language altho in hungarian it is pronounced 's' + */ if (((current == 0) - && StringAt(original, (current + 1), 1, + && StringAt(original, (current + 1), 1, "M", "N", "L", "W", "")) || StringAt(original, (current + 1), 1, "Z", "")) { @@ -1198,12 +1210,12 @@ DoubleMetaphone(char *str, char **codes) if (GetAt(original, current + 2) == 'H') { /* dutch origin, e.g. 'school', 'schooner' */ - if (StringAt(original, (current + 3), 2, + if (StringAt(original, (current + 3), 2, "OO", "ER", "EN", "UY", "ED", "EM", "")) { /* 'schermerhorn', 'schenker' */ - if (StringAt(original, (current + 3), 2, + if (StringAt(original, (current + 3), 2, "ER", "EN", "")) { MetaphAdd(primary, "X"); @@ -1235,7 +1247,7 @@ DoubleMetaphone(char *str, char **codes) } } - if (StringAt(original, (current + 2), 1, + if (StringAt(original, (current + 2), 1, "I", "E", "Y", "")) { MetaphAdd(primary, "S"); @@ -1252,7 +1264,7 @@ DoubleMetaphone(char *str, char **codes) /* french e.g. 'resnais', 'artois' */ if ((current == last) - && StringAt(original, (current - 2), 2, "AI", "OI", "")) + && StringAt(original, (current - 2), 2, "AI", "OI", "")) { MetaphAdd(primary, ""); MetaphAdd(secondary, "S"); @@ -1353,8 +1365,8 @@ DoubleMetaphone(char *str, char **codes) /* Arnow should match Arnoff */ if (((current == last) && IsVowel(original, current - 1)) - || StringAt(original, (current - 1), 5, "EWSKI", "EWSKY", - "OWSKI", "OWSKY", "") + || StringAt(original, (current - 1), 5, "EWSKI", "EWSKY", + "OWSKI", "OWSKY", "") || StringAt(original, 0, 3, "SCH", "")) { MetaphAdd(primary, ""); @@ -1379,15 +1391,15 @@ DoubleMetaphone(char *str, char **codes) case 'X': /* french e.g. breaux */ if (!((current == last) - && (StringAt(original, (current - 3), 3, + && (StringAt(original, (current - 3), 3, "IAU", "EAU", "") - || StringAt(original, (current - 2), 2, + || StringAt(original, (current - 2), 2, "AU", "OU", "")))) { MetaphAdd(primary, "KS"); MetaphAdd(secondary, "KS"); } - + if (StringAt(original, (current + 1), 1, "C", "X", "")) current += 2; @@ -1404,7 +1416,7 @@ DoubleMetaphone(char *str, char **codes) current += 2; break; } - else if (StringAt(original, (current + 1), 2, + else if (StringAt(original, (current + 1), 2, "ZO", "ZI", "ZA", "") || (SlavoGermanic(original) && ((current > 0) @@ -1427,38 +1439,42 @@ DoubleMetaphone(char *str, char **codes) default: current += 1; - } - /* printf("PRIMARY: %s\n", primary->str); - printf("SECONDARY: %s\n", secondary->str); */ + } + + /* + * printf("PRIMARY: %s\n", primary->str); printf("SECONDARY: + * %s\n", secondary->str); + */ } - if (primary->length > 4) + if (primary->length > 4) SetAt(primary, 4, '\0'); - if (secondary->length > 4) + if (secondary->length > 4) SetAt(secondary, 4, '\0'); - *codes = primary->str; - *++codes = secondary->str; + *codes = primary->str; + *++codes = secondary->str; - DestroyMetaString(original); - DestroyMetaString(primary); - DestroyMetaString(secondary); + DestroyMetaString(original); + DestroyMetaString(primary); + DestroyMetaString(secondary); } #ifdef DMETAPHONE_MAIN /* just for testing - not part of the perl code */ -main(int argc, char ** argv) +main(int argc, char **argv) { - char * codes[2]; + char *codes[2]; + if (argc > 1) { - DoubleMetaphone(argv[1],codes); - printf("%s|%s\n",codes[0],codes[1]); - } + DoubleMetaphone(argv[1], codes); + printf("%s|%s\n", codes[0], codes[1]); + } } #endif diff --git a/contrib/intarray/_int_gist.c b/contrib/intarray/_int_gist.c index ebf4ba3166..e4b923523b 100644 --- a/contrib/intarray/_int_gist.c +++ b/contrib/intarray/_int_gist.c @@ -87,7 +87,7 @@ g_int_consistent(PG_FUNCTION_ARGS) Datum g_int_union(PG_FUNCTION_ARGS) { - GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); int *size = (int *) PG_GETARG_POINTER(1); int4 i; ArrayType *res; @@ -317,7 +317,7 @@ comparecost(const void *a, const void *b) Datum g_int_picksplit(PG_FUNCTION_ARGS) { - GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1); OffsetNumber i, j; @@ -359,10 +359,10 @@ g_int_picksplit(PG_FUNCTION_ARGS) waste = 0.0; for (i = FirstOffsetNumber; i < maxoff; i = OffsetNumberNext(i)) { - datum_alpha = GETENTRY(entryvec,i); + datum_alpha = GETENTRY(entryvec, i); for (j = OffsetNumberNext(i); j <= maxoff; j = OffsetNumberNext(j)) { - datum_beta = GETENTRY(entryvec,j); + datum_beta = GETENTRY(entryvec, j); /* compute the wasted space by unioning these guys */ /* size_waste = size_union - size_inter; */ @@ -402,10 +402,10 @@ g_int_picksplit(PG_FUNCTION_ARGS) seed_2 = 2; } - datum_alpha = GETENTRY(entryvec,seed_1); + datum_alpha = GETENTRY(entryvec, seed_1); datum_l = copy_intArrayType(datum_alpha); rt__int_size(datum_l, &size_l); - datum_beta = GETENTRY(entryvec,seed_2); + datum_beta = GETENTRY(entryvec, seed_2); datum_r = copy_intArrayType(datum_beta); rt__int_size(datum_r, &size_r); @@ -418,7 +418,7 @@ g_int_picksplit(PG_FUNCTION_ARGS) for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) { costvector[i - 1].pos = i; - datum_alpha = GETENTRY(entryvec,i); + datum_alpha = GETENTRY(entryvec, i); union_d = inner_int_union(datum_l, datum_alpha); rt__int_size(union_d, &size_alpha); pfree(union_d); @@ -466,7 +466,7 @@ g_int_picksplit(PG_FUNCTION_ARGS) } /* okay, which page needs least enlargement? */ - datum_alpha = GETENTRY(entryvec,i); + datum_alpha = GETENTRY(entryvec, i); union_dl = inner_int_union(datum_l, datum_alpha); union_dr = inner_int_union(datum_r, datum_alpha); rt__int_size(union_dl, &size_alpha); diff --git a/contrib/intarray/_intbig_gist.c b/contrib/intarray/_intbig_gist.c index 04d26d90f9..efd70758dc 100644 --- a/contrib/intarray/_intbig_gist.c +++ b/contrib/intarray/_intbig_gist.c @@ -20,52 +20,55 @@ Datum g_intbig_picksplit(PG_FUNCTION_ARGS); Datum g_intbig_union(PG_FUNCTION_ARGS); Datum g_intbig_same(PG_FUNCTION_ARGS); -#define SUMBIT(val) ( \ - GETBITBYTE((val),0) + \ - GETBITBYTE((val),1) + \ - GETBITBYTE((val),2) + \ - GETBITBYTE((val),3) + \ - GETBITBYTE((val),4) + \ - GETBITBYTE((val),5) + \ - GETBITBYTE((val),6) + \ - GETBITBYTE((val),7) \ +#define SUMBIT(val) ( \ + GETBITBYTE((val),0) + \ + GETBITBYTE((val),1) + \ + GETBITBYTE((val),2) + \ + GETBITBYTE((val),3) + \ + GETBITBYTE((val),4) + \ + GETBITBYTE((val),5) + \ + GETBITBYTE((val),6) + \ + GETBITBYTE((val),7) \ ) PG_FUNCTION_INFO_V1(_intbig_in); -Datum _intbig_in(PG_FUNCTION_ARGS); - +Datum _intbig_in(PG_FUNCTION_ARGS); + PG_FUNCTION_INFO_V1(_intbig_out); -Datum _intbig_out(PG_FUNCTION_ARGS); - - +Datum _intbig_out(PG_FUNCTION_ARGS); + + Datum -_intbig_in(PG_FUNCTION_ARGS) { - ereport(ERROR, - (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), - errmsg("_intbig_in() not implemented"))); - PG_RETURN_DATUM(0); +_intbig_in(PG_FUNCTION_ARGS) +{ + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + errmsg("_intbig_in() not implemented"))); + PG_RETURN_DATUM(0); } - + Datum -_intbig_out(PG_FUNCTION_ARGS) { - ereport(ERROR, - (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), - errmsg("_intbig_out() not implemented"))); - PG_RETURN_DATUM(0); -} +_intbig_out(PG_FUNCTION_ARGS) +{ + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + errmsg("_intbig_out() not implemented"))); + PG_RETURN_DATUM(0); +} /********************************************************************* ** intbig functions *********************************************************************/ static bool -_intbig_overlap(GISTTYPE *a, ArrayType *b) +_intbig_overlap(GISTTYPE * a, ArrayType *b) { - int num=ARRNELEMS(b); - int4 *ptr=ARRPTR(b); + int num = ARRNELEMS(b); + int4 *ptr = ARRPTR(b); - while(num--) { - if (GETBIT(GETSIGN(a),HASHVAL(*ptr))) + while (num--) + { + if (GETBIT(GETSIGN(a), HASHVAL(*ptr))) return true; ptr++; } @@ -74,13 +77,14 @@ _intbig_overlap(GISTTYPE *a, ArrayType *b) } static bool -_intbig_contains(GISTTYPE *a, ArrayType *b) +_intbig_contains(GISTTYPE * a, ArrayType *b) { - int num=ARRNELEMS(b); - int4 *ptr=ARRPTR(b); + int num = ARRNELEMS(b); + int4 *ptr = ARRPTR(b); - while(num--) { - if (!GETBIT(GETSIGN(a),HASHVAL(*ptr))) + while (num--) + { + if (!GETBIT(GETSIGN(a), HASHVAL(*ptr))) return false; ptr++; } @@ -89,10 +93,11 @@ _intbig_contains(GISTTYPE *a, ArrayType *b) } Datum -g_intbig_same(PG_FUNCTION_ARGS) { +g_intbig_same(PG_FUNCTION_ARGS) +{ GISTTYPE *a = (GISTTYPE *) PG_GETARG_POINTER(0); GISTTYPE *b = (GISTTYPE *) PG_GETARG_POINTER(1); - bool *result = (bool *) PG_GETARG_POINTER(2); + bool *result = (bool *) PG_GETARG_POINTER(2); if (ISALLTRUE(a) && ISALLTRUE(b)) *result = true; @@ -100,16 +105,19 @@ g_intbig_same(PG_FUNCTION_ARGS) { *result = false; else if (ISALLTRUE(b)) *result = false; - else { - int4 i; - BITVECP sa = GETSIGN(a), - sb = GETSIGN(b); + else + { + int4 i; + BITVECP sa = GETSIGN(a), + sb = GETSIGN(b); + *result = true; LOOPBYTE( - if (sa[i] != sb[i]) { - *result = false; - break; - } + if (sa[i] != sb[i]) + { + *result = false; + break; + } ); } PG_RETURN_POINTER(result); @@ -120,93 +128,105 @@ g_intbig_compress(PG_FUNCTION_ARGS) { GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - if (entry->leafkey) { + if (entry->leafkey) + { GISTENTRY *retval; - ArrayType *in = (ArrayType *) PG_DETOAST_DATUM(entry->key); - int4 *ptr; - int num; - GISTTYPE *res=(GISTTYPE*)palloc(CALCGTSIZE(0)); + ArrayType *in = (ArrayType *) PG_DETOAST_DATUM(entry->key); + int4 *ptr; + int num; + GISTTYPE *res = (GISTTYPE *) palloc(CALCGTSIZE(0)); ARRISVOID(in); - ptr=ARRPTR(in); - num=ARRNELEMS(in); - memset(res,0,CALCGTSIZE(0)); - res->len=CALCGTSIZE(0); + ptr = ARRPTR(in); + num = ARRNELEMS(in); + memset(res, 0, CALCGTSIZE(0)); + res->len = CALCGTSIZE(0); - while(num--) { - HASH(GETSIGN(res),*ptr); + while (num--) + { + HASH(GETSIGN(res), *ptr); ptr++; } retval = (GISTENTRY *) palloc(sizeof(GISTENTRY)); gistentryinit(*retval, PointerGetDatum(res), - entry->rel, entry->page, - entry->offset, res->len, FALSE); - - if ( in!=(ArrayType *) PG_DETOAST_DATUM(entry->key) ) + entry->rel, entry->page, + entry->offset, res->len, FALSE); + + if (in != (ArrayType *) PG_DETOAST_DATUM(entry->key)) pfree(in); PG_RETURN_POINTER(retval); - } else if ( !ISALLTRUE(DatumGetPointer(entry->key)) ) { + } + else if (!ISALLTRUE(DatumGetPointer(entry->key))) + { GISTENTRY *retval; - int i; - BITVECP sign = GETSIGN(DatumGetPointer(entry->key)); + int i; + BITVECP sign = GETSIGN(DatumGetPointer(entry->key)); GISTTYPE *res; LOOPBYTE( - if ((sign[i] & 0xff) != 0xff) - PG_RETURN_POINTER(entry); + if ((sign[i] & 0xff) != 0xff) + PG_RETURN_POINTER(entry); ); - res=(GISTTYPE*)palloc(CALCGTSIZE(ALLISTRUE)); - res->len=CALCGTSIZE(ALLISTRUE); + res = (GISTTYPE *) palloc(CALCGTSIZE(ALLISTRUE)); + res->len = CALCGTSIZE(ALLISTRUE); res->flag = ALLISTRUE; retval = (GISTENTRY *) palloc(sizeof(GISTENTRY)); gistentryinit(*retval, PointerGetDatum(res), - entry->rel, entry->page, - entry->offset, res->len, FALSE); - + entry->rel, entry->page, + entry->offset, res->len, FALSE); + PG_RETURN_POINTER(retval); } - + PG_RETURN_POINTER(entry); } static int4 -sizebitvec(BITVECP sign) { - int4 size = 0, i; +sizebitvec(BITVECP sign) +{ + int4 size = 0, + i; + LOOPBYTE( - size += SUMBIT(sign); - sign = (BITVECP) (((char *) sign) + 1); + size += SUMBIT(sign); + sign = (BITVECP) (((char *) sign) + 1); ); - return size; + return size; } static int -hemdistsign(BITVECP a, BITVECP b) { - int i,dist=0; - - LOOPBIT( - if ( GETBIT(a,i) != GETBIT(b,i) ) - dist++; - ); - return dist; +hemdistsign(BITVECP a, BITVECP b) +{ + int i, + dist = 0; + + LOOPBIT( + if (GETBIT(a, i) != GETBIT(b, i)) + dist++; + ); + return dist; } static int -hemdist(GISTTYPE *a, GISTTYPE *b) { - if ( ISALLTRUE(a) ) { - if (ISALLTRUE(b)) - return 0; - else - return SIGLENBIT-sizebitvec(GETSIGN(b)); - } else if (ISALLTRUE(b)) - return SIGLENBIT-sizebitvec(GETSIGN(a)); - - return hemdistsign( GETSIGN(a), GETSIGN(b) ); +hemdist(GISTTYPE * a, GISTTYPE * b) +{ + if (ISALLTRUE(a)) + { + if (ISALLTRUE(b)) + return 0; + else + return SIGLENBIT - sizebitvec(GETSIGN(b)); + } + else if (ISALLTRUE(b)) + return SIGLENBIT - sizebitvec(GETSIGN(a)); + + return hemdistsign(GETSIGN(a), GETSIGN(b)); } Datum @@ -218,29 +238,33 @@ g_intbig_decompress(PG_FUNCTION_ARGS) static int4 unionkey(BITVECP sbase, GISTTYPE * add) { - int4 i; - BITVECP sadd = GETSIGN(add); + int4 i; + BITVECP sadd = GETSIGN(add); if (ISALLTRUE(add)) return 1; LOOPBYTE( - sbase[i] |= sadd[i]; + sbase[i] |= sadd[i]; ); return 0; } Datum -g_intbig_union(PG_FUNCTION_ARGS) { - GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); - int *size = (int *) PG_GETARG_POINTER(1); - BITVEC base; - int4 i, len; - int4 flag = 0; +g_intbig_union(PG_FUNCTION_ARGS) +{ + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + int *size = (int *) PG_GETARG_POINTER(1); + BITVEC base; + int4 i, + len; + int4 flag = 0; GISTTYPE *result; MemSet((void *) base, 0, sizeof(BITVEC)); - for (i = 0; i < entryvec->n; i++) { - if (unionkey(base, GETENTRY(entryvec, i))) { + for (i = 0; i < entryvec->n; i++) + { + if (unionkey(base, GETENTRY(entryvec, i))) + { flag = ALLISTRUE; break; } @@ -252,187 +276,201 @@ g_intbig_union(PG_FUNCTION_ARGS) { result->flag = flag; if (!ISALLTRUE(result)) memcpy((void *) GETSIGN(result), (void *) base, sizeof(BITVEC)); - + PG_RETURN_POINTER(result); } Datum -g_intbig_penalty(PG_FUNCTION_ARGS) { +g_intbig_penalty(PG_FUNCTION_ARGS) +{ GISTENTRY *origentry = (GISTENTRY *) PG_GETARG_POINTER(0); /* always ISSIGNKEY */ GISTENTRY *newentry = (GISTENTRY *) PG_GETARG_POINTER(1); - float *penalty = (float *) PG_GETARG_POINTER(2); + float *penalty = (float *) PG_GETARG_POINTER(2); GISTTYPE *origval = (GISTTYPE *) DatumGetPointer(origentry->key); GISTTYPE *newval = (GISTTYPE *) DatumGetPointer(newentry->key); - *penalty=hemdist(origval,newval); + *penalty = hemdist(origval, newval); PG_RETURN_POINTER(penalty); } -typedef struct { +typedef struct +{ OffsetNumber pos; - int4 cost; + int4 cost; } SPLITCOST; static int -comparecost(const void *a, const void *b) { +comparecost(const void *a, const void *b) +{ return ((SPLITCOST *) a)->cost - ((SPLITCOST *) b)->cost; } Datum -g_intbig_picksplit(PG_FUNCTION_ARGS) { - GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); - GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1); - OffsetNumber k, - j; - GISTTYPE *datum_l, - *datum_r; - BITVECP union_l, - union_r; - int4 size_alpha, size_beta; - int4 size_waste, - waste = -1; - int4 nbytes; - OffsetNumber seed_1 = 0, - seed_2 = 0; - OffsetNumber *left, - *right; - OffsetNumber maxoff; - BITVECP ptr; - int i; - SPLITCOST *costvector; - GISTTYPE *_k, - *_j; - - maxoff = entryvec->n - 2; - nbytes = (maxoff + 2) * sizeof(OffsetNumber); - v->spl_left = (OffsetNumber *) palloc(nbytes); - v->spl_right = (OffsetNumber *) palloc(nbytes); - - for (k = FirstOffsetNumber; k < maxoff; k = OffsetNumberNext(k)) { - _k = GETENTRY(entryvec, k); - for (j = OffsetNumberNext(k); j <= maxoff; j = OffsetNumberNext(j)) { - size_waste=hemdist(_k, GETENTRY(entryvec, j)); - if (size_waste > waste ) { - waste = size_waste; - seed_1 = k; - seed_2 = j; - } - } - } - - left = v->spl_left; - v->spl_nleft = 0; - right = v->spl_right; - v->spl_nright = 0; - - if (seed_1 == 0 || seed_2 == 0) - { - seed_1 = 1; - seed_2 = 2; - } - - /* form initial .. */ - if (ISALLTRUE(GETENTRY(entryvec, seed_1))) - { - datum_l = (GISTTYPE *) palloc(GTHDRSIZE); - datum_l->len = GTHDRSIZE; - datum_l->flag = ALLISTRUE; - } - else - { - datum_l = (GISTTYPE *) palloc(GTHDRSIZE + SIGLEN); - datum_l->len = GTHDRSIZE + SIGLEN; - datum_l->flag = 0; - memcpy((void *) GETSIGN(datum_l), (void *) GETSIGN(GETENTRY(entryvec, seed_1)), sizeof(BITVEC)); - } - if (ISALLTRUE(GETENTRY(entryvec, seed_2))) - { - datum_r = (GISTTYPE *) palloc(GTHDRSIZE); - datum_r->len = GTHDRSIZE; - datum_r->flag = ALLISTRUE; - } - else - { - datum_r = (GISTTYPE *) palloc(GTHDRSIZE + SIGLEN); - datum_r->len = GTHDRSIZE + SIGLEN; - datum_r->flag = 0; - memcpy((void *) GETSIGN(datum_r), (void *) GETSIGN(GETENTRY(entryvec, seed_2)), sizeof(BITVEC)); - } - - maxoff = OffsetNumberNext(maxoff); - /* sort before ... */ - costvector = (SPLITCOST *) palloc(sizeof(SPLITCOST) * maxoff); - for (j = FirstOffsetNumber; j <= maxoff; j = OffsetNumberNext(j)) - { - costvector[j - 1].pos = j; - _j = GETENTRY(entryvec, j); - size_alpha = hemdist(datum_l,_j); - size_beta = hemdist(datum_r,_j); - costvector[j - 1].cost = abs(size_alpha - size_beta); - } - qsort((void *) costvector, maxoff, sizeof(SPLITCOST), comparecost); - - union_l=GETSIGN(datum_l); - union_r=GETSIGN(datum_r); - - for (k = 0; k < maxoff; k++) - { - j = costvector[k].pos; - if (j == seed_1) - { - *left++ = j; - v->spl_nleft++; - continue; - } - else if (j == seed_2) - { - *right++ = j; - v->spl_nright++; - continue; - } - _j = GETENTRY(entryvec, j); - size_alpha = hemdist(datum_l,_j); - size_beta = hemdist(datum_r,_j); - - if (size_alpha < size_beta + WISH_F(v->spl_nleft, v->spl_nright, 0.00001)) - { - if (ISALLTRUE(datum_l) || ISALLTRUE(_j) ) { - if (!ISALLTRUE(datum_l)) - MemSet((void *) union_l, 0xff, sizeof(BITVEC)); - } else { - ptr=GETSIGN(_j); - LOOPBYTE( - union_l[i] |= ptr[i]; - ); - } - *left++ = j; - v->spl_nleft++; - } - else - { - if (ISALLTRUE(datum_r) || ISALLTRUE(_j) ) { - if (!ISALLTRUE(datum_r)) - MemSet((void *) union_r, 0xff, sizeof(BITVEC)); - } else { - ptr=GETSIGN(_j); - LOOPBYTE( - union_r[i] |= ptr[i]; - ); - } - *right++ = j; - v->spl_nright++; - } - } - - *right = *left = FirstOffsetNumber; - pfree(costvector); - - v->spl_ldatum = PointerGetDatum(datum_l); - v->spl_rdatum = PointerGetDatum(datum_r); - - PG_RETURN_POINTER(v); +g_intbig_picksplit(PG_FUNCTION_ARGS) +{ + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1); + OffsetNumber k, + j; + GISTTYPE *datum_l, + *datum_r; + BITVECP union_l, + union_r; + int4 size_alpha, + size_beta; + int4 size_waste, + waste = -1; + int4 nbytes; + OffsetNumber seed_1 = 0, + seed_2 = 0; + OffsetNumber *left, + *right; + OffsetNumber maxoff; + BITVECP ptr; + int i; + SPLITCOST *costvector; + GISTTYPE *_k, + *_j; + + maxoff = entryvec->n - 2; + nbytes = (maxoff + 2) * sizeof(OffsetNumber); + v->spl_left = (OffsetNumber *) palloc(nbytes); + v->spl_right = (OffsetNumber *) palloc(nbytes); + + for (k = FirstOffsetNumber; k < maxoff; k = OffsetNumberNext(k)) + { + _k = GETENTRY(entryvec, k); + for (j = OffsetNumberNext(k); j <= maxoff; j = OffsetNumberNext(j)) + { + size_waste = hemdist(_k, GETENTRY(entryvec, j)); + if (size_waste > waste) + { + waste = size_waste; + seed_1 = k; + seed_2 = j; + } + } + } + + left = v->spl_left; + v->spl_nleft = 0; + right = v->spl_right; + v->spl_nright = 0; + + if (seed_1 == 0 || seed_2 == 0) + { + seed_1 = 1; + seed_2 = 2; + } + + /* form initial .. */ + if (ISALLTRUE(GETENTRY(entryvec, seed_1))) + { + datum_l = (GISTTYPE *) palloc(GTHDRSIZE); + datum_l->len = GTHDRSIZE; + datum_l->flag = ALLISTRUE; + } + else + { + datum_l = (GISTTYPE *) palloc(GTHDRSIZE + SIGLEN); + datum_l->len = GTHDRSIZE + SIGLEN; + datum_l->flag = 0; + memcpy((void *) GETSIGN(datum_l), (void *) GETSIGN(GETENTRY(entryvec, seed_1)), sizeof(BITVEC)); + } + if (ISALLTRUE(GETENTRY(entryvec, seed_2))) + { + datum_r = (GISTTYPE *) palloc(GTHDRSIZE); + datum_r->len = GTHDRSIZE; + datum_r->flag = ALLISTRUE; + } + else + { + datum_r = (GISTTYPE *) palloc(GTHDRSIZE + SIGLEN); + datum_r->len = GTHDRSIZE + SIGLEN; + datum_r->flag = 0; + memcpy((void *) GETSIGN(datum_r), (void *) GETSIGN(GETENTRY(entryvec, seed_2)), sizeof(BITVEC)); + } + + maxoff = OffsetNumberNext(maxoff); + /* sort before ... */ + costvector = (SPLITCOST *) palloc(sizeof(SPLITCOST) * maxoff); + for (j = FirstOffsetNumber; j <= maxoff; j = OffsetNumberNext(j)) + { + costvector[j - 1].pos = j; + _j = GETENTRY(entryvec, j); + size_alpha = hemdist(datum_l, _j); + size_beta = hemdist(datum_r, _j); + costvector[j - 1].cost = abs(size_alpha - size_beta); + } + qsort((void *) costvector, maxoff, sizeof(SPLITCOST), comparecost); + + union_l = GETSIGN(datum_l); + union_r = GETSIGN(datum_r); + + for (k = 0; k < maxoff; k++) + { + j = costvector[k].pos; + if (j == seed_1) + { + *left++ = j; + v->spl_nleft++; + continue; + } + else if (j == seed_2) + { + *right++ = j; + v->spl_nright++; + continue; + } + _j = GETENTRY(entryvec, j); + size_alpha = hemdist(datum_l, _j); + size_beta = hemdist(datum_r, _j); + + if (size_alpha < size_beta + WISH_F(v->spl_nleft, v->spl_nright, 0.00001)) + { + if (ISALLTRUE(datum_l) || ISALLTRUE(_j)) + { + if (!ISALLTRUE(datum_l)) + MemSet((void *) union_l, 0xff, sizeof(BITVEC)); + } + else + { + ptr = GETSIGN(_j); + LOOPBYTE( + union_l[i] |= ptr[i]; + ); + } + *left++ = j; + v->spl_nleft++; + } + else + { + if (ISALLTRUE(datum_r) || ISALLTRUE(_j)) + { + if (!ISALLTRUE(datum_r)) + MemSet((void *) union_r, 0xff, sizeof(BITVEC)); + } + else + { + ptr = GETSIGN(_j); + LOOPBYTE( + union_r[i] |= ptr[i]; + ); + } + *right++ = j; + v->spl_nright++; + } + } + + *right = *left = FirstOffsetNumber; + pfree(costvector); + + v->spl_ldatum = PointerGetDatum(datum_l); + v->spl_rdatum = PointerGetDatum(datum_r); + + PG_RETURN_POINTER(v); } Datum @@ -443,12 +481,13 @@ g_intbig_consistent(PG_FUNCTION_ARGS) StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); bool retval; - if ( ISALLTRUE(DatumGetPointer(entry->key)) ) + if (ISALLTRUE(DatumGetPointer(entry->key))) PG_RETURN_BOOL(true); - - if (strategy == BooleanSearchStrategy) { + + if (strategy == BooleanSearchStrategy) + { PG_RETURN_BOOL(signconsistent((QUERYTYPE *) query, - GETSIGN(DatumGetPointer(entry->key)), + GETSIGN(DatumGetPointer(entry->key)), false)); } @@ -462,58 +501,72 @@ g_intbig_consistent(PG_FUNCTION_ARGS) retval = _intbig_overlap((GISTTYPE *) DatumGetPointer(entry->key), query); break; case RTSameStrategyNumber: - if (GIST_LEAF(entry)) { - int i,num=ARRNELEMS(query); - int4 *ptr=ARRPTR(query); - BITVEC qp; - BITVECP dq, de; - memset(qp,0,sizeof(BITVEC)); - - while(num--) { + if (GIST_LEAF(entry)) + { + int i, + num = ARRNELEMS(query); + int4 *ptr = ARRPTR(query); + BITVEC qp; + BITVECP dq, + de; + + memset(qp, 0, sizeof(BITVEC)); + + while (num--) + { HASH(qp, *ptr); ptr++; } - de=GETSIGN((GISTTYPE *) DatumGetPointer(entry->key)); - dq=qp; - retval=true; + de = GETSIGN((GISTTYPE *) DatumGetPointer(entry->key)); + dq = qp; + retval = true; LOOPBYTE( - if ( de[i] != dq[i] ) { - retval=false; - break; - } + if (de[i] != dq[i]) + { + retval = false; + break; + } ); - } else + } + else retval = _intbig_contains((GISTTYPE *) DatumGetPointer(entry->key), query); break; case RTContainsStrategyNumber: retval = _intbig_contains((GISTTYPE *) DatumGetPointer(entry->key), query); break; case RTContainedByStrategyNumber: - if (GIST_LEAF(entry)) { - int i,num=ARRNELEMS(query); - int4 *ptr=ARRPTR(query); - BITVEC qp; - BITVECP dq, de; - memset(qp,0,sizeof(BITVEC)); - - while(num--) { + if (GIST_LEAF(entry)) + { + int i, + num = ARRNELEMS(query); + int4 *ptr = ARRPTR(query); + BITVEC qp; + BITVECP dq, + de; + + memset(qp, 0, sizeof(BITVEC)); + + while (num--) + { HASH(qp, *ptr); ptr++; } - de=GETSIGN((GISTTYPE *) DatumGetPointer(entry->key)); - dq=qp; - retval=true; + de = GETSIGN((GISTTYPE *) DatumGetPointer(entry->key)); + dq = qp; + retval = true; LOOPBYTE( - if ( de[i] & ~dq[i] ) { - retval=false; - break; - } + if (de[i] & ~dq[i]) + { + retval = false; + break; + } ); - } else + } + else retval = _intbig_overlap((GISTTYPE *) DatumGetPointer(entry->key), query); break; default: @@ -521,5 +574,3 @@ g_intbig_consistent(PG_FUNCTION_ARGS) } PG_RETURN_BOOL(retval); } - - diff --git a/contrib/ltree/_ltree_gist.c b/contrib/ltree/_ltree_gist.c index f1b2efb157..f0e01bbf47 100644 --- a/contrib/ltree/_ltree_gist.c +++ b/contrib/ltree/_ltree_gist.c @@ -75,8 +75,8 @@ _ltree_compress(PG_FUNCTION_ARGS) if (ARR_NDIM(val) != 1) ereport(ERROR, - (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR), - errmsg("array must be one-dimensional"))); + (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR), + errmsg("array must be one-dimensional"))); key = (ltree_gist *) palloc(len); key->len = len; @@ -98,7 +98,7 @@ _ltree_compress(PG_FUNCTION_ARGS) entry->rel, entry->page, entry->offset, key->len, FALSE); } - else if ( !LTG_ISALLTRUE(entry->key) ) + else if (!LTG_ISALLTRUE(entry->key)) { int4 i, len; @@ -107,7 +107,7 @@ _ltree_compress(PG_FUNCTION_ARGS) BITVECP sign = LTG_SIGN(DatumGetPointer(entry->key)); ALOOPBYTE( - if ((sign[i]&0xff) != 0xff) + if ((sign[i] & 0xff) != 0xff) PG_RETURN_POINTER(retval); ); len = LTG_HDRSIZE; @@ -172,10 +172,11 @@ unionkey(BITVECP sbase, ltree_gist * add) Datum _ltree_union(PG_FUNCTION_ARGS) { - GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); int *size = (int *) PG_GETARG_POINTER(1); ABITVEC base; - int4 i,len; + int4 i, + len; int4 flag = 0; ltree_gist *result; @@ -212,28 +213,33 @@ sizebitvec(BITVECP sign) return size; } -static int -hemdistsign(BITVECP a, BITVECP b) { - int i,dist=0; - +static int +hemdistsign(BITVECP a, BITVECP b) +{ + int i, + dist = 0; + ALOOPBIT( - if ( GETBIT(a,i) != GETBIT(b,i) ) - dist++; + if (GETBIT(a, i) != GETBIT(b, i)) + dist++; ); return dist; } static int -hemdist(ltree_gist *a, ltree_gist *b) { - if ( LTG_ISALLTRUE(a) ) { - if (LTG_ISALLTRUE(b)) - return 0; - else - return ASIGLENBIT-sizebitvec(LTG_SIGN(b)); - } else if (LTG_ISALLTRUE(b)) - return ASIGLENBIT-sizebitvec(LTG_SIGN(a)); - - return hemdistsign( LTG_SIGN(a), LTG_SIGN(b) ); +hemdist(ltree_gist * a, ltree_gist * b) +{ + if (LTG_ISALLTRUE(a)) + { + if (LTG_ISALLTRUE(b)) + return 0; + else + return ASIGLENBIT - sizebitvec(LTG_SIGN(b)); + } + else if (LTG_ISALLTRUE(b)) + return ASIGLENBIT - sizebitvec(LTG_SIGN(a)); + + return hemdistsign(LTG_SIGN(a), LTG_SIGN(b)); } @@ -244,7 +250,7 @@ _ltree_penalty(PG_FUNCTION_ARGS) ltree_gist *newval = (ltree_gist *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); float *penalty = (float *) PG_GETARG_POINTER(2); - *penalty=hemdist(origval,newval); + *penalty = hemdist(origval, newval); PG_RETURN_POINTER(penalty); } @@ -263,7 +269,7 @@ comparecost(const void *a, const void *b) Datum _ltree_picksplit(PG_FUNCTION_ARGS) { - GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1); OffsetNumber k, j; @@ -271,7 +277,8 @@ _ltree_picksplit(PG_FUNCTION_ARGS) *datum_r; BITVECP union_l, union_r; - int4 size_alpha, size_beta; + int4 size_alpha, + size_beta; int4 size_waste, waste = -1; int4 nbytes; @@ -291,11 +298,14 @@ _ltree_picksplit(PG_FUNCTION_ARGS) v->spl_left = (OffsetNumber *) palloc(nbytes); v->spl_right = (OffsetNumber *) palloc(nbytes); - for (k = FirstOffsetNumber; k < maxoff; k = OffsetNumberNext(k)) { + for (k = FirstOffsetNumber; k < maxoff; k = OffsetNumberNext(k)) + { _k = GETENTRY(entryvec, k); - for (j = OffsetNumberNext(k); j <= maxoff; j = OffsetNumberNext(j)) { - size_waste=hemdist(_k, GETENTRY(entryvec, j)); - if (size_waste > waste ) { + for (j = OffsetNumberNext(k); j <= maxoff; j = OffsetNumberNext(j)) + { + size_waste = hemdist(_k, GETENTRY(entryvec, j)); + if (size_waste > waste) + { waste = size_waste; seed_1 = k; seed_2 = j; @@ -349,15 +359,15 @@ _ltree_picksplit(PG_FUNCTION_ARGS) { costvector[j - 1].pos = j; _j = GETENTRY(entryvec, j); - size_alpha = hemdist(datum_l,_j); - size_beta = hemdist(datum_r,_j); + size_alpha = hemdist(datum_l, _j); + size_beta = hemdist(datum_r, _j); costvector[j - 1].cost = abs(size_alpha - size_beta); } qsort((void *) costvector, maxoff, sizeof(SPLITCOST), comparecost); - union_l=LTG_SIGN(datum_l); - union_r=LTG_SIGN(datum_r); - + union_l = LTG_SIGN(datum_l); + union_r = LTG_SIGN(datum_r); + for (k = 0; k < maxoff; k++) { j = costvector[k].pos; @@ -374,18 +384,21 @@ _ltree_picksplit(PG_FUNCTION_ARGS) continue; } _j = GETENTRY(entryvec, j); - size_alpha = hemdist(datum_l,_j); - size_beta = hemdist(datum_r,_j); + size_alpha = hemdist(datum_l, _j); + size_beta = hemdist(datum_r, _j); - if (size_alpha < size_beta + WISH_F(v->spl_nleft, v->spl_nright, 0.00001)) + if (size_alpha < size_beta + WISH_F(v->spl_nleft, v->spl_nright, 0.00001)) { - if (LTG_ISALLTRUE(datum_l) || LTG_ISALLTRUE(_j) ) { + if (LTG_ISALLTRUE(datum_l) || LTG_ISALLTRUE(_j)) + { if (!LTG_ISALLTRUE(datum_l)) - MemSet((void *) union_l, 0xff, sizeof(ABITVEC)); - } else { - ptr=LTG_SIGN(_j); + MemSet((void *) union_l, 0xff, sizeof(ABITVEC)); + } + else + { + ptr = LTG_SIGN(_j); ALOOPBYTE( - union_l[i] |= ptr[i]; + union_l[i] |= ptr[i]; ); } *left++ = j; @@ -393,13 +406,16 @@ _ltree_picksplit(PG_FUNCTION_ARGS) } else { - if (LTG_ISALLTRUE(datum_r) || LTG_ISALLTRUE(_j) ) { + if (LTG_ISALLTRUE(datum_r) || LTG_ISALLTRUE(_j)) + { if (!LTG_ISALLTRUE(datum_r)) - MemSet((void *) union_r, 0xff, sizeof(ABITVEC)); - } else { - ptr=LTG_SIGN(_j); + MemSet((void *) union_r, 0xff, sizeof(ABITVEC)); + } + else + { + ptr = LTG_SIGN(_j); ALOOPBYTE( - union_r[i] |= ptr[i]; + union_r[i] |= ptr[i]; ); } *right++ = j; @@ -498,22 +514,24 @@ gist_qe(ltree_gist * key, lquery * query) } static bool -_arrq_cons(ltree_gist *key, ArrayType *_query) { - lquery *query = (lquery *) ARR_DATA_PTR(_query); - int num = ArrayGetNItems(ARR_NDIM(_query), ARR_DIMS(_query)); +_arrq_cons(ltree_gist * key, ArrayType *_query) +{ + lquery *query = (lquery *) ARR_DATA_PTR(_query); + int num = ArrayGetNItems(ARR_NDIM(_query), ARR_DIMS(_query)); - if (ARR_NDIM(_query) != 1) - ereport(ERROR, + if (ARR_NDIM(_query) != 1) + ereport(ERROR, (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR), errmsg("array must be one-dimensional"))); - while (num > 0) { - if ( gist_qe(key, query) ) - return true; - num--; - query = (lquery*)NEXTVAL(query); - } - return false; + while (num > 0) + { + if (gist_qe(key, query)) + return true; + num--; + query = (lquery *) NEXTVAL(query); + } + return false; } Datum diff --git a/contrib/ltree/ltree_gist.c b/contrib/ltree/ltree_gist.c index eb091f9927..7630b4f60c 100644 --- a/contrib/ltree/ltree_gist.c +++ b/contrib/ltree/ltree_gist.c @@ -166,7 +166,7 @@ hashing(BITVECP sign, ltree * t) Datum ltree_union(PG_FUNCTION_ARGS) { - GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); int *size = (int *) PG_GETARG_POINTER(1); BITVEC base; int4 i, @@ -277,14 +277,14 @@ treekey_cmp(const void *a, const void *b) return ltree_compare( ((RIX *) a)->r, ((RIX *) b)->r - ); + ); } Datum ltree_picksplit(PG_FUNCTION_ARGS) { - GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1); OffsetNumber j; int4 i; @@ -602,21 +602,23 @@ gist_qtxt(ltree_gist * key, ltxtquery * query) } static bool -arrq_cons(ltree_gist *key, ArrayType *_query) { - lquery *query = (lquery *) ARR_DATA_PTR(_query); - int num = ArrayGetNItems(ARR_NDIM(_query), ARR_DIMS(_query)); +arrq_cons(ltree_gist * key, ArrayType *_query) +{ + lquery *query = (lquery *) ARR_DATA_PTR(_query); + int num = ArrayGetNItems(ARR_NDIM(_query), ARR_DIMS(_query)); - if (ARR_NDIM(_query) != 1) - ereport(ERROR, + if (ARR_NDIM(_query) != 1) + ereport(ERROR, (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR), errmsg("array must be one-dimensional"))); - while (num > 0) { - if ( gist_qe(key, query) && gist_between(key, query) ) - return true; - num--; - query = NEXTVAL(query); - } + while (num > 0) + { + if (gist_qe(key, query) && gist_between(key, query)) + return true; + num--; + query = NEXTVAL(query); + } return false; } @@ -700,7 +702,7 @@ ltree_consistent(PG_FUNCTION_ARGS) if (GIST_LEAF(entry)) res = DatumGetBool(DirectFunctionCall2(lt_q_regex, PointerGetDatum(LTG_NODE(key)), - PointerGetDatum((ArrayType *) query) + PointerGetDatum((ArrayType *) query) )); else res = arrq_cons(key, (ArrayType *) query); diff --git a/contrib/pg_autovacuum/pg_autovacuum.c b/contrib/pg_autovacuum/pg_autovacuum.c index 191b91ba38..6ea76515cf 100644 --- a/contrib/pg_autovacuum/pg_autovacuum.c +++ b/contrib/pg_autovacuum/pg_autovacuum.c @@ -228,20 +228,20 @@ update_table_list(db_info * dbi) if (res != NULL) { t = PQntuples(res); - + /* - * First: use the tbl_list as the outer loop and the result set as - * the inner loop, this will determine what tables should be - * removed - */ + * First: use the tbl_list as the outer loop and the result + * set as the inner loop, this will determine what tables + * should be removed + */ while (tbl_elem != NULL) { tbl = ((tbl_info *) DLE_VAL(tbl_elem)); found_match = 0; - + for (i = 0; i < t; i++) - { /* loop through result set looking for a - * match */ + { /* loop through result set looking for a + * match */ if (tbl->relid == atooid(PQgetvalue(res, i, PQfnumber(res, "oid")))) { found_match = 1; @@ -249,22 +249,22 @@ update_table_list(db_info * dbi) } } if (found_match == 0) - { /* then we didn't find this tbl_elem in - * the result set */ + { /* then we didn't find this tbl_elem in + * the result set */ Dlelem *elem_to_remove = tbl_elem; - + tbl_elem = DLGetSucc(tbl_elem); remove_table_from_list(elem_to_remove); } else tbl_elem = DLGetSucc(tbl_elem); - } /* Done removing dropped tables from the - * table_list */ - + } /* Done removing dropped tables from the + * table_list */ + /* - * Then loop use result set as outer loop and tbl_list as the - * inner loop to determine what tables are new - */ + * Then loop use result set as outer loop and tbl_list as the + * inner loop to determine what tables are new + */ for (i = 0; i < t; i++) { tbl_elem = DLGetHead(dbi->table_list); @@ -279,8 +279,8 @@ update_table_list(db_info * dbi) } tbl_elem = DLGetSucc(tbl_elem); } - if (found_match == 0) /* then we didn't find this result - * now in the tbl_list */ + if (found_match == 0) /* then we didn't find this result + * now in the tbl_list */ { DLAddTail(dbi->table_list, DLNewElem(init_table_info(res, i, dbi))); if (args->debug >= 1) @@ -290,7 +290,7 @@ update_table_list(db_info * dbi) log_entry(logbuffer); } } - } /* end of for loop that adds tables */ + } /* end of for loop that adds tables */ } fflush(LOGOUTPUT); PQclear(res); @@ -419,7 +419,7 @@ init_db_list() dbs->age = atol(PQgetvalue(res, 0, PQfnumber(res, "age"))); if (res) PQclear(res); - + if (args->debug >= 2) print_db_list(db_list, 0); } @@ -499,49 +499,49 @@ update_db_list(Dllist *db_list) if (res != NULL) { t = PQntuples(res); - + /* - * First: use the db_list as the outer loop and the result set as - * the inner loop, this will determine what databases should be - * removed - */ + * First: use the db_list as the outer loop and the result set + * as the inner loop, this will determine what databases + * should be removed + */ while (db_elem != NULL) { dbi = ((db_info *) DLE_VAL(db_elem)); found_match = 0; - + for (i = 0; i < t; i++) - { /* loop through result set looking for a - * match */ + { /* loop through result set looking for a + * match */ if (dbi->oid == atooid(PQgetvalue(res, i, PQfnumber(res, "oid")))) { found_match = 1; - + /* - * update the dbi->age so that we ensure - * xid_wraparound won't happen - */ + * update the dbi->age so that we ensure + * xid_wraparound won't happen + */ dbi->age = atol(PQgetvalue(res, i, PQfnumber(res, "age"))); break; } } if (found_match == 0) - { /* then we didn't find this db_elem in the - * result set */ + { /* then we didn't find this db_elem in the + * result set */ Dlelem *elem_to_remove = db_elem; - + db_elem = DLGetSucc(db_elem); remove_db_from_list(elem_to_remove); } else db_elem = DLGetSucc(db_elem); - } /* Done removing dropped databases from - * the table_list */ - + } /* Done removing dropped databases from + * the table_list */ + /* - * Then loop use result set as outer loop and db_list as the inner - * loop to determine what databases are new - */ + * Then loop use result set as outer loop and db_list as the + * inner loop to determine what databases are new + */ for (i = 0; i < t; i++) { db_elem = DLGetHead(db_list); @@ -556,20 +556,20 @@ update_db_list(Dllist *db_list) } db_elem = DLGetSucc(db_elem); } - if (found_match == 0) /* then we didn't find this result - * now in the tbl_list */ + if (found_match == 0) /* then we didn't find this result + * now in the tbl_list */ { DLAddTail(db_list, DLNewElem(init_dbinfo - (PQgetvalue(res, i, PQfnumber(res, "datname")), - atooid(PQgetvalue(res, i, PQfnumber(res, "oid"))), - atol(PQgetvalue(res, i, PQfnumber(res, "age")))))); + (PQgetvalue(res, i, PQfnumber(res, "datname")), + atooid(PQgetvalue(res, i, PQfnumber(res, "oid"))), + atol(PQgetvalue(res, i, PQfnumber(res, "age")))))); if (args->debug >= 1) { sprintf(logbuffer, "added database: %s", ((db_info *) DLE_VAL(DLGetTail(db_list)))->dbname); log_entry(logbuffer); } } - } /* end of for loop that adds tables */ + } /* end of for loop that adds tables */ } fflush(LOGOUTPUT); PQclear(res); @@ -604,16 +604,14 @@ xid_wraparound_check(db_info * dbi) * 500million xacts to work with so we should be able to spread the * load of full database vacuums a bit */ - if (dbi->age > 1500000000 ) + if (dbi->age > 1500000000) { PGresult *res = NULL; res = send_query("VACUUM", dbi); /* FIXME: Perhaps should add a check for PQ_COMMAND_OK */ if (res != NULL) - { PQclear(res); - } return 1; } return 0; @@ -697,16 +695,16 @@ print_db_info(db_info * dbi, int print_tbl_list) { sprintf(logbuffer, "dbname: %s", (dbi->dbname) ? dbi->dbname : "(null)"); log_entry(logbuffer); - + sprintf(logbuffer, " oid: %u", dbi->oid); log_entry(logbuffer); - + sprintf(logbuffer, " username: %s", (dbi->username) ? dbi->username : "(null)"); log_entry(logbuffer); - + sprintf(logbuffer, " password: %s", (dbi->password) ? dbi->password : "(null)"); log_entry(logbuffer); - + if (dbi->conn != NULL) log_entry(" conn is valid, (connected)"); else @@ -714,10 +712,10 @@ print_db_info(db_info * dbi, int print_tbl_list) sprintf(logbuffer, " default_analyze_threshold: %li", dbi->analyze_threshold); log_entry(logbuffer); - + sprintf(logbuffer, " default_vacuum_threshold: %li", dbi->vacuum_threshold); log_entry(logbuffer); - + fflush(LOGOUTPUT); if (print_tbl_list > 0) print_table_list(dbi->table_list); @@ -1036,7 +1034,7 @@ main(int argc, char *argv[]) db_list = init_db_list(); if (db_list == NULL) return 1; - + if (check_stats_enabled(((db_info *) DLE_VAL(DLGetHead(db_list)))) != 0) { log_entry("Error: GUC variable stats_row_level must be enabled."); @@ -1096,38 +1094,40 @@ main(int argc, char *argv[]) if (res != NULL) { for (j = 0; j < PQntuples(res); j++) - { /* loop through result set */ - tbl_elem = DLGetHead(dbs->table_list); /* Reset tbl_elem to top - * of dbs->table_list */ + { /* loop through result set */ + tbl_elem = DLGetHead(dbs->table_list); /* Reset tbl_elem to top + * of dbs->table_list */ while (tbl_elem != NULL) - { /* Loop through tables in list */ - tbl = ((tbl_info *) DLE_VAL(tbl_elem)); /* set tbl_info = - * current_table */ + { /* Loop through tables in list */ + tbl = ((tbl_info *) DLE_VAL(tbl_elem)); /* set tbl_info = + * current_table */ if (tbl->relid == atooid(PQgetvalue(res, j, PQfnumber(res, "oid")))) { tbl->curr_analyze_count = (atol(PQgetvalue(res, j, PQfnumber(res, "n_tup_ins"))) + - atol(PQgetvalue(res, j, PQfnumber(res, "n_tup_upd"))) + - atol(PQgetvalue(res, j, PQfnumber(res, "n_tup_del")))); + atol(PQgetvalue(res, j, PQfnumber(res, "n_tup_upd"))) + + atol(PQgetvalue(res, j, PQfnumber(res, "n_tup_del")))); tbl->curr_vacuum_count = (atol(PQgetvalue(res, j, PQfnumber(res, "n_tup_del"))) + - atol(PQgetvalue(res, j, PQfnumber(res, "n_tup_upd")))); - + atol(PQgetvalue(res, j, PQfnumber(res, "n_tup_upd")))); + /* - * Check numDeletes to see if we need to - * vacuum, if so: Run vacuum analyze - * (adding analyze is small so we might as - * well) Update table thresholds and - * related information if numDeletes is - * not big enough for vacuum then check - * numInserts for analyze - */ + * Check numDeletes to see if we need + * to vacuum, if so: Run vacuum + * analyze (adding analyze is small so + * we might as well) Update table + * thresholds and related information + * if numDeletes is not big enough for + * vacuum then check numInserts for + * analyze + */ if (tbl->curr_vacuum_count - tbl->CountAtLastVacuum >= tbl->vacuum_threshold) { /* - * if relisshared = t and database != - * template1 then only do an analyze - */ + * if relisshared = t and database + * != template1 then only do an + * analyze + */ if (tbl->relisshared > 0 && strcmp("template1", dbs->dbname)) snprintf(buf, sizeof(buf), "ANALYZE %s", tbl->table_name); else @@ -1157,19 +1157,20 @@ main(int argc, char *argv[]) if (args->debug >= 2) print_table_info(tbl); } - - break; /* once we have found a match, no - * need to keep checking. */ + + break; /* once we have found a + * match, no need to keep + * checking. */ } - + /* - * Advance the table pointers for the next - * loop - */ + * Advance the table pointers for the next + * loop + */ tbl_elem = DLGetSucc(tbl_elem); - - } /* end for table while loop */ - } /* end for j loop (tuples in PGresult) */ + + } /* end for table while loop */ + } /* end for j loop (tuples in PGresult) */ } /* end if (res != NULL) */ } /* close of if(xid_wraparound_check()) */ /* Done working on this db, Clean up, then advance cur_db */ diff --git a/contrib/pg_dumplo/utils.c b/contrib/pg_dumplo/utils.c index 92a1ae52fd..c48db20e94 100644 --- a/contrib/pg_dumplo/utils.c +++ b/contrib/pg_dumplo/utils.c @@ -30,7 +30,7 @@ void index_file(LODumpMaster * pgLO) { char path[BUFSIZ]; - int sz; + int sz; if (pgLO->action == ACTION_SHOW) return; @@ -51,7 +51,7 @@ index_file(LODumpMaster * pgLO) } sz = strlen(path); - strncat(path, "/lo_dump.index", BUFSIZ-sz); + strncat(path, "/lo_dump.index", BUFSIZ - sz); if ((pgLO->index = fopen(path, "w")) == NULL) { @@ -63,7 +63,7 @@ index_file(LODumpMaster * pgLO) else if (pgLO->action != ACTION_NONE) { sz = strlen(path); - strncat(path, "/lo_dump.index", BUFSIZ-sz); + strncat(path, "/lo_dump.index", BUFSIZ - sz); if ((pgLO->index = fopen(path, "r")) == NULL) { diff --git a/contrib/pg_trgm/trgm.h b/contrib/pg_trgm/trgm.h index a56edca129..73c4cb6aa6 100644 --- a/contrib/pg_trgm/trgm.h +++ b/contrib/pg_trgm/trgm.h @@ -11,53 +11,54 @@ #include "storage/bufpage.h" /* options */ -#define LPADDING 2 -#define RPADDING 1 +#define LPADDING 2 +#define RPADDING 1 #define KEEPONLYALNUM -#define IGNORECASE +#define IGNORECASE #define DIVUNION typedef char trgm[3]; #define CMPCHAR(a,b) ( ((a)==(b)) ? 0 : ( ((a)<(b)) ? -1 : 1 ) ) -#define CMPPCHAR(a,b,i) CMPCHAR( *(((char*)(a))+i), *(((char*)(b))+i) ) +#define CMPPCHAR(a,b,i) CMPCHAR( *(((char*)(a))+i), *(((char*)(b))+i) ) #define CMPTRGM(a,b) ( CMPPCHAR(a,b,0) ? CMPPCHAR(a,b,0) : ( CMPPCHAR(a,b,1) ? CMPPCHAR(a,b,1) : CMPPCHAR(a,b,2) ) ) -#define CPTRGM(a,b) do { \ +#define CPTRGM(a,b) do { \ *(((char*)(a))+0) = *(((char*)(b))+0); \ *(((char*)(a))+1) = *(((char*)(b))+1); \ *(((char*)(a))+2) = *(((char*)(b))+2); \ } while(0); -typedef struct { - int4 len; - uint8 flag; - char data[1]; -} TRGM; +typedef struct +{ + int4 len; + uint8 flag; + char data[1]; +} TRGM; -#define TRGMHRDSIZE (sizeof(int4)+sizeof(uint8)) +#define TRGMHRDSIZE (sizeof(int4)+sizeof(uint8)) /* gist */ #define BITBYTE 8 -#define SIGLENINT 3 /* >122 => key will toast, so very slow!!! */ -#define SIGLEN ( sizeof(int)*SIGLENINT ) +#define SIGLENINT 3 /* >122 => key will toast, so very slow!!! */ +#define SIGLEN ( sizeof(int)*SIGLENINT ) -#define SIGLENBIT (SIGLEN*BITBYTE - 1) /* see makesign */ +#define SIGLENBIT (SIGLEN*BITBYTE - 1) /* see makesign */ typedef char BITVEC[SIGLEN]; typedef char *BITVECP; #define LOOPBYTE(a) \ - for(i=0;i<SIGLEN;i++) {\ - a;\ - } + for(i=0;i<SIGLEN;i++) {\ + a;\ + } #define LOOPBIT(a) \ - for(i=0;i<SIGLENBIT;i++) {\ - a;\ - } + for(i=0;i<SIGLENBIT;i++) {\ + a;\ + } #define GETBYTE(x,i) ( *( (BITVECP)(x) + (int)( (i) / BITBYTE ) ) ) #define GETBITBYTE(x,i) ( ((char)(x)) >> i & 0x01 ) @@ -68,21 +69,21 @@ typedef char *BITVECP; #define HASHVAL(val) (((unsigned int)(val)) % SIGLENBIT) #define HASH(sign, val) SETBIT((sign), HASHVAL(val)) -#define ARRKEY 0x01 -#define SIGNKEY 0x02 -#define ALLISTRUE 0x04 - +#define ARRKEY 0x01 +#define SIGNKEY 0x02 +#define ALLISTRUE 0x04 + #define ISARRKEY(x) ( ((TRGM*)x)->flag & ARRKEY ) -#define ISSIGNKEY(x) ( ((TRGM*)x)->flag & SIGNKEY ) -#define ISALLTRUE(x) ( ((TRGM*)x)->flag & ALLISTRUE ) +#define ISSIGNKEY(x) ( ((TRGM*)x)->flag & SIGNKEY ) +#define ISALLTRUE(x) ( ((TRGM*)x)->flag & ALLISTRUE ) #define CALCGTSIZE(flag, len) ( TRGMHRDSIZE + ( ( (flag) & ARRKEY ) ? ((len)*sizeof(trgm)) : (((flag) & ALLISTRUE) ? 0 : SIGLEN) ) ) -#define GETSIGN(x) ( (BITVECP)( (char*)x+TRGMHRDSIZE ) ) -#define GETARR(x) ( (trgm*)( (char*)x+TRGMHRDSIZE ) ) +#define GETSIGN(x) ( (BITVECP)( (char*)x+TRGMHRDSIZE ) ) +#define GETARR(x) ( (trgm*)( (char*)x+TRGMHRDSIZE ) ) #define ARRNELEM(x) ( ( ((TRGM*)x)->len - TRGMHRDSIZE )/sizeof(trgm) ) extern float4 trgm_limit; -TRGM* generate_trgm(char *str, int slen); -float4 cnt_sml(TRGM *trg1, TRGM *trg2); +TRGM *generate_trgm(char *str, int slen); +float4 cnt_sml(TRGM * trg1, TRGM * trg2); #endif diff --git a/contrib/pg_trgm/trgm_gist.c b/contrib/pg_trgm/trgm_gist.c index 6f30a44244..3ae8f4b3aa 100644 --- a/contrib/pg_trgm/trgm_gist.c +++ b/contrib/pg_trgm/trgm_gist.c @@ -71,12 +71,13 @@ makesign(BITVECP sign, TRGM * a) int4 k, len = ARRNELEM(a); trgm *ptr = GETARR(a); - int4 tmp=0; + int4 tmp = 0; MemSet((void *) sign, 0, sizeof(BITVEC)); - SETBIT(sign, SIGLENBIT); /*set last unused bit*/ - for (k = 0; k < len; k++) { - CPTRGM( ((char*)&tmp), ptr+k ); + SETBIT(sign, SIGLENBIT); /* set last unused bit */ + for (k = 0; k < len; k++) + { + CPTRGM(((char *) &tmp), ptr + k); HASH(sign, tmp); } } @@ -89,7 +90,7 @@ gtrgm_compress(PG_FUNCTION_ARGS) if (entry->leafkey) { /* trgm */ - TRGM *res; + TRGM *res; text *toastedval = (text *) DatumGetPointer(entry->key); text *val = (text *) DatumGetPointer(PG_DETOAST_DATUM(entry->key)); @@ -107,7 +108,7 @@ gtrgm_compress(PG_FUNCTION_ARGS) { int4 i, len; - TRGM *res; + TRGM *res; BITVECP sign = GETSIGN(DatumGetPointer(entry->key)); LOOPBYTE( @@ -137,37 +138,45 @@ gtrgm_decompress(PG_FUNCTION_ARGS) Datum gtrgm_consistent(PG_FUNCTION_ARGS) { - text *query = (text *) PG_GETARG_TEXT_P(1); - TRGM *key = (TRGM *) DatumGetPointer( ((GISTENTRY *) PG_GETARG_POINTER(0))->key ); - TRGM *qtrg = generate_trgm(VARDATA(query), VARSIZE(query) - VARHDRSZ); - int res=false; - - if ( GIST_LEAF( (GISTENTRY *) PG_GETARG_POINTER(0) ) ) { /* all leafs contains orig trgm */ - float4 tmpsml = cnt_sml(key,qtrg); - /* strange bug at freebsd 5.2.1 and gcc 3.3.3 */ - res = ( *(int*)&tmpsml==*(int*)&trgm_limit || tmpsml > trgm_limit ) ? true : false; - } else if ( ISALLTRUE(key) ) { /* non-leaf contains signature */ + text *query = (text *) PG_GETARG_TEXT_P(1); + TRGM *key = (TRGM *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); + TRGM *qtrg = generate_trgm(VARDATA(query), VARSIZE(query) - VARHDRSZ); + int res = false; + + if (GIST_LEAF((GISTENTRY *) PG_GETARG_POINTER(0))) + { /* all leafs contains orig trgm */ + float4 tmpsml = cnt_sml(key, qtrg); + + /* strange bug at freebsd 5.2.1 and gcc 3.3.3 */ + res = (*(int *) &tmpsml == *(int *) &trgm_limit || tmpsml > trgm_limit) ? true : false; + } + else if (ISALLTRUE(key)) + { /* non-leaf contains signature */ res = true; - } else { /* non-leaf contains signature */ - int4 count=0; - int4 k, len = ARRNELEM(qtrg); + } + else + { /* non-leaf contains signature */ + int4 count = 0; + int4 k, + len = ARRNELEM(qtrg); trgm *ptr = GETARR(qtrg); - BITVECP sign = GETSIGN(key); - int4 tmp=0; + BITVECP sign = GETSIGN(key); + int4 tmp = 0; - for (k = 0; k < len; k++) { - CPTRGM( ((char*)&tmp), ptr+k ); + for (k = 0; k < len; k++) + { + CPTRGM(((char *) &tmp), ptr + k); count += GETBIT(sign, HASHVAL(tmp)); } #ifdef DIVUNION - res = ( len==count ) ? true : ( ( ( ( ((float4)count) / ((float4)(len-count)) ) ) >= trgm_limit ) ? true : false ); + res = (len == count) ? true : ((((((float4) count) / ((float4) (len - count)))) >= trgm_limit) ? true : false); #else - res = (len==0) ? false : ( ( ( ( ((float4)count) / ((float4)len) ) ) >= trgm_limit ) ? true : false ); + res = (len == 0) ? false : ((((((float4) count) / ((float4) len))) >= trgm_limit) ? true : false); #endif } - PG_FREE_IF_COPY(query,1); - pfree(qtrg); + PG_FREE_IF_COPY(query, 1); + pfree(qtrg); PG_RETURN_BOOL(res); } @@ -191,10 +200,11 @@ unionkey(BITVECP sbase, TRGM * add) else { trgm *ptr = GETARR(add); - int4 tmp=0; + int4 tmp = 0; - for (i = 0; i < ARRNELEM(add); i++) { - CPTRGM( ((char*)&tmp), ptr+i ); + for (i = 0; i < ARRNELEM(add); i++) + { + CPTRGM(((char *) &tmp), ptr + i); HASH(sbase, tmp); } } @@ -205,13 +215,13 @@ unionkey(BITVECP sbase, TRGM * add) Datum gtrgm_union(PG_FUNCTION_ARGS) { - GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); - int4 len = entryvec->n; + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + int4 len = entryvec->n; int *size = (int *) PG_GETARG_POINTER(1); BITVEC base; int4 i; int4 flag = 0; - TRGM *result; + TRGM *result; MemSet((void *) base, 0, sizeof(BITVEC)); for (i = 0; i < len; i++) @@ -237,8 +247,8 @@ gtrgm_union(PG_FUNCTION_ARGS) Datum gtrgm_same(PG_FUNCTION_ARGS) { - TRGM *a = (TRGM *) PG_GETARG_POINTER(0); - TRGM *b = (TRGM *) PG_GETARG_POINTER(1); + TRGM *a = (TRGM *) PG_GETARG_POINTER(0); + TRGM *b = (TRGM *) PG_GETARG_POINTER(1); bool *result = (bool *) PG_GETARG_POINTER(2); if (ISSIGNKEY(a)) @@ -280,7 +290,7 @@ gtrgm_same(PG_FUNCTION_ARGS) *result = true; for (i = 0; i < lena; i++) - if (CMPTRGM(ptra+i, ptrb+i)) + if (CMPTRGM(ptra + i, ptrb + i)) { *result = false; break; @@ -298,34 +308,39 @@ sizebitvec(BITVECP sign) i; LOOPBYTE( - size += SUMBIT(*(char *) sign); - sign = (BITVECP) (((char *) sign) + 1); + size += SUMBIT(*(char *) sign); + sign = (BITVECP) (((char *) sign) + 1); ); return size; } static int -hemdistsign(BITVECP a, BITVECP b) { - int i,dist=0; +hemdistsign(BITVECP a, BITVECP b) +{ + int i, + dist = 0; LOOPBIT( - if ( GETBIT(a,i) != GETBIT(b,i) ) + if (GETBIT(a, i) != GETBIT(b, i)) dist++; ); return dist; } static int -hemdist(TRGM *a, TRGM *b) { - if ( ISALLTRUE(a) ) { +hemdist(TRGM * a, TRGM * b) +{ + if (ISALLTRUE(a)) + { if (ISALLTRUE(b)) return 0; else - return SIGLENBIT-sizebitvec(GETSIGN(b)); - } else if (ISALLTRUE(b)) - return SIGLENBIT-sizebitvec(GETSIGN(a)); + return SIGLENBIT - sizebitvec(GETSIGN(b)); + } + else if (ISALLTRUE(b)) + return SIGLENBIT - sizebitvec(GETSIGN(a)); - return hemdistsign( GETSIGN(a), GETSIGN(b) ); + return hemdistsign(GETSIGN(a), GETSIGN(b)); } Datum @@ -334,23 +349,25 @@ gtrgm_penalty(PG_FUNCTION_ARGS) GISTENTRY *origentry = (GISTENTRY *) PG_GETARG_POINTER(0); /* always ISSIGNKEY */ GISTENTRY *newentry = (GISTENTRY *) PG_GETARG_POINTER(1); float *penalty = (float *) PG_GETARG_POINTER(2); - TRGM *origval = (TRGM *) DatumGetPointer(origentry->key); - TRGM *newval = (TRGM *) DatumGetPointer(newentry->key); + TRGM *origval = (TRGM *) DatumGetPointer(origentry->key); + TRGM *newval = (TRGM *) DatumGetPointer(newentry->key); BITVECP orig = GETSIGN(origval); *penalty = 0.0; - if (ISARRKEY(newval)) { - BITVEC sign; + if (ISARRKEY(newval)) + { + BITVEC sign; + makesign(sign, newval); - if ( ISALLTRUE(origval) ) - *penalty=((float)(SIGLENBIT-sizebitvec(sign)))/(float)(SIGLENBIT+1); - else - *penalty=hemdistsign(sign,orig); - } else { - *penalty=hemdist(origval,newval); + if (ISALLTRUE(origval)) + *penalty = ((float) (SIGLENBIT - sizebitvec(sign))) / (float) (SIGLENBIT + 1); + else + *penalty = hemdistsign(sign, orig); } + else + *penalty = hemdist(origval, newval); PG_RETURN_POINTER(penalty); } @@ -390,27 +407,30 @@ comparecost(const void *a, const void *b) static int -hemdistcache(CACHESIGN *a, CACHESIGN *b) { - if ( a->allistrue ) { +hemdistcache(CACHESIGN * a, CACHESIGN * b) +{ + if (a->allistrue) + { if (b->allistrue) return 0; else - return SIGLENBIT-sizebitvec(b->sign); - } else if (b->allistrue) - return SIGLENBIT-sizebitvec(a->sign); + return SIGLENBIT - sizebitvec(b->sign); + } + else if (b->allistrue) + return SIGLENBIT - sizebitvec(a->sign); - return hemdistsign( a->sign, b->sign ); + return hemdistsign(a->sign, b->sign); } Datum gtrgm_picksplit(PG_FUNCTION_ARGS) { - GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); - OffsetNumber maxoff = entryvec->n - 2; + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + OffsetNumber maxoff = entryvec->n - 2; GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1); OffsetNumber k, j; - TRGM *datum_l, + TRGM *datum_l, *datum_r; BITVECP union_l, union_r; @@ -435,13 +455,16 @@ gtrgm_picksplit(PG_FUNCTION_ARGS) cache = (CACHESIGN *) palloc(sizeof(CACHESIGN) * (maxoff + 2)); fillcache(&cache[FirstOffsetNumber], GETENTRY(entryvec, FirstOffsetNumber)); - for (k = FirstOffsetNumber; k < maxoff; k = OffsetNumberNext(k)) { - for (j = OffsetNumberNext(k); j <= maxoff; j = OffsetNumberNext(j)) { + for (k = FirstOffsetNumber; k < maxoff; k = OffsetNumberNext(k)) + { + for (j = OffsetNumberNext(k); j <= maxoff; j = OffsetNumberNext(j)) + { if (k == FirstOffsetNumber) fillcache(&cache[j], GETENTRY(entryvec, j)); - size_waste=hemdistcache(&(cache[j]),&(cache[k])); - if (size_waste > waste) { + size_waste = hemdistcache(&(cache[j]), &(cache[k])); + if (size_waste > waste) + { waste = size_waste; seed_1 = k; seed_2 = j; @@ -454,101 +477,124 @@ gtrgm_picksplit(PG_FUNCTION_ARGS) right = v->spl_right; v->spl_nright = 0; - if (seed_1 == 0 || seed_2 == 0) { + if (seed_1 == 0 || seed_2 == 0) + { seed_1 = 1; seed_2 = 2; } /* form initial .. */ - if (cache[seed_1].allistrue) { + if (cache[seed_1].allistrue) + { datum_l = (TRGM *) palloc(CALCGTSIZE(SIGNKEY | ALLISTRUE, 0)); datum_l->len = CALCGTSIZE(SIGNKEY | ALLISTRUE, 0); datum_l->flag = SIGNKEY | ALLISTRUE; - } else { + } + else + { datum_l = (TRGM *) palloc(CALCGTSIZE(SIGNKEY, 0)); datum_l->len = CALCGTSIZE(SIGNKEY, 0); datum_l->flag = SIGNKEY; memcpy((void *) GETSIGN(datum_l), (void *) cache[seed_1].sign, sizeof(BITVEC)); } - if (cache[seed_2].allistrue) { + if (cache[seed_2].allistrue) + { datum_r = (TRGM *) palloc(CALCGTSIZE(SIGNKEY | ALLISTRUE, 0)); datum_r->len = CALCGTSIZE(SIGNKEY | ALLISTRUE, 0); datum_r->flag = SIGNKEY | ALLISTRUE; - } else { + } + else + { datum_r = (TRGM *) palloc(CALCGTSIZE(SIGNKEY, 0)); datum_r->len = CALCGTSIZE(SIGNKEY, 0); datum_r->flag = SIGNKEY; memcpy((void *) GETSIGN(datum_r), (void *) cache[seed_2].sign, sizeof(BITVEC)); } - union_l=GETSIGN(datum_l); - union_r=GETSIGN(datum_r); + union_l = GETSIGN(datum_l); + union_r = GETSIGN(datum_r); maxoff = OffsetNumberNext(maxoff); fillcache(&cache[maxoff], GETENTRY(entryvec, maxoff)); /* sort before ... */ costvector = (SPLITCOST *) palloc(sizeof(SPLITCOST) * maxoff); - for (j = FirstOffsetNumber; j <= maxoff; j = OffsetNumberNext(j)) { + for (j = FirstOffsetNumber; j <= maxoff; j = OffsetNumberNext(j)) + { costvector[j - 1].pos = j; size_alpha = hemdistcache(&(cache[seed_1]), &(cache[j])); - size_beta = hemdistcache(&(cache[seed_2]), &(cache[j])); + size_beta = hemdistcache(&(cache[seed_2]), &(cache[j])); costvector[j - 1].cost = abs(size_alpha - size_beta); } qsort((void *) costvector, maxoff, sizeof(SPLITCOST), comparecost); - for (k = 0; k < maxoff; k++) { + for (k = 0; k < maxoff; k++) + { j = costvector[k].pos; - if (j == seed_1) { + if (j == seed_1) + { *left++ = j; v->spl_nleft++; continue; - } else if (j == seed_2) { + } + else if (j == seed_2) + { *right++ = j; v->spl_nright++; continue; } - if (ISALLTRUE(datum_l) || cache[j].allistrue) { - if ( ISALLTRUE(datum_l) && cache[j].allistrue ) - size_alpha=0; + if (ISALLTRUE(datum_l) || cache[j].allistrue) + { + if (ISALLTRUE(datum_l) && cache[j].allistrue) + size_alpha = 0; else - size_alpha = SIGLENBIT-sizebitvec( - ( cache[j].allistrue ) ? GETSIGN(datum_l) : GETSIGN(cache[j].sign) - ); - } else { - size_alpha=hemdistsign(cache[j].sign,GETSIGN(datum_l)); + size_alpha = SIGLENBIT - sizebitvec( + (cache[j].allistrue) ? GETSIGN(datum_l) : GETSIGN(cache[j].sign) + ); } + else + size_alpha = hemdistsign(cache[j].sign, GETSIGN(datum_l)); - if (ISALLTRUE(datum_r) || cache[j].allistrue) { - if ( ISALLTRUE(datum_r) && cache[j].allistrue ) - size_beta=0; + if (ISALLTRUE(datum_r) || cache[j].allistrue) + { + if (ISALLTRUE(datum_r) && cache[j].allistrue) + size_beta = 0; else - size_beta = SIGLENBIT-sizebitvec( - ( cache[j].allistrue ) ? GETSIGN(datum_r) : GETSIGN(cache[j].sign) - ); - } else { - size_beta=hemdistsign(cache[j].sign,GETSIGN(datum_r)); + size_beta = SIGLENBIT - sizebitvec( + (cache[j].allistrue) ? GETSIGN(datum_r) : GETSIGN(cache[j].sign) + ); } + else + size_beta = hemdistsign(cache[j].sign, GETSIGN(datum_r)); - if (size_alpha < size_beta + WISH_F(v->spl_nleft, v->spl_nright, 0.1)) { - if (ISALLTRUE(datum_l) || cache[j].allistrue) { - if (! ISALLTRUE(datum_l) ) + if (size_alpha < size_beta + WISH_F(v->spl_nleft, v->spl_nright, 0.1)) + { + if (ISALLTRUE(datum_l) || cache[j].allistrue) + { + if (!ISALLTRUE(datum_l)) MemSet((void *) GETSIGN(datum_l), 0xff, sizeof(BITVEC)); - } else { - ptr=cache[j].sign; + } + else + { + ptr = cache[j].sign; LOOPBYTE( - union_l[i] |= ptr[i]; + union_l[i] |= ptr[i]; ); } *left++ = j; v->spl_nleft++; - } else { - if (ISALLTRUE(datum_r) || cache[j].allistrue) { - if (! ISALLTRUE(datum_r) ) + } + else + { + if (ISALLTRUE(datum_r) || cache[j].allistrue) + { + if (!ISALLTRUE(datum_r)) MemSet((void *) GETSIGN(datum_r), 0xff, sizeof(BITVEC)); - } else { - ptr=cache[j].sign; + } + else + { + ptr = cache[j].sign; LOOPBYTE( - union_r[i] |= ptr[i]; + union_r[i] |= ptr[i]; ); } *right++ = j; diff --git a/contrib/pg_trgm/trgm_op.c b/contrib/pg_trgm/trgm_op.c index 01ece90cdf..57fb944a56 100644 --- a/contrib/pg_trgm/trgm_op.c +++ b/contrib/pg_trgm/trgm_op.c @@ -3,136 +3,162 @@ #include "utils/array.h" #include "catalog/pg_type.h" -float4 trgm_limit = 0.3; +float4 trgm_limit = 0.3; PG_FUNCTION_INFO_V1(set_limit); -Datum set_limit(PG_FUNCTION_ARGS); +Datum set_limit(PG_FUNCTION_ARGS); Datum -set_limit(PG_FUNCTION_ARGS) { - float4 nlimit = PG_GETARG_FLOAT4(0); - if ( nlimit < 0 || nlimit > 1.0 ) - elog(ERROR,"Wrong limit, should be between 0 and 1"); +set_limit(PG_FUNCTION_ARGS) +{ + float4 nlimit = PG_GETARG_FLOAT4(0); + + if (nlimit < 0 || nlimit > 1.0) + elog(ERROR, "Wrong limit, should be between 0 and 1"); trgm_limit = nlimit; PG_RETURN_FLOAT4(trgm_limit); } PG_FUNCTION_INFO_V1(show_limit); -Datum show_limit(PG_FUNCTION_ARGS); +Datum show_limit(PG_FUNCTION_ARGS); Datum -show_limit(PG_FUNCTION_ARGS) { +show_limit(PG_FUNCTION_ARGS) +{ PG_RETURN_FLOAT4(trgm_limit); } -#define WORDWAIT 0 -#define INWORD 1 +#define WORDWAIT 0 +#define INWORD 1 static int -comp_trgm(const void *a, const void *b) { - return CMPTRGM(a,b); +comp_trgm(const void *a, const void *b) +{ + return CMPTRGM(a, b); } static int -unique_array (trgm *a, int len) { - trgm *curend, *tmp; +unique_array(trgm * a, int len) +{ + trgm *curend, + *tmp; curend = tmp = a; while (tmp - a < len) - if ( CMPTRGM(tmp, curend) ) { + if (CMPTRGM(tmp, curend)) + { curend++; - CPTRGM(curend,tmp); + CPTRGM(curend, tmp); tmp++; - } else + } + else tmp++; - + return curend + 1 - a; } -TRGM* -generate_trgm(char *str, int slen) { - TRGM* trg; - char *buf,*sptr,*bufptr; - trgm *tptr; - int state=WORDWAIT; - int wl,len; +TRGM * +generate_trgm(char *str, int slen) +{ + TRGM *trg; + char *buf, + *sptr, + *bufptr; + trgm *tptr; + int state = WORDWAIT; + int wl, + len; - trg = (TRGM*) palloc(TRGMHRDSIZE+sizeof(trgm) * (slen/2 + 1) * 3); + trg = (TRGM *) palloc(TRGMHRDSIZE + sizeof(trgm) * (slen / 2 + 1) * 3); trg->flag = ARRKEY; trg->len = TRGMHRDSIZE; - if ( slen+LPADDING+RPADDING<3 || slen == 0 ) + if (slen + LPADDING + RPADDING < 3 || slen == 0) return trg; tptr = GETARR(trg); - buf = palloc(sizeof(char) * (slen+4)); + buf = palloc(sizeof(char) * (slen + 4)); sptr = str; - if ( LPADDING > 0 ) { + if (LPADDING > 0) + { *buf = ' '; - if ( LPADDING > 1 ) - *(buf+1) = ' '; + if (LPADDING > 1) + *(buf + 1) = ' '; } - bufptr = buf+LPADDING; - while( sptr-str < slen ) { - if ( state == WORDWAIT ) { - if ( + bufptr = buf + LPADDING; + while (sptr - str < slen) + { + if (state == WORDWAIT) + { + if ( #ifdef KEEPONLYALNUM - isalnum((unsigned char)*sptr) + isalnum((unsigned char) *sptr) #else - !isspace( (unsigned char)*sptr ) + !isspace((unsigned char) *sptr) #endif - ) { - *bufptr = *sptr; /* start put word in buffer */ + ) + { + *bufptr = *sptr; /* start put word in buffer */ bufptr++; state = INWORD; - if ( sptr-str == slen-1 /* last char */ ) + if (sptr - str == slen - 1 /* last char */ ) goto gettrg; } - } else { + } + else + { if ( #ifdef KEEPONLYALNUM - !isalnum((unsigned char)*sptr) + !isalnum((unsigned char) *sptr) #else - isspace( (unsigned char)*sptr ) + isspace((unsigned char) *sptr) #endif - ) { -gettrg: + ) + { + gettrg: /* word in buffer, so count trigrams */ *bufptr = ' '; - *(bufptr+1) = ' '; - wl = bufptr - (buf+LPADDING) - 2 + LPADDING + RPADDING; - if ( wl<=0 ) { - bufptr = buf+LPADDING; + *(bufptr + 1) = ' '; + wl = bufptr - (buf + LPADDING) - 2 + LPADDING + RPADDING; + if (wl <= 0) |