diff options
author | Bruce Momjian | 2001-03-22 04:01:46 +0000 |
---|---|---|
committer | Bruce Momjian | 2001-03-22 04:01:46 +0000 |
commit | 9e1552607a9dc6bc23e43d46770a9063ade4f3f0 (patch) | |
tree | 6a230d81917ebc004e40cd46c48f2aa27eec153e | |
parent | 6cf8707b828b14b5c2336076ce358b18b67829d6 (diff) |
pgindent run. Make it all clean.
555 files changed, 32742 insertions, 28338 deletions
diff --git a/contrib/cube/buffer.c b/contrib/cube/buffer.c index 0bcc2d19b5..bab7ae303c 100644 --- a/contrib/cube/buffer.c +++ b/contrib/cube/buffer.c @@ -4,76 +4,81 @@ #include "utils/elog.h" -static char * PARSE_BUFFER; -static char * PARSE_BUFFER_PTR; -static unsigned int PARSE_BUFFER_SIZE; +static char *PARSE_BUFFER; +static char *PARSE_BUFFER_PTR; +static unsigned int PARSE_BUFFER_SIZE; static unsigned int SCANNER_POS; -void set_parse_buffer( char* s ); -void reset_parse_buffer( void ); -int read_parse_buffer( void ); -char * parse_buffer( void ); -char * parse_buffer_ptr( void ); -unsigned int parse_buffer_curr_char( void ); -unsigned int parse_buffer_size( void ); -unsigned int parse_buffer_pos( void ); +void set_parse_buffer(char *s); +void reset_parse_buffer(void); +int read_parse_buffer(void); +char *parse_buffer(void); +char *parse_buffer_ptr(void); +unsigned int parse_buffer_curr_char(void); +unsigned int parse_buffer_size(void); +unsigned int parse_buffer_pos(void); -extern void cube_flush_scanner_buffer(void); /* defined in cubescan.l */ +extern void cube_flush_scanner_buffer(void); /* defined in cubescan.l */ -void set_parse_buffer( char* s ) +void +set_parse_buffer(char *s) { - PARSE_BUFFER = s; - PARSE_BUFFER_SIZE = strlen(s); - if ( PARSE_BUFFER_SIZE == 0 ) { - elog(ERROR, "cube_in: can't parse an empty string"); - } - PARSE_BUFFER_PTR = PARSE_BUFFER; - SCANNER_POS = 0; + PARSE_BUFFER = s; + PARSE_BUFFER_SIZE = strlen(s); + if (PARSE_BUFFER_SIZE == 0) + elog(ERROR, "cube_in: can't parse an empty string"); + PARSE_BUFFER_PTR = PARSE_BUFFER; + SCANNER_POS = 0; } -void reset_parse_buffer( void ) +void +reset_parse_buffer(void) { - PARSE_BUFFER_PTR = PARSE_BUFFER; - SCANNER_POS = 0; - cube_flush_scanner_buffer(); + PARSE_BUFFER_PTR = PARSE_BUFFER; + SCANNER_POS = 0; + cube_flush_scanner_buffer(); } -int read_parse_buffer( void ) +int +read_parse_buffer(void) { - int c; - /* - c = *PARSE_BUFFER_PTR++; - SCANNER_POS++; - */ - c = PARSE_BUFFER[SCANNER_POS]; - if(SCANNER_POS < PARSE_BUFFER_SIZE) - SCANNER_POS++; - return c; + int c; + + /* + * c = *PARSE_BUFFER_PTR++; SCANNER_POS++; + */ + c = PARSE_BUFFER[SCANNER_POS]; + if (SCANNER_POS < PARSE_BUFFER_SIZE) + SCANNER_POS++; + return c; } -char * parse_buffer( void ) +char * +parse_buffer(void) { - return PARSE_BUFFER; + return PARSE_BUFFER; } -unsigned int parse_buffer_curr_char( void ) +unsigned int +parse_buffer_curr_char(void) { - return PARSE_BUFFER[SCANNER_POS]; + return PARSE_BUFFER[SCANNER_POS]; } -char * parse_buffer_ptr( void ) +char * +parse_buffer_ptr(void) { - return PARSE_BUFFER_PTR; + return PARSE_BUFFER_PTR; } -unsigned int parse_buffer_pos( void ) +unsigned int +parse_buffer_pos(void) { - return SCANNER_POS; + return SCANNER_POS; } -unsigned int parse_buffer_size( void ) +unsigned int +parse_buffer_size(void) { - return PARSE_BUFFER_SIZE; + return PARSE_BUFFER_SIZE; } - - diff --git a/contrib/cube/buffer.h b/contrib/cube/buffer.h index fd41a7b69b..eef9124dac 100644 --- a/contrib/cube/buffer.h +++ b/contrib/cube/buffer.h @@ -1,8 +1,8 @@ -extern void set_parse_buffer( char* s ); -extern void reset_parse_buffer( void ); -extern int read_parse_buffer( void ); -extern char * parse_buffer( void ); -extern char * parse_buffer_ptr( void ); -extern unsigned int parse_buffer_curr_char( void ); -extern unsigned int parse_buffer_pos( void ); -extern unsigned int parse_buffer_size( void ); +extern void set_parse_buffer(char *s); +extern void reset_parse_buffer(void); +extern int read_parse_buffer(void); +extern char *parse_buffer(void); +extern char *parse_buffer_ptr(void); +extern unsigned int parse_buffer_curr_char(void); +extern unsigned int parse_buffer_pos(void); +extern unsigned int parse_buffer_size(void); diff --git a/contrib/cube/cube.c b/contrib/cube/cube.c index 35ac34f0b0..4d6169a480 100644 --- a/contrib/cube/cube.c +++ b/contrib/cube/cube.c @@ -16,67 +16,67 @@ #include "cubedata.h" -#define max(a,b) ((a) > (b) ? (a) : (b)) -#define min(a,b) ((a) <= (b) ? (a) : (b)) -#define abs(a) ((a) < (0) ? (-a) : (a)) +#define max(a,b) ((a) > (b) ? (a) : (b)) +#define min(a,b) ((a) <= (b) ? (a) : (b)) +#define abs(a) ((a) < (0) ? (-a) : (a)) -extern void set_parse_buffer(char *str); -extern int cube_yyparse(); +extern void set_parse_buffer(char *str); +extern int cube_yyparse(); /* ** Input/Output routines */ -NDBOX * cube_in(char *str); -char * cube_out(NDBOX *cube); +NDBOX *cube_in(char *str); +char *cube_out(NDBOX * cube); -/* +/* ** GiST support methods */ -bool g_cube_consistent(GISTENTRY *entry, NDBOX *query, StrategyNumber strategy); -GISTENTRY * g_cube_compress(GISTENTRY *entry); -GISTENTRY * g_cube_decompress(GISTENTRY *entry); -float * g_cube_penalty(GISTENTRY *origentry, GISTENTRY *newentry, float *result); -GIST_SPLITVEC * g_cube_picksplit(bytea *entryvec, GIST_SPLITVEC *v); -bool g_cube_leaf_consistent(NDBOX *key, NDBOX *query, StrategyNumber strategy); -bool g_cube_internal_consistent(NDBOX *key, NDBOX *query, StrategyNumber strategy); -NDBOX * g_cube_union(bytea *entryvec, int *sizep); -NDBOX * g_cube_binary_union(NDBOX *r1, NDBOX *r2, int *sizep); -bool * g_cube_same(NDBOX *b1, NDBOX *b2, bool *result); +bool g_cube_consistent(GISTENTRY *entry, NDBOX * query, StrategyNumber strategy); +GISTENTRY *g_cube_compress(GISTENTRY *entry); +GISTENTRY *g_cube_decompress(GISTENTRY *entry); +float *g_cube_penalty(GISTENTRY *origentry, GISTENTRY *newentry, float *result); +GIST_SPLITVEC *g_cube_picksplit(bytea *entryvec, GIST_SPLITVEC *v); +bool g_cube_leaf_consistent(NDBOX * key, NDBOX * query, StrategyNumber strategy); +bool g_cube_internal_consistent(NDBOX * key, NDBOX * query, StrategyNumber strategy); +NDBOX *g_cube_union(bytea *entryvec, int *sizep); +NDBOX *g_cube_binary_union(NDBOX * r1, NDBOX * r2, int *sizep); +bool *g_cube_same(NDBOX * b1, NDBOX * b2, bool *result); /* ** R-tree suport functions */ -bool cube_same(NDBOX *a, NDBOX *b); -bool cube_different(NDBOX *a, NDBOX *b); -bool cube_contains(NDBOX *a, NDBOX *b); -bool cube_contained (NDBOX *a, NDBOX *b); -bool cube_overlap(NDBOX *a, NDBOX *b); -NDBOX * cube_union(NDBOX *a, NDBOX *b); -NDBOX * cube_inter(NDBOX *a, NDBOX *b); -float * cube_size(NDBOX *a); -void rt_cube_size(NDBOX *a, float *sz); +bool cube_same(NDBOX * a, NDBOX * b); +bool cube_different(NDBOX * a, NDBOX * b); +bool cube_contains(NDBOX * a, NDBOX * b); +bool cube_contained(NDBOX * a, NDBOX * b); +bool cube_overlap(NDBOX * a, NDBOX * b); +NDBOX *cube_union(NDBOX * a, NDBOX * b); +NDBOX *cube_inter(NDBOX * a, NDBOX * b); +float *cube_size(NDBOX * a); +void rt_cube_size(NDBOX * a, float *sz); /* ** These make no sense for this type, but R-tree wants them */ -bool cube_over_left(NDBOX *a, NDBOX *b); -bool cube_over_right(NDBOX *a, NDBOX *b); -bool cube_left(NDBOX *a, NDBOX *b); -bool cube_right(NDBOX *a, NDBOX *b); +bool cube_over_left(NDBOX * a, NDBOX * b); +bool cube_over_right(NDBOX * a, NDBOX * b); +bool cube_left(NDBOX * a, NDBOX * b); +bool cube_right(NDBOX * a, NDBOX * b); /* ** miscellaneous */ -bool cube_lt(NDBOX *a, NDBOX *b); -bool cube_gt(NDBOX *a, NDBOX *b); -float * cube_distance(NDBOX *a, NDBOX *b); +bool cube_lt(NDBOX * a, NDBOX * b); +bool cube_gt(NDBOX * a, NDBOX * b); +float *cube_distance(NDBOX * a, NDBOX * b); -/* +/* ** Auxiliary funxtions */ -static float distance_1D(float a1, float a2, float b1, float b2); -static NDBOX *swap_corners (NDBOX *a); +static float distance_1D(float a1, float a2, float b1, float b2); +static NDBOX *swap_corners(NDBOX * a); /***************************************************************************** @@ -88,68 +88,71 @@ static NDBOX *swap_corners (NDBOX *a); NDBOX * cube_in(char *str) { - void * result; + void *result; - set_parse_buffer( str ); + set_parse_buffer(str); - if ( cube_yyparse(&result) != 0 ) { - return NULL; - } + if (cube_yyparse(&result) != 0) + return NULL; - return ( (NDBOX *)result ); + return ((NDBOX *) result); } /* * You might have noticed a slight inconsistency between the following * declaration and the SQL definition: - * CREATE FUNCTION cube_out(opaque) RETURNS opaque ... + * CREATE FUNCTION cube_out(opaque) RETURNS opaque ... * The reason is that the argument pass into cube_out is really just a * pointer. POSTGRES thinks all output functions are: - * char *out_func(char *); + * char *out_func(char *); */ char * -cube_out(NDBOX *cube) +cube_out(NDBOX * cube) { - char *result; - char *p; - int equal = 1; - int dim = cube->dim; - int i; - - if (cube == NULL) - return(NULL); - - p = result = (char *) palloc(100); - - /* while printing the first (LL) corner, check if it is equal - to the scond one */ - p += sprintf(p, "("); - for ( i=0; i < dim; i++ ) { - p += sprintf(p, "%g", cube->x[i]); - p += sprintf(p, ", "); - if ( cube->x[i] != cube->x[i+dim] ) { - equal = 0; - } - } - p -= 2; /* get rid of the last ", " */ - p += sprintf(p, ")"); - - if ( !equal ) { - p += sprintf(p, ",("); - for ( i=dim; i < dim * 2; i++ ) { - p += sprintf(p, "%g", cube->x[i]); - p += sprintf(p, ", "); - } - p -= 2; - p += sprintf(p, ")"); - } - - return(result); + char *result; + char *p; + int equal = 1; + int dim = cube->dim; + int i; + + if (cube == NULL) + return (NULL); + + p = result = (char *) palloc(100); + + /* + * while printing the first (LL) corner, check if it is equal to the + * scond one + */ + p += sprintf(p, "("); + for (i = 0; i < dim; i++) + { + p += sprintf(p, "%g", cube->x[i]); + p += sprintf(p, ", "); + if (cube->x[i] != cube->x[i + dim]) + equal = 0; + } + p -= 2; /* get rid of the last ", " */ + p += sprintf(p, ")"); + + if (!equal) + { + p += sprintf(p, ",("); + for (i = dim; i < dim * 2; i++) + { + p += sprintf(p, "%g", cube->x[i]); + p += sprintf(p, ", "); + } + p -= 2; + p += sprintf(p, ")"); + } + + return (result); } /***************************************************************************** - * GiST functions + * GiST functions *****************************************************************************/ /* @@ -158,19 +161,20 @@ cube_out(NDBOX *cube) ** the predicate x op query == FALSE, where op is the oper ** corresponding to strategy in the pg_amop table. */ -bool +bool g_cube_consistent(GISTENTRY *entry, - NDBOX *query, - StrategyNumber strategy) + NDBOX * query, + StrategyNumber strategy) { - /* - ** if entry is not leaf, use g_cube_internal_consistent, - ** else use g_cube_leaf_consistent - */ - if (GIST_LEAF(entry)) - return(g_cube_leaf_consistent((NDBOX *)(entry->pred), query, strategy)); - else - return(g_cube_internal_consistent((NDBOX *)(entry->pred), query, strategy)); + + /* + * * if entry is not leaf, use g_cube_internal_consistent, * else use + * g_cube_leaf_consistent + */ + if (GIST_LEAF(entry)) + return (g_cube_leaf_consistent((NDBOX *) (entry->pred), query, strategy)); + else + return (g_cube_internal_consistent((NDBOX *) (entry->pred), query, strategy)); } @@ -181,48 +185,55 @@ g_cube_consistent(GISTENTRY *entry, NDBOX * g_cube_union(bytea *entryvec, int *sizep) { - int numranges, i; - NDBOX *out = (NDBOX *)NULL; - NDBOX *tmp; - - /* - fprintf(stderr, "union\n"); - */ - numranges = (VARSIZE(entryvec) - VARHDRSZ)/sizeof(GISTENTRY); - tmp = (NDBOX *)(((GISTENTRY *)(VARDATA(entryvec)))[0]).pred; - /* - *sizep = sizeof(NDBOX); -- NDBOX has variable size - */ - *sizep = tmp->size; - - for (i = 1; i < numranges; i++) { - out = g_cube_binary_union(tmp, (NDBOX *) - (((GISTENTRY *)(VARDATA(entryvec)))[i]).pred, - sizep); - /* - fprintf(stderr, "\t%s ^ %s -> %s\n", cube_out(tmp), cube_out((NDBOX *)(((GISTENTRY *)(VARDATA(entryvec)))[i]).pred), cube_out(out)); - */ - if (i > 1) pfree(tmp); - tmp = out; - } - - return(out); + int numranges, + i; + NDBOX *out = (NDBOX *) NULL; + NDBOX *tmp; + + /* + * fprintf(stderr, "union\n"); + */ + numranges = (VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY); + tmp = (NDBOX *) (((GISTENTRY *) (VARDATA(entryvec)))[0]).pred; + + /* + * sizep = sizeof(NDBOX); -- NDBOX has variable size + */ + *sizep = tmp->size; + + for (i = 1; i < numranges; i++) + { + out = g_cube_binary_union(tmp, (NDBOX *) + (((GISTENTRY *) (VARDATA(entryvec)))[i]).pred, + sizep); + + /* + * fprintf(stderr, "\t%s ^ %s -> %s\n", cube_out(tmp), + * cube_out((NDBOX *)(((GISTENTRY + * *)(VARDATA(entryvec)))[i]).pred), cube_out(out)); + */ + if (i > 1) + pfree(tmp); + tmp = out; + } + + return (out); } /* ** GiST Compress and Decompress methods for boxes ** do not do anything. */ -GISTENTRY * +GISTENTRY * g_cube_compress(GISTENTRY *entry) { - return(entry); + return (entry); } -GISTENTRY * +GISTENTRY * g_cube_decompress(GISTENTRY *entry) { - return(entry); + return (entry); } /* @@ -232,398 +243,448 @@ g_cube_decompress(GISTENTRY *entry) float * g_cube_penalty(GISTENTRY *origentry, GISTENTRY *newentry, float *result) { - Datum ud; - float tmp1, tmp2; - - ud = (Datum)cube_union((NDBOX *)(origentry->pred), (NDBOX *)(newentry->pred)); - rt_cube_size((NDBOX *)ud, &tmp1); - rt_cube_size((NDBOX *)(origentry->pred), &tmp2); - *result = tmp1 - tmp2; - pfree((char *)ud); - /* - fprintf(stderr, "penalty\n"); - fprintf(stderr, "\t%g\n", *result); - */ - return(result); + Datum ud; + float tmp1, + tmp2; + + ud = (Datum) cube_union((NDBOX *) (origentry->pred), (NDBOX *) (newentry->pred)); + rt_cube_size((NDBOX *) ud, &tmp1); + rt_cube_size((NDBOX *) (origentry->pred), &tmp2); + *result = tmp1 - tmp2; + pfree((char *) ud); + + /* + * fprintf(stderr, "penalty\n"); fprintf(stderr, "\t%g\n", *result); + */ + return (result); } /* ** The GiST PickSplit method for boxes -** We use Guttman's poly time split algorithm +** We use Guttman's poly time split algorithm */ GIST_SPLITVEC * g_cube_picksplit(bytea *entryvec, - GIST_SPLITVEC *v) + GIST_SPLITVEC *v) { - OffsetNumber i, j; - NDBOX *datum_alpha, *datum_beta; - NDBOX *datum_l, *datum_r; - NDBOX *union_d, *union_dl, *union_dr; - NDBOX *inter_d; - bool firsttime; - float size_alpha, size_beta, size_union, size_inter; - float size_waste, waste; - float size_l, size_r; - int nbytes; - OffsetNumber seed_1 = 0, seed_2 = 0; - OffsetNumber *left, *right; - OffsetNumber maxoff; - - /* - fprintf(stderr, "picksplit\n"); - */ - maxoff = ((VARSIZE(entryvec) - VARHDRSZ)/sizeof(GISTENTRY)) - 2; - nbytes = (maxoff + 2) * sizeof(OffsetNumber); - v->spl_left = (OffsetNumber *) palloc(nbytes); - v->spl_right = (OffsetNumber *) palloc(nbytes); - - firsttime = true; - waste = 0.0; - - for (i = FirstOffsetNumber; i < maxoff; i = OffsetNumberNext(i)) { - datum_alpha = (NDBOX *)(((GISTENTRY *)(VARDATA(entryvec)))[i].pred); - for (j = OffsetNumberNext(i); j <= maxoff; j = OffsetNumberNext(j)) { - datum_beta = (NDBOX *)(((GISTENTRY *)(VARDATA(entryvec)))[j].pred); - - /* compute the wasted space by unioning these guys */ - /* size_waste = size_union - size_inter; */ - union_d = (NDBOX *)cube_union(datum_alpha, datum_beta); - rt_cube_size(union_d, &size_union); - inter_d = (NDBOX *)cube_inter(datum_alpha, datum_beta); - rt_cube_size(inter_d, &size_inter); - size_waste = size_union - size_inter; - - pfree(union_d); - - if (inter_d != (NDBOX *) NULL) - pfree(inter_d); - - /* - * are these a more promising split than what we've - * already seen? - */ - - if (size_waste > waste || firsttime) { - waste = size_waste; - seed_1 = i; - seed_2 = j; - firsttime = false; - } - } - } - - left = v->spl_left; - v->spl_nleft = 0; - right = v->spl_right; - v->spl_nright = 0; - - datum_alpha = (NDBOX *)(((GISTENTRY *)(VARDATA(entryvec)))[seed_1].pred); - datum_l = (NDBOX *)cube_union(datum_alpha, datum_alpha); - rt_cube_size((NDBOX *)datum_l, &size_l); - datum_beta = (NDBOX *)(((GISTENTRY *)(VARDATA(entryvec)))[seed_2].pred);; - datum_r = (NDBOX *)cube_union(datum_beta, datum_beta); - rt_cube_size((NDBOX *)datum_r, &size_r); - - /* - * Now split up the regions between the two seeds. An important - * property of this split algorithm is that the split vector v - * has the indices of items to be split in order in its left and - * right vectors. We exploit this property by doing a merge in - * the code that actually splits the page. - * - * For efficiency, we also place the new index tuple in this loop. - * This is handled at the very end, when we have placed all the - * existing tuples and i == maxoff + 1. - */ - - maxoff = OffsetNumberNext(maxoff); - for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) { - + OffsetNumber i, + j; + NDBOX *datum_alpha, + *datum_beta; + NDBOX *datum_l, + *datum_r; + NDBOX *union_d, + *union_dl, + *union_dr; + NDBOX *inter_d; + bool firsttime; + float size_alpha, + size_beta, + size_union, + size_inter; + float size_waste, + waste; + float size_l, + size_r; + int nbytes; + OffsetNumber seed_1 = 0, + seed_2 = 0; + OffsetNumber *left, + *right; + OffsetNumber maxoff; + /* - * If we've already decided where to place this item, just - * put it on the right list. Otherwise, we need to figure - * out which page needs the least enlargement in order to - * store the item. + * fprintf(stderr, "picksplit\n"); */ - - if (i == seed_1) { - *left++ = i; - v->spl_nleft++; - continue; - } else if (i == seed_2) { - *right++ = i; - v->spl_nright++; - continue; + maxoff = ((VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY)) - 2; + nbytes = (maxoff + 2) * sizeof(OffsetNumber); + v->spl_left = (OffsetNumber *) palloc(nbytes); + v->spl_right = (OffsetNumber *) palloc(nbytes); + + firsttime = true; + waste = 0.0; + + for (i = FirstOffsetNumber; i < maxoff; i = OffsetNumberNext(i)) + { + datum_alpha = (NDBOX *) (((GISTENTRY *) (VARDATA(entryvec)))[i].pred); + for (j = OffsetNumberNext(i); j <= maxoff; j = OffsetNumberNext(j)) + { + datum_beta = (NDBOX *) (((GISTENTRY *) (VARDATA(entryvec)))[j].pred); + + /* compute the wasted space by unioning these guys */ + /* size_waste = size_union - size_inter; */ + union_d = (NDBOX *) cube_union(datum_alpha, datum_beta); + rt_cube_size(union_d, &size_union); + inter_d = (NDBOX *) cube_inter(datum_alpha, datum_beta); + rt_cube_size(inter_d, &size_inter); + size_waste = size_union - size_inter; + + pfree(union_d); + + if (inter_d != (NDBOX *) NULL) + pfree(inter_d); + + /* + * are these a more promising split than what we've already + * seen? + */ + + if (size_waste > waste || firsttime) + { + waste = size_waste; + seed_1 = i; + seed_2 = j; + firsttime = false; + } + } } - - /* okay, which page needs least enlargement? */ - datum_alpha = (NDBOX *)(((GISTENTRY *)(VARDATA(entryvec)))[i].pred); - union_dl = (NDBOX *)cube_union(datum_l, datum_alpha); - union_dr = (NDBOX *)cube_union(datum_r, datum_alpha); - rt_cube_size((NDBOX *)union_dl, &size_alpha); - rt_cube_size((NDBOX *)union_dr, &size_beta); - - /* pick which page to add it to */ - if (size_alpha - size_l < size_beta - size_r) { - pfree(datum_l); - pfree(union_dr); - datum_l = union_dl; - size_l = size_alpha; - *left++ = i; - v->spl_nleft++; - } else { - pfree(datum_r); - pfree(union_dl); - datum_r = union_dr; - size_r = size_alpha; - *right++ = i; - v->spl_nright++; + + left = v->spl_left; + v->spl_nleft = 0; + right = v->spl_right; + v->spl_nright = 0; + + datum_alpha = (NDBOX *) (((GISTENTRY *) (VARDATA(entryvec)))[seed_1].pred); + datum_l = (NDBOX *) cube_union(datum_alpha, datum_alpha); + rt_cube_size((NDBOX *) datum_l, &size_l); + datum_beta = (NDBOX *) (((GISTENTRY *) (VARDATA(entryvec)))[seed_2].pred);; + datum_r = (NDBOX *) cube_union(datum_beta, datum_beta); + rt_cube_size((NDBOX *) datum_r, &size_r); + + /* + * Now split up the regions between the two seeds. An important + * property of this split algorithm is that the split vector v has the + * indices of items to be split in order in its left and right + * vectors. We exploit this property by doing a merge in the code + * that actually splits the page. + * + * For efficiency, we also place the new index tuple in this loop. This + * is handled at the very end, when we have placed all the existing + * tuples and i == maxoff + 1. + */ + + maxoff = OffsetNumberNext(maxoff); + for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) + { + + /* + * If we've already decided where to place this item, just put it + * on the right list. Otherwise, we need to figure out which page + * needs the least enlargement in order to store the item. + */ + + if (i == seed_1) + { + *left++ = i; + v->spl_nleft++; + continue; + } + else if (i == seed_2) + { + *right++ = i; + v->spl_nright++; + continue; + } + + /* okay, which page needs least enlargement? */ + datum_alpha = (NDBOX *) (((GISTENTRY *) (VARDATA(entryvec)))[i].pred); + union_dl = (NDBOX *) cube_union(datum_l, datum_alpha); + union_dr = (NDBOX *) cube_union(datum_r, datum_alpha); + rt_cube_size((NDBOX *) union_dl, &size_alpha); + rt_cube_size((NDBOX *) union_dr, &size_beta); + + /* pick which page to add it to */ + if (size_alpha - size_l < size_beta - size_r) + { + pfree(datum_l); + pfree(union_dr); + datum_l = union_dl; + size_l = size_alpha; + *left++ = i; + v->spl_nleft++; + } + else + { + pfree(datum_r); + pfree(union_dl); + datum_r = union_dr; + size_r = size_alpha; + *right++ = i; + v->spl_nright++; + } } - } - *left = *right = FirstOffsetNumber; /* sentinel value, see dosplit() */ - - v->spl_ldatum = (char *)datum_l; - v->spl_rdatum = (char *)datum_r; + *left = *right = FirstOffsetNumber; /* sentinel value, see dosplit() */ - return v; + v->spl_ldatum = (char *) datum_l; + v->spl_rdatum = (char *) datum_r; + + return v; } /* ** Equality method */ bool * -g_cube_same(NDBOX *b1, NDBOX *b2, bool *result) +g_cube_same(NDBOX * b1, NDBOX * b2, bool *result) { - if (cube_same(b1, b2)) - *result = TRUE; - else *result = FALSE; - /* - fprintf(stderr, "same: %s\n", (*result ? "TRUE" : "FALSE" )); - */ - return(result); + if (cube_same(b1, b2)) + *result = TRUE; + else + *result = FALSE; + + /* + * fprintf(stderr, "same: %s\n", (*result ? "TRUE" : "FALSE" )); + */ + return (result); } -/* +/* ** SUPPORT ROUTINES */ -bool -g_cube_leaf_consistent(NDBOX *key, - NDBOX *query, - StrategyNumber strategy) +bool +g_cube_leaf_consistent(NDBOX * key, + NDBOX * query, + StrategyNumber strategy) { - bool retval; - - /* - fprintf(stderr, "leaf_consistent, %d\n", strategy); - */ - switch(strategy) { - case RTLeftStrategyNumber: - retval = (bool)cube_left(key, query); - break; - case RTOverLeftStrategyNumber: - retval = (bool)cube_over_left(key,query); - break; - case RTOverlapStrategyNumber: - retval = (bool)cube_overlap(key, query); - break; - case RTOverRightStrategyNumber: - retval = (bool)cube_over_right(key, query); - break; - case RTRightStrategyNumber: - retval = (bool)cube_right(key, query); - break; - case RTSameStrategyNumber: - retval = (bool)cube_same(key, query); - break; - case RTContainsStrategyNumber: - retval = (bool)cube_contains(key, query); - break; - case RTContainedByStrategyNumber: - retval = (bool)cube_contained(key,query); - break; - default: - retval = FALSE; - } - return(retval); + bool retval; + + /* + * fprintf(stderr, "leaf_consistent, %d\n", strategy); + */ + switch (strategy) + { + case RTLeftStrategyNumber: + retval = (bool) cube_left(key, query); + break; + case RTOverLeftStrategyNumber: + retval = (bool) cube_over_left(key, query); + break; + case RTOverlapStrategyNumber: + retval = (bool) cube_overlap(key, query); + break; + case RTOverRightStrategyNumber: + retval = (bool) cube_over_right(key, query); + break; + case RTRightStrategyNumber: + retval = (bool) cube_right(key, query); + break; + case RTSameStrategyNumber: + retval = (bool) cube_same(key, query); + break; + case RTContainsStrategyNumber: + retval = (bool) cube_contains(key, query); + break; + case RTContainedByStrategyNumber: + retval = (bool) cube_contained(key, query); + break; + default: + retval = FALSE; + } + return (retval); } -bool -g_cube_internal_consistent(NDBOX *key, - NDBOX *query, - StrategyNumber strategy) +bool +g_cube_internal_consistent(NDBOX * key, + NDBOX * query, + StrategyNumber strategy) { - bool retval; - - /* - fprintf(stderr, "internal_consistent, %d\n", strategy); - */ - switch(strategy) { - case RTLeftStrategyNumber: - case RTOverLeftStrategyNumber: - retval = (bool)cube_over_left(key,query); - break; - case RTOverlapStrategyNumber: - retval = (bool)cube_overlap(key, query); - break; - case RTOverRightStrategyNumber: - case RTRightStrategyNumber: - retval = (bool)cube_right(key, query); - break; - case RTSameStrategyNumber: - case RTContainsStrategyNumber: - retval = (bool)cube_contains(key, query); - break; - case RTContainedByStrategyNumber: - retval = (bool)cube_overlap(key, query); - break; - default: - retval = FALSE; - } - return(retval); + bool retval; + + /* + * fprintf(stderr, "internal_consistent, %d\n", strategy); + */ + switch (strategy) + { + case RTLeftStrategyNumber: + case RTOverLeftStrategyNumber: + retval = (bool) cube_over_left(key, query); + break; + case RTOverlapStrategyNumber: + retval = (bool) cube_overlap(key, query); + break; + case RTOverRightStrategyNumber: + case RTRightStrategyNumber: + retval = (bool) cube_right(key, query); + break; + case RTSameStrategyNumber: + case RTContainsStrategyNumber: + retval = (bool) cube_contains(key, query); + break; + case RTContainedByStrategyNumber: + retval = (bool) cube_overlap(key, query); + break; + default: + retval = FALSE; + } + return (retval); } NDBOX * -g_cube_binary_union(NDBOX *r1, NDBOX *r2, int *sizep) +g_cube_binary_union(NDBOX * r1, NDBOX * r2, int *sizep) { - NDBOX *retval; + NDBOX *retval; - retval = cube_union(r1, r2); - *sizep = retval->size; + retval = cube_union(r1, r2); + *sizep = retval->size; - return (retval); + return (retval); } /* cube_union */ -NDBOX *cube_union(NDBOX *box_a, NDBOX *box_b) +NDBOX * +cube_union(NDBOX * box_a, NDBOX * box_b) { - int i; - NDBOX *result; - NDBOX *a = swap_corners(box_a); - NDBOX *b = swap_corners(box_b); - - if ( a->dim >= b->dim ) { - result = palloc(a->size); - result->size = a->size; - result->dim = a->dim; - } - else { - result = palloc(b->size); - result->size = b->size; - result->dim = b->dim; - } - - /* swap the box pointers if needed */ - if ( a->dim < b->dim ) { - NDBOX * tmp = b; b = a; a = tmp; - } - - /* use the potentially smaller of the two boxes (b) to fill in - the result, padding absent dimensions with zeroes*/ - for ( i = 0; i < b->dim; i++ ) { - result->x[i] = b->x[i]; - result->x[i + a->dim] = b->x[i + b->dim]; - } - for ( i = b->dim; i < a->dim; i++ ) { - result->x[i] = 0; - result->x[i + a->dim] = 0; - } - - /* compute the union */ - for ( i = 0; i < a->dim; i++ ) { - result->x[i] = min(a->x[i], result->x[i]); - } - for ( i = a->dim; i < a->dim * 2; i++ ) { - result->x[i] = max(a->x[i], result->x[i]); - } - - pfree(a); - pfree(b); - - return(result); + int i; + NDBOX *result; + NDBOX *a = swap_corners(box_a); + NDBOX *b = swap_corners(box_b); + + if (a->dim >= b->dim) + { + result = palloc(a->size); + result->size = a->size; + result->dim = a->dim; + } + else + { + result = palloc(b->size); + result->size = b->size; + result->dim = b->dim; + } + + /* swap the box pointers if needed */ + if (a->dim < b->dim) + { + NDBOX *tmp = b; + + b = a; + a = tmp; + } + + /* + * use the potentially smaller of the two boxes (b) to fill in the + * result, padding absent dimensions with zeroes + */ + for (i = 0; i < b->dim; i++) + { + result->x[i] = b->x[i]; + result->x[i + a->dim] = b->x[i + b->dim]; + } + for (i = b->dim; i < a->dim; i++) + { + result->x[i] = 0; + result->x[i + a->dim] = 0; + } + + /* compute the union */ + for (i = 0; i < a->dim; i++) + result->x[i] = min(a->x[i], result->x[i]); + for (i = a->dim; i < a->dim * 2; i++) + result->x[i] = max(a->x[i], result->x[i]); + + pfree(a); + pfree(b); + + return (result); } /* cube_inter */ -NDBOX *cube_inter(NDBOX *box_a, NDBOX *box_b) +NDBOX * +cube_inter(NDBOX * box_a, NDBOX * box_b) { - int i; - NDBOX * result; - NDBOX *a = swap_corners(box_a); - NDBOX *b = swap_corners(box_b); - - if ( a->dim >= b->dim ) { - result = palloc(a->size); - result->size = a->size; - result->dim = a->dim; - } - else { - result = palloc(b->size); - result->size = b->size; - result->dim = b->dim; - } - - /* swap the box pointers if needed */ - if ( a->dim < b->dim ) { - NDBOX * tmp = b; b = a; a = tmp; - } - - /* use the potentially smaller of the two boxes (b) to fill in - the result, padding absent dimensions with zeroes*/ - for ( i = 0; i < b->dim; i++ ) { - result->x[i] = b->x[i]; - result->x[i + a->dim] = b->x[i + b->dim]; - } - for ( i = b->dim; i < a->dim; i++ ) { - result->x[i] = 0; - result->x[i + a->dim] = 0; - } - - /* compute the intersection */ - for ( i = 0; i < a->dim; i++ ) { - result->x[i] = max(a->x[i], result->x[i]); - } - for ( i = a->dim; i < a->dim * 2; i++ ) { - result->x[i] = min(a->x[i], result->x[i]); - } - - pfree(a); - pfree(b); - - /* Is it OK to return a non-null intersection for non-overlapping boxes? */ - return(result); + int i; + NDBOX *result; + NDBOX *a = swap_corners(box_a); + NDBOX *b = swap_corners(box_b); + + if (a->dim >= b->dim) + { + result = palloc(a->size); + result->size = a->size; + result->dim = a->dim; + } + else + { + result = palloc(b->size); + result->size = b->size; + result->dim = b->dim; + } + + /* swap the box pointers if needed */ + if (a->dim < b->dim) + { + NDBOX *tmp = b; + + b = a; + a = tmp; + } + + /* + * use the potentially smaller of the two boxes (b) to fill in the + * result, padding absent dimensions with zeroes + */ + for (i = 0; i < b->dim; i++) + { + result->x[i] = b->x[i]; + result->x[i + a->dim] = b->x[i + b->dim]; + } + for (i = b->dim; i < a->dim; i++) + { + result->x[i] = 0; + result->x[i + a->dim] = 0; + } + + /* compute the intersection */ + for (i = 0; i < a->dim; i++) + result->x[i] = max(a->x[i], result->x[i]); + for (i = a->dim; i < a->dim * 2; i++) + result->x[i] = min(a->x[i], result->x[i]); + + pfree(a); + pfree(b); + + /* + * Is it OK to return a non-null intersection for non-overlapping + * boxes? + */ + return (result); } /* cube_size */ -float *cube_size(NDBOX *a) +float * +cube_size(NDBOX * a) { - int i,j; - float *result; - - result = (float *) palloc(sizeof(float)); - - *result = 1.0; - for ( i = 0, j = a->dim; i < a->dim; i++,j++ ) { - *result=(*result)*abs((a->x[j] - a->x[i])); - } - - return(result); + int i, + j; + float *result; + + result = (float *) palloc(sizeof(float)); + + *result = 1.0; + for (i = 0, j = a->dim; i < a->dim; i++, j++) + *result = (*result) * abs((a->x[j] - a->x[i])); + + return (result); } void -rt_cube_size(NDBOX *a, float *size) +rt_cube_size(NDBOX * a, float *size) { - int i,j; - if (a == (NDBOX *) NULL) - *size = 0.0; - else { - *size = 1.0; - for ( i = 0, j = a->dim; i < a->dim; i++,j++ ) { - *size=(*size)*abs((a->x[j] - a->x[i])); - } - } - return; + int i, + j; + + if (a == (NDBOX *) NULL) + *size = 0.0; + else + { + *size = 1.0; + for (i = 0, j = a->dim; i < a->dim; i++, j++) + *size = (*size) * abs((a->x[j] - a->x[i])); + } + return; } /* The following four methods compare the projections of the boxes @@ -631,428 +692,489 @@ rt_cube_size(NDBOX *a, float *size) larger than 2, but it seems that R-tree requires all its strategies map to real functions that return something */ -/* is the right edge of (a) located to the left of - the right edge of (b)? */ -bool cube_over_left(NDBOX *box_a, NDBOX *box_b) +/* is the right edge of (a) located to the left of + the right edge of (b)? */ +bool +cube_over_left(NDBOX * box_a, NDBOX * box_b) { - NDBOX *a; - NDBOX *b; - - if ( (box_a==NULL) || (box_b==NULL) ) - return(FALSE); + NDBOX *a; + NDBOX *b; + + if ((box_a == NULL) || (box_b == NULL)) + return (FALSE); - a = swap_corners(box_a); - b = swap_corners(box_b); + a = swap_corners(box_a); + b = swap_corners(box_b); - return( a->x[a->dim - 1] <= b->x[b->dim - 1] && !cube_left(a, b) && !cube_right(a, b) ); + return (a->x[a->dim - 1] <= b->x[b->dim - 1] && !cube_left(a, b) && !cube_right(a, b)); } -/* is the left edge of (a) located to the right of - the left edge of (b)? */ -bool cube_over_right(NDBOX *box_a, NDBOX *box_b) +/* is the left edge of (a) located to the right of + the left edge of (b)? */ +bool +cube_over_right(NDBOX * box_a, NDBOX * box_b) { - NDBOX *a; - NDBOX *b; - - if ( (box_a==NULL) || (box_b==NULL) ) - return(FALSE); + NDBOX *a; + NDBOX *b; - a = swap_corners(box_a); - b = swap_corners(box_b); + if ((box_a == NULL) || (box_b == NULL)) + return (FALSE); - return( a->x[a->dim - 1] >= b->x[b->dim - 1] && !cube_left(a, b) && !cube_right(a, b) ); + a = swap_corners(box_a); + b = swap_corners(box_b); + + return (a->x[a->dim - 1] >= b->x[b->dim - 1] && !cube_left(a, b) && !cube_right(a, b)); } /* return 'true' if the projection of 'a' is entirely on the left of the projection of 'b' */ -bool cube_left(NDBOX *box_a, NDBOX *box_b) +bool +cube_left(NDBOX * box_a, NDBOX * box_b) { - NDBOX *a; - NDBOX *b; - - if ( (box_a==NULL) || (box_b==NULL) ) - return(FALSE); + NDBOX *a; + NDBOX *b; + + if ((box_a == NULL) || (box_b == NULL)) + return (FALSE); - a = swap_corners(box_a); - b = swap_corners(box_b); + a = swap_corners(box_a); + b = swap_corners(box_b); - return( a->x[a->dim - 1] < b->x[0]); + return (a->x[a->dim - 1] < b->x[0]); } /* return 'true' if the projection of 'a' is entirely on the right of the projection of 'b' */ -bool cube_right(NDBOX *box_a, NDBOX *box_b) +bool +cube_right(NDBOX * box_a, NDBOX * box_b) { - NDBOX *a; - NDBOX *b; - - if ( (box_a==NULL) || (box_b==NULL) ) - return(FALSE); + NDBOX *a; + NDBOX *b; - a = swap_corners(box_a); - b = swap_corners(box_b); + if ((box_a == NULL) || (box_b == NULL)) + return (FALSE); - return( a->x[0] > b->x[b->dim - 1]); + a = swap_corners(box_a); + b = swap_corners(box_b); + + return (a->x[0] > b->x[b->dim - 1]); } /* make up a metric in which one box will be 'lower' than the other -- this can be useful for srting and to determine uniqueness */ -bool cube_lt(NDBOX *box_a, NDBOX *box_b) +bool +cube_lt(NDBOX * box_a, NDBOX * box_b) { - int i; - int dim; - NDBOX *a; - NDBOX *b; - - if ( (box_a==NULL) || (box_b==NULL) ) - return(FALSE); - - a = swap_corners(box_a); - b = swap_corners(box_b); - dim = min(a->dim, b->dim); - - /* if all common dimensions are equal, the cube with more dimensions wins */ - if ( cube_same(a, b) ) { - if (a->dim < b->dim) { - return(TRUE); - } - else { - return(FALSE); - } - } - - /* compare the common dimensions */ - for ( i = 0; i < dim; i++ ) { - if ( a->x[i] > b->x[i] ) - return(FALSE); - if ( a->x[i] < b->x[i] ) - return(TRUE); - } - for ( i = 0; i < dim; i++ ) { - if ( a->x[i + a->dim] > b->x[i + b->dim] ) - return(FALSE); - if ( a->x[i + a->dim] < b->x[i + b->dim] ) - return(TRUE); - } - - /* compare extra dimensions to zero */ - if ( a->dim > b->dim ) { - for ( i = dim; i < a->dim; i++ ) { - if ( a->x[i] > 0 ) - return(FALSE); - if ( a->x[i] < 0 ) - return(TRUE); - } - for ( i = 0; i < dim; i++ ) { - if ( a->x[i + a->dim] > 0 ) - return(FALSE); - if ( a->x[i + a->dim] < 0 ) - return(TRUE); - } - } - if ( a->dim < b->dim ) { - for ( i = dim; i < b->dim; i++ ) { - if ( b->x[i] > 0 ) - return(TRUE); - if ( b->x[i] < 0 ) - return(FALSE); - } - for ( i = 0; i < dim; i++ ) { - if ( b->x[i + b->dim] > 0 ) - return(TRUE); - if ( b->x[i + b->dim] < 0 ) - return(FALSE); - } - } - - return(FALSE); + int i; + int dim; + NDBOX *a; + NDBOX *b; + + if ((box_a == NULL) || (box_b == NULL)) + return (FALSE); + + a = swap_corners(box_a); + b = swap_corners(box_b); + dim = min(a->dim, b->dim); + + /* + * if all common dimensions are equal, the cube with more dimensions + * wins + */ + if (cube_same(a, b)) + { + if (a->dim < b->dim) + return (TRUE); + else + return (FALSE); + } + + /* compare the common dimensions */ + for (i = 0; i < dim; i++) + { + if (a->x[i] > b->x[i]) + return (FALSE); + if (a->x[i] < b->x[i]) + return (TRUE); + } + for (i = 0; i < dim; i++) + { + if (a->x[i + a->dim] > b->x[i + b->dim]) + return (FALSE); + if (a->x[i + a->dim] < b->x[i + b->dim]) + return (TRUE); + } + + /* compare extra dimensions to zero */ + if (a->dim > b->dim) + { + for (i = dim; i < a->dim; i++) + { + if (a->x[i] > 0) + return (FALSE); + if (a->x[i] < 0) + return (TRUE); + } + for (i = 0; i < dim; i++) + { + if (a->x[i + a->dim] > 0) + return (FALSE); + if (a->x[i + a->dim] < 0) + return (TRUE); + } + } + if (a->dim < b->dim) + { + for (i = dim; i < b->dim; i++) + { + if (b->x[i] > 0) + return (TRUE); + if (b->x[i] < 0) + return (FALSE); + } + for (i = 0; i < dim; i++) + { + if (b->x[i + b->dim] > 0) + return (TRUE); + if (b->x[i + b->dim] < 0) + return (FALSE); + } + } + + return (FALSE); } -bool cube_gt(NDBOX *box_a, NDBOX *box_b) +bool +cube_gt(NDBOX * box_a, NDBOX * box_b) { - int i; - int dim; - NDBOX *a; - NDBOX *b; - - if ( (box_a==NULL) || (box_b==NULL) ) - return(FALSE); - - a = swap_corners(box_a); - b = swap_corners(box_b); - dim = min(a->dim, b->dim); - - /* if all common dimensions are equal, the cube with more dimensions wins */ - if ( cube_same(a, b) ) { - if (a->dim > b->dim) { - return(TRUE); - } - else { - return(FALSE); - } - } - - /* compare the common dimensions */ - for ( i = 0; i < dim; i++ ) { - if ( a->x[i] < b->x[i] ) - return(FALSE); - if ( a->x[i] > b->x[i] ) - return(TRUE); - } - for ( i = 0; i < dim; i++ ) { - if ( a->x[i + a->dim] < b->x[i + b->dim] ) - return(FALSE); - if ( a->x[i + a->dim] > b->x[i + b->dim] ) - return(TRUE); - } - - - /* compare extra dimensions to zero */ - if ( a->dim > b->dim ) { - for ( i = dim; i < a->dim; i++ ) { - if ( a->x[i] < 0 ) - return(FALSE); - if ( a->x[i] > 0 ) - return(TRUE); - } - for ( i = 0; i < dim; i++ ) { - if ( a->x[i + a->dim] < 0 ) - return(FALSE); - if ( a->x[i + a->dim] > 0 ) - return(TRUE); - } - } - if ( a->dim < b->dim ) { - for ( i = dim; i < b->dim; i++ ) { - if ( b->x[i] < 0 ) - return(TRUE); - if ( b->x[i] > 0 ) - return(FALSE); - } - for ( i = 0; i < dim; i++ ) { - if ( b->x[i + b->dim] < 0 ) - return(TRUE); - if ( b->x[i + b->dim] > 0 ) - return(FALSE); - } - } - - return(FALSE); + int i; + int dim; + NDBOX *a; + NDBOX *b; + + if ((box_a == NULL) || (box_b == NULL)) + return (FALSE); + + a = swap_corners(box_a); + b = swap_corners(box_b); + dim = min(a->dim, b->dim); + + /* + * if all common dimensions are equal, the cube with more dimensions + * wins + */ + if (cube_same(a, b)) + { + if (a->dim > b->dim) + return (TRUE); + else + return (FALSE); + } + + /* compare the common dimensions */ + for (i = 0; i < dim; i++) + { + if (a->x[i] < b->x[i]) + return (FALSE); + if (a->x[i] > b->x[i]) + return (TRUE); + } + for (i = 0; i < dim; i++) + { + if (a->x[i + a->dim] < b->x[i + b->dim]) + return (FALSE); + if (a->x[i + a->dim] > b->x[i + b->dim]) + return (TRUE); + } + + + /* compare extra dimensions to zero */ + if (a->dim > b->dim) + { + for (i = dim; i < a->dim; i++) + { + if (a->x[i] < 0) + return (FALSE); + if (a->x[i] > 0) + return (TRUE); + } + for (i = 0; i < dim; i++) + { + if (a->x[i + a->dim] < 0) + return (FALSE); + if (a->x[i + a->dim] > 0) + return (TRUE); + } + } + if (a->dim < b->dim) + { + for (i = dim; i < b->dim; i++) + { + if (b->x[i] < 0) + return (TRUE); + if (b->x[i] > 0) + return (FALSE); + } + for (i = 0; i < dim; i++) + { + if (b->x[i + b->dim] < 0) + return (TRUE); + if (b->x[i + b->dim] > 0) + return (FALSE); + } + } + + return (FALSE); } /* Equal */ -bool cube_same(NDBOX *box_a, NDBOX *box_b) +bool +cube_same(NDBOX * box_a, NDBOX * box_b) { - int i; - NDBOX *a; - NDBOX *b; - - if ( (box_a==NULL) || (box_b==NULL) ) - return(FALSE); - - a = swap_corners(box_a); - b = swap_corners(box_b); - - /* swap the box pointers if necessary */ - if ( a->dim < b->dim ) { - NDBOX * tmp = b; b = a; a = tmp; - } - - for ( i = 0; i < b->dim; i++ ) { - if ( a->x[i] != b->x[i] ) - return(FALSE); - if ( a->x[i + a->dim] != b->x[i + b->dim] ) - return(FALSE); - } - - /* all dimensions of (b) are compared to those of (a); - instead of those in (a) absent in (b), compare (a) to zero */ - for ( i = b->dim; i < a->dim; i++ ) { - if ( a->x[i] != 0 ) - return(FALSE); - if ( a->x[i + a->dim] != 0 ) - return(FALSE); - } - - pfree(a); - pfree(b); - - return(TRUE); + int i; + NDBOX *a; + NDBOX *b; + + if ((box_a == NULL) || (box_b == NULL)) + return (FALSE); + + a = swap_corners(box_a); + b = swap_corners(box_b); + + /* swap the box pointers if necessary */ + if (a->dim < b->dim) + { + NDBOX *tmp = b; + + b = a; + a = tmp; + } + + for (i = 0; i < b->dim; i++) + { + if (a->x[i] != b->x[i]) + return (FALSE); + if (a->x[i + a->dim] != b->x[i + b->dim]) + return (FALSE); + } + + /* + * all dimensions of (b) are compared to those of (a); instead of + * those in (a) absent in (b), compare (a) to zero + */ + for (i = b->dim; i < a->dim; i++) + { + if (a->x[i] != 0) + return (FALSE); + if (a->x[i + a->dim] != 0) + return (FALSE); + } + + pfree(a); + pfree(b); + + return (TRUE); } /* Different */ -bool cube_different(NDBOX *box_a, NDBOX *box_b) +bool +cube_different(NDBOX * box_a, NDBOX * box_b) { - return(!cube_same(box_a, box_b)); + return (!cube_same(box_a, box_b)); } /* Contains */ /* Box(A) CONTAINS Box(B) IFF pt(A) < pt(B) */ -bool cube_contains(NDBOX *box_a, NDBOX *box_b) +bool +cube_contains(NDBOX * box_a, NDBOX * box_b) { - int i; - NDBOX *a; - NDBOX *b; - - if ( (box_a==NULL) || (box_b==NULL) ) - return(FALSE); - - a = swap_corners(box_a); - b = swap_corners(box_b); - - if ( a->dim < b->dim ) { - /* the further comparisons will make sense if the - excess dimensions of (b) were zeroes */ - for ( i = a->dim; i < b->dim; i++ ) { - if ( b->x[i] != 0 ) - return(FALSE); - if ( b->x[i + b->dim] != 0 ) - return(FALSE); - } - } - - /* Can't care less about the excess dimensions of (a), if any */ - for ( i = 0; i < min(a->dim, b->dim); i++ ) { - if ( a->x[i] > b->x[i] ) - return(FALSE); - if ( a->x[i + a->dim] < b->x[i + b->dim] ) - return(FALSE); - } - - pfree(a); - pfree(b); - - return(TRUE); + int i; + NDBOX *a; + NDBOX *b; + + if ((box_a == NULL) || (box_b == NULL)) + return (FALSE); + + a = swap_corners(box_a); + b = swap_corners(box_b); + + if (a->dim < b->dim) + { + + /* + * the further comparisons will make sense if the excess + * dimensions of (b) were zeroes + */ + for (i = a->dim; i < b->dim; i++) + { + if (b->x[i] != 0) + return (FALSE); + if (b->x[i + b->dim] != 0) + return (FALSE); + } + } + + /* Can't care less about the excess dimensions of (a), if any */ + for (i = 0; i < min(a->dim, b->dim); i++) + { + if (a->x[i] > b->x[i]) + return (FALSE); + if (a->x[i + a->dim] < b->x[i + b->dim]) + return (FALSE); + } + + pfree(a); + pfree(b); + + return (TRUE); } /* Contained */ /* Box(A) Contained by Box(B) IFF Box(B) Contains Box(A) */ -bool cube_contained (NDBOX *a, NDBOX *b) +bool +cube_contained(NDBOX * a, NDBOX * b) { - if (cube_contains(b,a) == TRUE) - return(TRUE); - else - return(FALSE); + if (cube_contains(b, a) == TRUE) + return (TRUE); + else + return (FALSE); } /* Overlap */ /* Box(A) Overlap Box(B) IFF (pt(a)LL < pt(B)UR) && (pt(b)LL < pt(a)UR) */ -bool cube_overlap(NDBOX *box_a, NDBOX *box_b) +bool +cube_overlap(NDBOX * box_a, NDBOX * box_b) { - int i; - NDBOX *a; - NDBOX *b; - - /* This *very bad* error was found in the source: - if ( (a==NULL) || (b=NULL) ) - return(FALSE); - */ - if ( (box_a==NULL) || (box_b==NULL) ) - return(FALSE); - - a = swap_corners(box_a); - b = swap_corners(box_b); - - /* swap the box pointers if needed */ - if ( a->dim < b->dim ) { - NDBOX * tmp = b; b = a; a = tmp; - } - - /* compare within the dimensions of (b) */ - for ( i = 0; i < b->dim; i++ ) { - if ( a->x[i] > b->x[i + b->dim] ) - return(FALSE); - if ( a->x[i + a->dim] < b->x[i] ) - return(FALSE); - } - - /* compare to zero those dimensions in (a) absent in (b) */ - for ( i = b->dim; i < a->dim; i++ ) { - if ( a->x[i] > 0 ) - return(FALSE); - if ( a->x[i + a->dim] < 0 ) - return(FALSE); - } - - pfree(a); - pfree(b); - - return(TRUE); + int i; + NDBOX *a; + NDBOX *b; + + /* + * This *very bad* error was found in the source: if ( (a==NULL) || + * (b=NULL) ) return(FALSE); + */ + if ((box_a == NULL) || (box_b == NULL)) + return (FALSE); + + a = swap_corners(box_a); + b = swap_corners(box_b); + + /* swap the box pointers if needed */ + if (a->dim < b->dim) + { + NDBOX *tmp = b; + + b = a; + a = tmp; + } + + /* compare within the dimensions of (b) */ + for (i = 0; i < b->dim; i++) + { + if (a->x[i] > b->x[i + b->dim]) + return (FALSE); + if (a->x[i + a->dim] < b->x[i]) + return (FALSE); + } + + /* compare to zero those dimensions in (a) absent in (b) */ + for (i = b->dim; i < a->dim; i++) + { + if (a->x[i] > 0) + return (FALSE); + if (a->x[i + a->dim] < 0) + return (FALSE); + } + + pfree(a); + pfree(b); + + return (TRUE); } /* Distance */ /* The distance is computed as a per axis sum of the squared distances - between 1D projections of the boxes onto Cartesian axes. Assuming zero - distance between overlapping projections, this metric coincides with the + between 1D projections of the boxes onto Cartesian axes. Assuming zero + distance between overlapping projections, this metric coincides with the "common sense" geometric distance */ -float *cube_distance(NDBOX *a, NDBOX *b) +float * +cube_distance(NDBOX * a, NDBOX * b) { - int i; - double d, distance; - float *result; - - result = (float *) palloc(sizeof(float)); - - /* swap the box pointers if needed */ - if ( a->dim < b->dim ) { - NDBOX * tmp = b; b = a; a = tmp; - } - - distance = 0.0; - /* compute within the dimensions of (b) */ - for ( i = 0; i < b->dim; i++ ) { - d = distance_1D(a->x[i], a->x[i + a->dim], b->x[i], b->x[i + b->dim]); - distance += d*d; - } - - /* compute distance to zero for those dimensions in (a) absent in (b) */ - for ( i = b->dim; i < a->dim; i++ ) { - d = distance_1D(a->x[i], a->x[i + a->dim], 0.0, 0.0); - distance += d*d; - } - - *result = (float)sqrt(distance); - - return(result); + int i; + double d, + distance; + float *result; + + result = (float *) palloc(sizeof(float)); + + /* swap the box pointers if needed */ + if (a->dim < b->dim) + { + NDBOX *tmp = b; + + b = a; + a = tmp; + } + + distance = 0.0; + /* compute within the dimensions of (b) */ + for (i = 0; i < b->dim; i++) + { + d = distance_1D(a->x[i], a->x[i + a->dim], b->x[i], b->x[i + b->dim]); + distance += d * d; + } + + /* compute distance to zero for those dimensions in (a) absent in (b) */ + for (i = b->dim; i < a->dim; i++) + { + d = distance_1D(a->x[i], a->x[i + a->dim], 0.0, 0.0); + distance += d * d; + } + + *result = (float) sqrt(distance); + + return (result); } -static float distance_1D(float a1, float a2, float b1, float b2) +static float +distance_1D(float a1, float a2, float b1, float b2) { - /* interval (a) is entirely on the left of (b) */ - if( (a1 <= b1) && (a2 <= b1) && (a1 <= b2) && (a2 <= b2) ) { - return ( min( b1, b2 ) - max( a1, a2 ) ); - } - - /* interval (a) is entirely on the right of (b) */ - if( (a1 > b1) && (a2 > b1) && (a1 > b2) && (a2 > b2) ) { - return ( min( a1, a2 ) - max( b1, b2 ) ); - } - - /* the rest are all sorts of intersections */ - return(0.0); + /* interval (a) is entirely on the left of (b) */ + if ((a1 <= b1) && (a2 <= b1) && (a1 <= b2) && (a2 <= b2)) + return (min(b1, b2) - max(a1, a2)); + + /* interval (a) is entirely on the right of (b) */ + if ((a1 > b1) && (a2 > b1) && (a1 > b2) && (a2 > b2)) + return (min(a1, a2) - max(b1, b2)); + + /* the rest are all sorts of intersections */ + return (0.0); } /* normalize the box's co-ordinates by placing min(xLL,xUR) to LL - and max(xLL,xUR) to UR + and max(xLL,xUR) to UR */ -static NDBOX *swap_corners ( NDBOX *a ) +static NDBOX * +swap_corners(NDBOX * a) { - int i, j; - NDBOX * result; - - result = palloc(a->size); - result->size = a->size; - result->dim = a->dim; - - for ( i = 0, j = a->dim; i < a->dim; i++, j++ ) { - result->x[i] = min(a->x[i],a->x[j]); - result->x[j] = max(a->x[i],a->x[j]); - } - - return(result); + int i, + j; + NDBOX *result; + + result = palloc(a->size); + result->size = a->size; + result->dim = a->dim; + + for (i = 0, j = a->dim; i < a->dim; i++, j++) + { + result->x[i] = min(a->x[i], a->x[j]); + result->x[j] = max(a->x[i], a->x[j]); + } + + return (result); } diff --git a/contrib/cube/cubedata.h b/contrib/cube/cubedata.h index 18bb648546..359fab2871 100644 --- a/contrib/cube/cubedata.h +++ b/contrib/cube/cubedata.h @@ -1,5 +1,6 @@ -typedef struct NDBOX { - unsigned int size; /* required to be a Postgres varlena type */ - unsigned int dim; - float x[1]; -} NDBOX; +typedef struct NDBOX +{ + unsigned int size; /* required to be a Postgres varlena type */ + unsigned int dim; + float x[1]; +} NDBOX; diff --git a/contrib/earthdistance/earthdistance.c b/contrib/earthdistance/earthdistance.c index 2383256be9..c1962272f4 100644 --- a/contrib/earthdistance/earthdistance.c +++ b/contrib/earthdistance/earthdistance.c @@ -9,7 +9,7 @@ const int EARTH_RADIUS = 3958.747716; const int TWO_PI = 2.0 * M_PI; -double *geo_distance(Point *pt1, Point *pt2); +double *geo_distance(Point *pt1, Point *pt2); /****************************************************** diff --git a/contrib/findoidjoins/findoidjoins.c b/contrib/findoidjoins/findoidjoins.c index 7d76bf719f..8aabe58672 100644 --- a/contrib/findoidjoins/findoidjoins.c +++ b/contrib/findoidjoins/findoidjoins.c @@ -20,7 +20,7 @@ main(int argc, char **argv) char attname[256]; char typname[256]; int count; - char optstr[256]; + char optstr[256]; if (argc != 2) halt("Usage: %s database\n", argv[0]); diff --git a/contrib/fulltextindex/fti.c b/contrib/fulltextindex/fti.c index 1f9c398fea..a797505e70 100644 --- a/contrib/fulltextindex/fti.c +++ b/contrib/fulltextindex/fti.c @@ -62,11 +62,11 @@ select p.* from product p, title_fti f1, title_fti f2 where that can build the final query automatigally? */ -extern Datum fti(PG_FUNCTION_ARGS); -static char *breakup(char *, char *); -static bool is_stopword(char *); +extern Datum fti(PG_FUNCTION_ARGS); +static char *breakup(char *, char *); +static bool is_stopword(char *); -static bool new_tuple = false; +static bool new_tuple = false; /* THIS LIST MUST BE IN SORTED ORDER, A BINARY SEARCH IS USED!!!! */ diff --git a/contrib/lo/lo.c b/contrib/lo/lo.c index 33fa4cf98d..1dcdc35850 100644 --- a/contrib/lo/lo.c +++ b/contrib/lo/lo.c @@ -1,7 +1,7 @@ /* * PostgreSQL type definitions for managed LargeObjects. * - * $Header: /cvsroot/pgsql/contrib/lo/lo.c,v 1.7 2001/02/10 02:31:25 tgl Exp $ + * $Header: /cvsroot/pgsql/contrib/lo/lo.c,v 1.8 2001/03/22 03:59:09 momjian Exp $ * */ @@ -36,7 +36,7 @@ Blob *lo_in(char *str); /* Create from String */ char *lo_out(Blob * addr);/* Output oid as String */ Oid lo_oid(Blob * addr);/* Return oid as an oid */ Blob *lo(Oid oid); /* Return Blob based on oid */ -Datum lo_manage(PG_FUNCTION_ARGS); /* Trigger handler */ +Datum lo_manage(PG_FUNCTION_ARGS); /* Trigger handler */ /* * This creates a large object, and sets its OID to the value in the @@ -69,7 +69,7 @@ lo_in(char *str) * There is no Oid passed, so create a new one */ oid = DatumGetObjectId(DirectFunctionCall1(lo_creat, - Int32GetDatum(INV_READ | INV_WRITE))); + Int32GetDatum(INV_READ | INV_WRITE))); if (oid == InvalidOid) elog(ERROR, "lo_in: InvalidOid returned from lo_creat"); } diff --git a/contrib/oid2name/oid2name.c b/contrib/oid2name/oid2name.c index 1eaa73335c..a823c5f50b 100644 --- a/contrib/oid2name/oid2name.c +++ b/contrib/oid2name/oid2name.c @@ -1,6 +1,6 @@ -/* +/* oid2name; a postgresql 7.1 (+?) app to map OIDs on the filesystem - to table and database names. + to table and database names. b. palmer, [email protected] 1-17-2001 @@ -13,433 +13,439 @@ #include "libpq-fe.h" /* these are the opts structures for command line params */ -struct options { - int getdatabase; - int gettable; - int getoid; - - int systables; - - int remotehost; - int remoteport; - int remoteuser; - int remotepass; - - int _oid; - char _dbname[128]; - char _tbname[128]; - - char _hostname[128]; - char _port[6]; - char _username[128]; - char _password[128]; +struct options +{ + int getdatabase; + int gettable; + int getoid; + + int systables; + + int remotehost; + int remoteport; + int remoteuser; + int remotepass; + + int _oid; + char _dbname[128]; + char _tbname[128]; + + char _hostname[128]; + char _port[6]; + char _username[128]; + char _password[128]; }; /* function prototypes */ -void get_opts(int, char **, struct options *); -PGconn *sql_conn(char *, struct options *); -void sql_exec_error (int); -int sql_exec(PGconn *, char *, int); -void sql_exec_dumpdb(PGconn *); -void sql_exec_dumptable(PGconn *, int); -void sql_exec_searchtable(PGconn *, char *); -void sql_exec_searchoid(PGconn *, int); +void get_opts(int, char **, struct options *); +PGconn *sql_conn(char *, struct options *); +void sql_exec_error(int); +int sql_exec(PGconn *, char *, int); +void sql_exec_dumpdb(PGconn *); +void sql_exec_dumptable(PGconn *, int); +void sql_exec_searchtable(PGconn *, char *); +void sql_exec_searchoid(PGconn *, int); /* fuction to parse command line options and check for some usage errors. */ -void get_opts(int argc, char **argv, struct options *my_opts) +void +get_opts(int argc, char **argv, struct options * my_opts) { - char c; + char c; - /* set the defaults */ - my_opts->getdatabase = 0; - my_opts->gettable = 0; - my_opts->getoid = 0; + /* set the defaults */ + my_opts->getdatabase = 0; + my_opts->gettable = 0; + my_opts->getoid = 0; - my_opts->systables = 0; + my_opts->systables = 0; - my_opts->remotehost = 0; - my_opts->remoteport = 0; - my_opts->remoteuser = 0; - my_opts->remotepass = 0; + my_opts->remotehost = 0; + my_opts->remoteport = 0; + my_opts->remoteuser = 0; + my_opts->remotepass = 0; - /* get opts */ - while( (c = getopt(argc, argv, "H:p:U:P:d:t:o:xh?")) != EOF) - { - switch(c) + /* get opts */ + while ((c = getopt(argc, argv, "H:p:U:P:d:t:o:xh?")) != EOF) { - /* specify the database */ - case 'd': - my_opts->getdatabase = 1; - sscanf(optarg, "%s", my_opts->_dbname); - break; - - /* specify the table name */ - case 't': - /* make sure we set the database first */ - if(!my_opts->getdatabase) - { - fprintf(stderr, "Sorry, but you must specify a database to dump from.\n"); - exit(1); - } - /* make sure we don't try to do a -o also */ - if(my_opts->getoid) - { - fprintf(stderr, "Sorry, you can only specify either oid or table\n"); - exit(1); - } - - my_opts->gettable = 1; - sscanf(optarg, "%s", my_opts->_tbname); - - break; - - /* specify the oid int */ - case 'o': - /* make sure we set the database first */ - if(!my_opts->getdatabase) - { - fprintf(stderr, "Sorry, but you must specify a database to dump from.\n"); - exit(1); - } - /* make sure we don't try to do a -t also */ - if(my_opts->gettable) - { - fprintf(stderr, "Sorry, you can only specify either oid or table\n"); - exit(1); - } - - my_opts->getoid = 1; - sscanf(optarg, "%i", &my_opts->_oid); - - break; - - /* host to connect to */ - case 'H': - my_opts->remotehost = 1; - sscanf(optarg, "%s", my_opts->_hostname); - break; - - /* port to connect to on remote host */ - case 'p': - my_opts->remoteport = 1; - sscanf(optarg, "%s", my_opts->_port); - break; - - /* username */ - case 'U': - my_opts->remoteuser = 1; - sscanf(optarg, "%s", my_opts->_username); - break; - - /* password */ - case 'P': - my_opts->remotepass = 1; - sscanf(optarg, "%s", my_opts->_password); - break; - - /* display system tables */ - case 'x': - - my_opts->systables = 1; - break; - - /* help! (ugly in code for easier editing) */ - case '?': - case 'h': - fprintf(stderr, "\n\ + switch (c) + { + /* specify the database */ + case 'd': + my_opts->getdatabase = 1; + sscanf(optarg, "%s", my_opts->_dbname); + break; + + /* specify the table name */ + case 't': + /* make sure we set the database first */ + if (!my_opts->getdatabase) + { + fprintf(stderr, "Sorry, but you must specify a database to dump from.\n"); + exit(1); + } + /* make sure we don't try to do a -o also */ + if (my_opts->getoid) + { + fprintf(stderr, "Sorry, you can only specify either oid or table\n"); + exit(1); + } + + my_opts->gettable = 1; + sscanf(optarg, "%s", my_opts->_tbname); + + break; + + /* specify the oid int */ + case 'o': + /* make sure we set the database first */ + if (!my_opts->getdatabase) + { + fprintf(stderr, "Sorry, but you must specify a database to dump from.\n"); + exit(1); + } + /* make sure we don't try to do a -t also */ + if (my_opts->gettable) + { + fprintf(stderr, "Sorry, you can only specify either oid or table\n"); + exit(1); + } + + my_opts->getoid = 1; + sscanf(optarg, "%i", &my_opts->_oid); + + break; + + /* host to connect to */ + case 'H': + my_opts->remotehost = 1; + sscanf(optarg, "%s", my_opts->_hostname); + break; + + /* port to connect to on remote host */ + case 'p': + my_opts->remoteport = 1; + sscanf(optarg, "%s", my_opts->_port); + break; + + /* username */ + case 'U': + my_opts->remoteuser = 1; + sscanf(optarg, "%s", my_opts->_username); + break; + + /* password */ + case 'P': + my_opts->remotepass = 1; + sscanf(optarg, "%s", my_opts->_password); + break; + + /* display system tables */ + case 'x': + + my_opts->systables = 1; + break; + + /* help! (ugly in code for easier editing) */ + case '?': + case 'h': + fprintf(stderr, "\n\ Usage: pg_oid2name [-d database [-x] ] [-t table | -o oid] \n\ - dafault action display all databases + dafault action display all databases\n\ -d database database to oid2name\n\ -x display system tables\n\ -t table | -o oid search for table name (-t) or\n\ - oid (-o) in -d database + oid (-o) in -d database\n\ -H host connect to remote host\n\ -p port host port to connect to\n\ -U username username to connect with\n\ -P password password for username\n\n\ "); - exit(1); - break; + exit(1); + break; + } } - } } /* establish connection with database. */ -PGconn *sql_conn(char *dbName, struct options *my_opts) +PGconn * +sql_conn(char *dbName, struct options * my_opts) { - char *pghost, *pgport; - char *pgoptions, *pgtty; - char *pguser, *pgpass; - - PGconn *conn; - - pghost = NULL; - pgport = NULL; - - pgoptions = NULL; /* special options to start up the backend - * server */ - pgtty = NULL; /* debugging tty for the backend server */ - - pguser = NULL; - pgpass = NULL; - - /* override the NULLs with the user params if passed */ - if(my_opts->remotehost) - { - pghost = (char *) malloc (128); - sscanf(my_opts->_hostname, "%s", pghost); - } - - if(my_opts->remoteport) - { - pgport = (char *) malloc (6); - sscanf(my_opts->_port, "%s", pgport); - } - - if(my_opts->remoteuser) - { - pguser = (char *) malloc (128); - sscanf(my_opts->_username, "%s", pguser); - } - - if(my_opts->remotepass) - { - pgpass = (char *) malloc (128); - sscanf(my_opts->_password, "%s", pgpass); - } - - /* login */ - conn = PQsetdbLogin(pghost, pgport, pgoptions, pgtty, dbName, pguser, pgpass); - - /* deal with errors */ - if (PQstatus(conn) == CONNECTION_BAD) - { - fprintf(stderr, "Connection to database '%s' failed.\n", dbName); - fprintf(stderr, "%s", PQerrorMessage(conn)); - - - PQfinish(conn); - exit(1); - - } - - /* return the conn if good */ - return conn; + char *pghost, + *pgport; + char *pgoptions, + *pgtty; + char *pguser, + *pgpass; + + PGconn *conn; + + pghost = NULL; + pgport = NULL; + + pgoptions = NULL; /* special options to start up the backend + * server */ + pgtty = NULL; /* debugging tty for the backend server */ + + pguser = NULL; + pgpass = NULL; + + /* override the NULLs with the user params if passed */ + if (my_opts->remotehost) + { + pghost = (char *) malloc(128); + sscanf(my_opts->_hostname, "%s", pghost); + } + + if (my_opts->remoteport) + { + pgport = (char *) malloc(6); + sscanf(my_opts->_port, "%s", pgport); + } + + if (my_opts->remoteuser) + { + pguser = (char *) malloc(128); + sscanf(my_opts->_username, "%s", pguser); + } + + if (my_opts->remotepass) + { + pgpass = (char *) malloc(128); + sscanf(my_opts->_password, "%s", pgpass); + } + + /* login */ + conn = PQsetdbLogin(pghost, pgport, pgoptions, pgtty, dbName, pguser, pgpass); + + /* deal with errors */ + if (PQstatus(conn) == CONNECTION_BAD) + { + fprintf(stderr, "Connection to database '%s' failed.\n", dbName); + fprintf(stderr, "%s", PQerrorMessage(conn)); + + + PQfinish(conn); + exit(1); + + } + + /* return the conn if good */ + return conn; } /* If the sql_ command has an error, this function looks up the error number and prints it out. */ -void sql_exec_error (int error_number) +void +sql_exec_error(int error_number) { - fprintf(stderr, "Error number %i.\n", error_number); - switch(error_number) - { - case 3: - fprintf(stderr, "Error: PGRES_COPY_OUT\n"); - break; - - case 4: - fprintf(stderr, "Error: PGRES_COPY_IN\n"); - break; - - case 5: - fprintf(stderr, "Error: PGRES_BAD_RESPONCE\n"); - break; - - case 6: - fprintf(stderr, "Error: PGRES_NONFATAL_ERROR\n"); - break; - - case 7: - fprintf(stderr, "Error: PGRES_FATAL_ERROR\n"); - break; - } + fprintf(stderr, "Error number %i.\n", error_number); + switch (error_number) + { + case 3: + fprintf(stderr, "Error: PGRES_COPY_OUT\n"); + break; + + case 4: + fprintf(stderr, "Error: PGRES_COPY_IN\n"); + break; + + case 5: + fprintf(stderr, "Error: PGRES_BAD_RESPONCE\n"); + break; + + case 6: + fprintf(stderr, "Error: PGRES_NONFATAL_ERROR\n"); + break; + + case 7: + fprintf(stderr, "Error: PGRES_FATAL_ERROR\n"); + break; + } } /* actual code to make call to the database and print the output data */ -int sql_exec(PGconn *conn, char *todo, int match) +int +sql_exec(PGconn *conn, char *todo, int match) { - PGresult *res; - - int numbfields; - int error_number; - int i, len; - - /* make the call */ - res = PQexec(conn, todo); - - /* check and deal with errors */ - if (!res || PQresultStatus(res) > 2) - { - error_number = PQresultStatus(res); - fprintf(stderr, "There was an error in the SQL command:\n%s\n", todo); - sql_exec_error(error_number); - fprintf(stderr, "PQerrorMessage = %s\n", PQerrorMessage(conn)); - - PQclear(res); - PQfinish(conn); - exit(-1); - } - - /* get the number of fields */ - numbfields = PQntuples(res); - - /* if we only expect 1 and there mode than, return -2 */ - if(match == 1 && numbfields > 1) - return -2; - - /* return -1 if there aren't any returns */ - if(match == 1 && numbfields < 1) - return -1; - - /* for each row, dump the information */ - for(i = 0; i < numbfields; i++) - { - len = strlen(PQgetvalue(res, i, 0)); - - fprintf(stdout, "%-6s = %s\n", PQgetvalue(res, i, 0), PQgetvalue(res, i, 1)); - } - - /* clean the PGconn once done */ - PQclear(res); - - return 0; + PGresult *res; + + int numbfields; + int error_number; + int i, + len; + + /* make the call */ + res = PQexec(conn, todo); + + /* check and deal with errors */ + if (!res || PQresultStatus(res) > 2) + { + error_number = PQresultStatus(res); + fprintf(stderr, "There was an error in the SQL command:\n%s\n", todo); + sql_exec_error(error_number); + fprintf(stderr, "PQerrorMessage = %s\n", PQerrorMessage(conn)); + + PQclear(res); + PQfinish(conn); + exit(-1); + } + + /* get the number of fields */ + numbfields = PQntuples(res); + + /* if we only expect 1 and there mode than, return -2 */ + if (match == 1 && numbfields > 1) + return -2; + + /* return -1 if there aren't any returns */ + if (match == 1 && numbfields < 1) + return -1; + + /* for each row, dump the information */ + for (i = 0; i < numbfields; i++) + { + len = strlen(PQgetvalue(res, i, 0)); + + fprintf(stdout, "%-6s = %s\n", PQgetvalue(res, i, 0), PQgetvalue(res, i, 1)); + } + + /* clean the PGconn once done */ + PQclear(res); + + return 0; } /* dump all databases know by the system table */ -void sql_exec_dumpdb(PGconn *conn) +void +sql_exec_dumpdb(PGconn *conn) { - char *todo; + char *todo; - todo = (char *) malloc (1024); + todo = (char *) malloc(1024); - /* get the oid and database name from the system pg_database table */ - sprintf(todo, "select oid,datname from pg_database"); + /* get the oid and database name from the system pg_database table */ + sprintf(todo, "select oid,datname from pg_database"); - sql_exec(conn, todo, 0); + sql_exec(conn, todo, 0); } /* display all tables in whatever db we are connected to. don't display the system tables by default */ -void sql_exec_dumptable(PGconn *conn, int systables) +void +sql_exec_dumptable(PGconn *conn, int systables) { - char *todo; + char *todo; - todo = (char *) malloc (1024); + todo = (char *) malloc(1024); - /* don't exclude the systables if this is set */ - if(systables == 1) - sprintf(todo, "select relfilenode,relname from pg_class order by relname"); - else - sprintf(todo, "select relfilenode,relname from pg_class where relname not like 'pg_%%' order by relname"); + /* don't exclude the systables if this is set */ + if (systables == 1) + sprintf(todo, "select relfilenode,relname from pg_class order by relname"); + else + sprintf(todo, "select relfilenode,relname from pg_class where relname not like 'pg_%%' order by relname"); - sql_exec(conn, todo, 0); + sql_exec(conn, todo, 0); } /* display the oid for a given tablename for whatever db we are connected - to. do we want to allow %bar% in the search? Not now. */ -void sql_exec_searchtable(PGconn *conn, char *tablename) + to. do we want to allow %bar% in the search? Not now. */ +void +sql_exec_searchtable(PGconn *conn, char *tablename) { - int returnvalue; - char *todo; - - todo = (char *) malloc (1024); - - /* get the oid and tablename where the name matches tablename */ - sprintf(todo, "select relfilenode,relname from pg_class where relname = '%s'", tablename); - - returnvalue = sql_exec(conn, todo, 1); - - /* deal with the return errors */ - if(returnvalue == -1) - { - printf("No tables with that name found\n"); - } - - if(returnvalue == -2) - { - printf("VERY scary: more than one table with that name found!!\n"); - } + int returnvalue; + char *todo; + + todo = (char *) malloc(1024); + + /* get the oid and tablename where the name matches tablename */ + sprintf(todo, "select relfilenode,relname from pg_class where relname = '%s'", tablename); + + returnvalue = sql_exec(conn, todo, 1); + + /* deal with the return errors */ + if (returnvalue == -1) + printf("No tables with that name found\n"); + + if (returnvalue == -2) + printf("VERY scary: more than one table with that name found!!\n"); } /* same as above */ -void sql_exec_searchoid(PGconn *conn, int oid) +void +sql_exec_searchoid(PGconn *conn, int oid) { - int returnvalue; - char *todo; + int returnvalue; + char *todo; + + todo = (char *) malloc(1024); - todo = (char *) malloc (1024); + sprintf(todo, "select relfilenode,relname from pg_class where oid = %i", oid); - sprintf(todo, "select relfilenode,relname from pg_class where oid = %i", oid); + returnvalue = sql_exec(conn, todo, 1); - returnvalue = sql_exec(conn, todo, 1); + if (returnvalue == -1) + printf("No tables with that oid found\n"); - if(returnvalue == -1) - { - printf("No tables with that oid found\n"); - } - - if(returnvalue == -2) - { - printf("VERY scary: more than one table with that oid found!!\n"); - } + if (returnvalue == -2) + printf("VERY scary: more than one table with that oid found!!\n"); } -int main(int argc, char **argv) +int +main(int argc, char **argv) { - struct options *my_opts; - PGconn *pgconn; - - my_opts = (struct options *) malloc (sizeof(struct options)); - - /* parse the opts */ - get_opts(argc, argv, my_opts); - - /* display all the tables in the database */ - if(my_opts->getdatabase & my_opts->gettable) - { - printf("Oid of table %s from database \"%s\":\n", my_opts->_tbname, my_opts->_dbname); - printf("_______________________________\n"); - - pgconn = sql_conn(my_opts->_dbname, my_opts); - sql_exec_searchtable(pgconn, my_opts->_tbname); - PQfinish(pgconn); - - exit(1); - } - - /* search for the tablename of the given OID */ - if(my_opts->getdatabase & my_opts->getoid) - { - printf("Tablename of oid %i from database \"%s\":\n", my_opts->_oid, my_opts->_dbname); - printf("---------------------------------\n"); - - pgconn = sql_conn(my_opts->_dbname, my_opts); - sql_exec_searchoid(pgconn, my_opts->_oid); - PQfinish(pgconn); - - exit(1); - } - - /* search for the oid for the given tablename */ - if(my_opts->getdatabase) - { - printf("All tables from database \"%s\":\n", my_opts->_dbname); - printf("---------------------------------\n"); - - pgconn = sql_conn(my_opts->_dbname, my_opts); - sql_exec_dumptable(pgconn, my_opts->systables); - PQfinish(pgconn); - - exit(1); - } - - /* display all the databases for the server we are connected to.. */ - printf("All databases:\n"); - printf("---------------------------------\n"); - - pgconn = sql_conn("template1", my_opts); - sql_exec_dumpdb(pgconn); - PQfinish(pgconn); - - exit(0); + struct options *my_opts; + PGconn *pgconn; + + my_opts = (struct options *) malloc(sizeof(struct options)); + + /* parse the opts */ + get_opts(argc, argv, my_opts); + + /* display all the tables in the database */ + if (my_opts->getdatabase & my_opts->gettable) + { + printf("Oid of table %s from database \"%s\":\n", my_opts->_tbname, my_opts->_dbname); + printf("_______________________________\n"); + + pgconn = sql_conn(my_opts->_dbname, my_opts); + sql_exec_searchtable(pgconn, my_opts->_tbname); + PQfinish(pgconn); + + exit(1); + } + + /* search for the tablename of the given OID */ + if (my_opts->getdatabase & my_opts->getoid) + { + printf("Tablename of oid %i from database \"%s\":\n", my_opts->_oid, my_opts->_dbname); + printf("---------------------------------\n"); + + pgconn = sql_conn(my_opts->_dbname, my_opts); + sql_exec_searchoid(pgconn, my_opts->_oid); + PQfinish(pgconn); + + exit(1); + } + + /* search for the oid for the given tablename */ + if (my_opts->getdatabase) + { + printf("All tables from database \"%s\":\n", my_opts->_dbname); + printf("---------------------------------\n"); + + pgconn = sql_conn(my_opts->_dbname, my_opts); + sql_exec_dumptable(pgconn, my_opts->systables); + PQfinish(pgconn); + + exit(1); + } + + /* display all the databases for the server we are connected to.. */ + printf("All databases:\n"); + printf("---------------------------------\n"); + + pgconn = sql_conn("template1", my_opts); + sql_exec_dumpdb(pgconn); + PQfinish(pgconn); + + exit(0); } diff --git a/contrib/pg_controldata/pg_controldata.c b/contrib/pg_controldata/pg_controldata.c index dc666c1fcf..93fe9a54c9 100644 --- a/contrib/pg_controldata/pg_controldata.c +++ b/contrib/pg_controldata/pg_controldata.c @@ -6,7 +6,7 @@ * copyright (c) Oliver Elphick <[email protected]>, 2001; * licence: BSD * - * $Header: /cvsroot/pgsql/contrib/pg_controldata/Attic/pg_controldata.c,v 1.2 2001/03/13 01:17:40 tgl Exp $ + * $Header: /cvsroot/pgsql/contrib/pg_controldata/Attic/pg_controldata.c,v 1.3 2001/03/22 03:59:09 momjian Exp $ */ #include "postgres.h" @@ -24,7 +24,7 @@ dbState(DBState state) { switch (state) { - case DB_STARTUP: + case DB_STARTUP: return "STARTUP"; case DB_SHUTDOWNED: return "SHUTDOWNED"; @@ -43,16 +43,17 @@ int main() { ControlFileData ControlFile; - int fd; - char ControlFilePath[MAXPGPATH]; - char *DataDir; - crc64 crc; - char pgctime_str[32]; - char ckpttime_str[32]; + int fd; + char ControlFilePath[MAXPGPATH]; + char *DataDir; + crc64 crc; + char pgctime_str[32]; + char ckpttime_str[32]; DataDir = getenv("PGDATA"); - if ( DataDir == NULL ) { - fprintf(stderr,"PGDATA is not defined\n"); + if (DataDir == NULL) + { + fprintf(stderr, "PGDATA is not defined\n"); exit(1); } @@ -73,8 +74,8 @@ main() /* Check the CRC. */ INIT_CRC64(crc); - COMP_CRC64(crc, - (char*) &ControlFile + sizeof(crc64), + COMP_CRC64(crc, + (char *) &ControlFile + sizeof(crc64), sizeof(ControlFileData) - sizeof(crc64)); FIN_CRC64(crc); @@ -93,7 +94,7 @@ main() "Database state: %s\n" "pg_control last modified: %s\n" "Current log file id: %u\n" - "Next log file segment: %u\n" + "Next log file segment: %u\n" "Latest checkpoint location: %X/%X\n" "Prior checkpoint location: %X/%X\n" "Latest checkpoint's REDO location: %X/%X\n" diff --git a/contrib/pg_dumplo/lo_export.c b/contrib/pg_dumplo/lo_export.c index 5a2a1614a5..6a62c88bc6 100644 --- a/contrib/pg_dumplo/lo_export.c +++ b/contrib/pg_dumplo/lo_export.c @@ -1,20 +1,20 @@ /* ------------------------------------------------------------------------- * pg_dumplo * - * $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/lo_export.c,v 1.5 2001/01/24 19:42:44 momjian Exp $ + * $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/lo_export.c,v 1.6 2001/03/22 03:59:10 momjian Exp $ * * Karel Zak 1999-2000 * ------------------------------------------------------------------------- */ -#include <stdio.h> +#include <stdio.h> #include <unistd.h> #include <stdlib.h> #include <string.h> #include <sys/stat.h> #include <sys/types.h> #include <fcntl.h> -#include <errno.h> +#include <errno.h> #include <time.h> #include <libpq-fe.h> @@ -22,17 +22,17 @@ #include "pg_dumplo.h" -extern int errno; +extern int errno; -void -load_lolist( LODumpMaster *pgLO ) +void +load_lolist(LODumpMaster * pgLO) { - LOlist *ll; - int i; - int n; + LOlist *ll; + int i; + int n; - /* ---------- + /* ---------- * Now find any candidate tables who have columns of type oid. * * NOTE: System tables including pg_largeobject will be ignored. @@ -40,8 +40,8 @@ load_lolist( LODumpMaster *pgLO ) * * NOTE: the system oid column is ignored, as it has attnum < 1. * This shouldn't matter for correctness, but it saves time. - * ---------- - */ + * ---------- + */ pgLO->res = PQexec(pgLO->conn, "SELECT c.relname, a.attname " "FROM pg_class c, pg_attribute a, pg_type t " @@ -52,43 +52,49 @@ load_lolist( LODumpMaster *pgLO ) " AND c.relkind = 'r' " " AND c.relname NOT LIKE 'pg_%'"); - if (PQresultStatus(pgLO->res) != PGRES_TUPLES_OK) { + if (PQresultStatus(pgLO->res) != PGRES_TUPLES_OK) + { fprintf(stderr, "%s: Failed to get LO OIDs:\n%s", progname, PQerrorMessage(pgLO->conn)); exit(RE_ERROR); } - if ((n = PQntuples(pgLO->res)) == 0) { + if ((n = PQntuples(pgLO->res)) == 0) + { fprintf(stderr, "%s: No OID columns in the database.\n", progname); exit(RE_ERROR); - } - + } + pgLO->lolist = (LOlist *) malloc((n + 1) * sizeof(LOlist)); - - if (!pgLO->lolist) { + + if (!pgLO->lolist) + { fprintf(stderr, "%s: can't allocate memory\n", progname); exit(RE_ERROR); - } - - for (i = 0, ll = pgLO->lolist; i < n; i++, ll++) { + } + + for (i = 0, ll = pgLO->lolist; i < n; i++, ll++) + { ll->lo_table = strdup(PQgetvalue(pgLO->res, i, 0)); - ll->lo_attr = strdup(PQgetvalue(pgLO->res, i, 1)); + ll->lo_attr = strdup(PQgetvalue(pgLO->res, i, 1)); } - ll->lo_table = ll->lo_attr = (char *) NULL; - + ll->lo_table = ll->lo_attr = (char *) NULL; + PQclear(pgLO->res); } -void -pglo_export(LODumpMaster *pgLO) +void +pglo_export(LODumpMaster * pgLO) { - LOlist *ll; - int tuples; + LOlist *ll; + int tuples; char path[BUFSIZ], - Qbuff[QUERY_BUFSIZ]; - - if (pgLO->action != ACTION_SHOW) { - time_t t; + Qbuff[QUERY_BUFSIZ]; + + if (pgLO->action != ACTION_SHOW) + { + time_t t; + time(&t); fprintf(pgLO->index, "#\n# This is the PostgreSQL large object dump index\n#\n"); fprintf(pgLO->index, "#\tDate: %s", ctime(&t)); @@ -97,90 +103,102 @@ pglo_export(LODumpMaster *pgLO) fprintf(pgLO->index, "#\tUser: %s\n", pgLO->user); fprintf(pgLO->index, "#\n# oid\ttable\tattribut\tinfile\n#\n"); } - + pgLO->counter = 0; - for(ll=pgLO->lolist; ll->lo_table != NULL; ll++) { - + for (ll = pgLO->lolist; ll->lo_table != NULL; ll++) + { + /* ---------- * Query: find the LOs referenced by this column * ---------- */ sprintf(Qbuff, "SELECT DISTINCT l.loid FROM \"%s\" x, pg_largeobject l WHERE x.\"%s\" = l.loid", ll->lo_table, ll->lo_attr); - + /* puts(Qbuff); */ - + pgLO->res = PQexec(pgLO->conn, Qbuff); - if (PQresultStatus(pgLO->res) != PGRES_TUPLES_OK) { + if (PQresultStatus(pgLO->res) != PGRES_TUPLES_OK) + { fprintf(stderr, "%s: Failed to get LO OIDs:\n%s", progname, PQerrorMessage(pgLO->conn)); - } - else if ((tuples = PQntuples(pgLO->res)) == 0) { + } + else if ((tuples = PQntuples(pgLO->res)) == 0) + { if (!pgLO->quiet && pgLO->action == ACTION_EXPORT_ATTR) printf("%s: no large objects in \"%s\".\"%s\"\n", - progname, ll->lo_table, ll->lo_attr); - } else { - - int t; - char *val; - + progname, ll->lo_table, ll->lo_attr); + } + else + { + + int t; + char *val; + /* ---------- * Create DIR/FILE * ---------- */ - if (pgLO->action != ACTION_SHOW) { - + if (pgLO->action != ACTION_SHOW) + { + sprintf(path, "%s/%s/%s", pgLO->space, pgLO->db, ll->lo_table); - if (mkdir(path, DIR_UMASK) == -1) { - if (errno != EEXIST) { + if (mkdir(path, DIR_UMASK) == -1) + { + if (errno != EEXIST) + { perror(path); - exit(RE_ERROR); - } + exit(RE_ERROR); + } } sprintf(path, "%s/%s/%s/%s", pgLO->space, pgLO->db, - ll->lo_table, ll->lo_attr); - - if (mkdir(path, DIR_UMASK) == -1) { - if (errno != EEXIST) { + ll->lo_table, ll->lo_attr); + + if (mkdir(path, DIR_UMASK) == -1) + { + if (errno != EEXIST) + { perror(path); - exit(RE_ERROR); - } + exit(RE_ERROR); + } } - + if (!pgLO->quiet) - printf("dump %s.%s (%d large obj)\n", - ll->lo_table, ll->lo_attr, tuples); + printf("dump %s.%s (%d large obj)\n", + ll->lo_table, ll->lo_attr, tuples); } pgLO->counter += tuples; - - for(t=0; t<tuples; t++) { - Oid lo; - + + for (t = 0; t < tuples; t++) + { + Oid lo; + val = PQgetvalue(pgLO->res, t, 0); - + lo = atooid(val); - - if (pgLO->action == ACTION_SHOW) { + + if (pgLO->action == ACTION_SHOW) + { printf("%s.%s: %u\n", ll->lo_table, ll->lo_attr, lo); continue; } - - sprintf(path, "%s/%s/%s/%s/%s", pgLO->space, - pgLO->db, ll->lo_table, ll->lo_attr, val); - - if (lo_export(pgLO->conn, lo, path) < 0) + + sprintf(path, "%s/%s/%s/%s/%s", pgLO->space, + pgLO->db, ll->lo_table, ll->lo_attr, val); + + if (lo_export(pgLO->conn, lo, path) < 0) fprintf(stderr, "%s: lo_export failed:\n%s", progname, PQerrorMessage(pgLO->conn)); - - else - fprintf(pgLO->index, "%s\t%s\t%s\t%s/%s/%s/%s\n", val, - ll->lo_table, ll->lo_attr, pgLO->db, ll->lo_table, ll->lo_attr, val); + + else + fprintf(pgLO->index, "%s\t%s\t%s\t%s/%s/%s/%s\n", val, + ll->lo_table, ll->lo_attr, pgLO->db, ll->lo_table, ll->lo_attr, val); } } diff --git a/contrib/pg_dumplo/lo_import.c b/contrib/pg_dumplo/lo_import.c index 996bdf9e27..ff8929d6d6 100644 --- a/contrib/pg_dumplo/lo_import.c +++ b/contrib/pg_dumplo/lo_import.c @@ -1,20 +1,20 @@ /* ------------------------------------------------------------------------- * pg_dumplo * - * $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/lo_import.c,v 1.3 2001/01/24 19:42:45 momjian Exp $ + * $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/lo_import.c,v 1.4 2001/03/22 03:59:10 momjian Exp $ * * Karel Zak 1999-2000 * ------------------------------------------------------------------------- */ -#include <stdio.h> +#include <stdio.h> #include <unistd.h> #include <stdlib.h> #include <string.h> #include <sys/stat.h> #include <sys/types.h> #include <fcntl.h> -#include <errno.h> +#include <errno.h> #include <time.h> #include <libpq-fe.h> @@ -22,76 +22,82 @@ #include "pg_dumplo.h" -extern int errno; +extern int errno; -void -pglo_import(LODumpMaster *pgLO) +void +pglo_import(LODumpMaster * pgLO) { LOlist loa; - Oid new_oid; - char tab[MAX_TABLE_NAME], attr[MAX_ATTR_NAME], - path[BUFSIZ], lo_path[BUFSIZ], - Qbuff[QUERY_BUFSIZ]; - - while(fgets(Qbuff, QUERY_BUFSIZ, pgLO->index)) { - + Oid new_oid; + char tab[MAX_TABLE_NAME], + attr[MAX_ATTR_NAME], + path[BUFSIZ], + lo_path[BUFSIZ], + Qbuff[QUERY_BUFSIZ]; + + while (fgets(Qbuff, QUERY_BUFSIZ, pgLO->index)) + { + if (*Qbuff == '#') continue; - if (! pgLO->remove && ! pgLO->quiet) + if (!pgLO->remove && !pgLO->quiet) printf(Qbuff); - - sscanf(Qbuff, "%u\t%s\t%s\t%s\n", &loa.lo_oid, tab, attr, path); + + sscanf(Qbuff, "%u\t%s\t%s\t%s\n", &loa.lo_oid, tab, attr, path); loa.lo_table = tab; - loa.lo_attr = attr; + loa.lo_attr = attr; - sprintf(lo_path, "%s/%s", pgLO->space, path); + sprintf(lo_path, "%s/%s", pgLO->space, path); /* ---------- * Import LO * ---------- */ - if ((new_oid = lo_import(pgLO->conn, lo_path)) == 0) { - + if ((new_oid = lo_import(pgLO->conn, lo_path)) == 0) + { + fprintf(stderr, "%s: %s\n", progname, PQerrorMessage(pgLO->conn)); - + PQexec(pgLO->conn, "ROLLBACK"); fprintf(stderr, "\n%s: ROLLBACK\n", progname); exit(RE_ERROR); } - if (pgLO->remove) { + if (pgLO->remove) + { notice(pgLO, FALSE); - if (lo_unlink(pgLO->conn, loa.lo_oid) < 0) - fprintf(stderr, "%s: can't remove LO %u:\n%s", - progname, loa.lo_oid, PQerrorMessage(pgLO->conn)); - + if (lo_unlink(pgLO->conn, loa.lo_oid) < 0) + fprintf(stderr, "%s: can't remove LO %u:\n%s", + progname, loa.lo_oid, PQerrorMessage(pgLO->conn)); + else if (!pgLO->quiet) - printf("remove old %u and create new %u\n", - loa.lo_oid, new_oid); - notice(pgLO, TRUE); + printf("remove old %u and create new %u\n", + loa.lo_oid, new_oid); + notice(pgLO, TRUE); } - + pgLO->counter++; - + /* ---------- * UPDATE oid in tab * ---------- */ - sprintf(Qbuff, "UPDATE \"%s\" SET \"%s\"=%u WHERE \"%s\"=%u", + sprintf(Qbuff, "UPDATE \"%s\" SET \"%s\"=%u WHERE \"%s\"=%u", loa.lo_table, loa.lo_attr, new_oid, loa.lo_attr, loa.lo_oid); - /*fprintf(stderr, Qbuff);*/ - + /* fprintf(stderr, Qbuff); */ + pgLO->res = PQexec(pgLO->conn, Qbuff); - - if (PQresultStatus(pgLO->res) != PGRES_COMMAND_OK) { - fprintf(stderr, "%s: %s\n",progname, PQerrorMessage(pgLO->conn)); + + if (PQresultStatus(pgLO->res) != PGRES_COMMAND_OK) + { + fprintf(stderr, "%s: %s\n", progname, PQerrorMessage(pgLO->conn)); PQclear(pgLO->res); PQexec(pgLO->conn, "ROLLBACK"); fprintf(stderr, "\n%s: ROLLBACK\n", progname); exit(RE_ERROR); - } + } PQclear(pgLO->res); - } - } + } +} diff --git a/contrib/pg_dumplo/main.c b/contrib/pg_dumplo/main.c index e8ff2f72e0..3878aeca02 100644 --- a/contrib/pg_dumplo/main.c +++ b/contrib/pg_dumplo/main.c @@ -1,7 +1,7 @@ /* ------------------------------------------------------------------------- * pg_dumplo * - * $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/main.c,v 1.6 2001/02/10 02:31:25 tgl Exp $ + * $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/main.c,v 1.7 2001/03/22 03:59:10 momjian Exp $ * * Karel Zak 1999-2000 * ------------------------------------------------------------------------- @@ -12,238 +12,254 @@ #include "postgres_fe.h" #endif -#include <stdio.h> +#include <stdio.h> #include <unistd.h> #include <stdlib.h> #include <string.h> -#include <errno.h> +#include <errno.h> #include <libpq-fe.h> #include <libpq/libpq-fs.h> -#include "pg_dumplo.h" +#include "pg_dumplo.h" #ifdef HAVE_GETOPT_LONG - #include <getopt.h> - #define no_argument 0 - #define required_argument 1 +#include <getopt.h> +#define no_argument 0 +#define required_argument 1 #endif - -extern int errno; -char *progname = NULL; +extern int errno; -int main(int argc, char **argv); +char *progname = NULL; + +int main(int argc, char **argv); static void usage(void); -static void parse_lolist (LODumpMaster *pgLO); - +static void parse_lolist(LODumpMaster * pgLO); + /*----- * The mother of all C functions *----- */ -int +int main(int argc, char **argv) -{ - LODumpMaster _pgLO, *pgLO = &_pgLO; - char *pwd = NULL; - - pgLO->argv = argv; - pgLO->argc = argc; - pgLO->action = 0; - pgLO->lolist = NULL; - pgLO->user = NULL; - pgLO->db = NULL; - pgLO->host = NULL; - pgLO->space = NULL; - pgLO->index = NULL; - pgLO->remove = FALSE; - pgLO->quiet = FALSE; - pgLO->counter = 0; +{ + LODumpMaster _pgLO, + *pgLO = &_pgLO; + char *pwd = NULL; + + pgLO->argv = argv; + pgLO->argc = argc; + pgLO->action = 0; + pgLO->lolist = NULL; + pgLO->user = NULL; + pgLO->db = NULL; + pgLO->host = NULL; + pgLO->space = NULL; + pgLO->index = NULL; + pgLO->remove = FALSE; + pgLO->quiet = FALSE; + pgLO->counter = 0; pgLO->lolist_start = 0; - + progname = argv[0]; /* ---------- * Parse ARGV * ---------- */ - if (argc > 1) { - int arg; - extern int optind; - -#ifdef HAVE_GETOPT_LONG - int l_index=0; - static struct option l_opt[] = { - { "help", no_argument, 0, 'h' }, - { "user", required_argument, 0, 'u' }, - { "pwd", required_argument, 0, 'p' }, - { "db", required_argument, 0, 'd' }, - { "host", required_argument, 0, 'h' }, - { "space", required_argument, 0, 's' }, - { "import", no_argument, 0, 'i' }, - { "export", no_argument, 0, 'e' }, - { "remove", no_argument, 0, 'r' }, - { "quiet", no_argument, 0, 'q' }, - { "all", no_argument, 0, 'a' }, - { "show", no_argument, 0, 'w' }, - { NULL, 0, 0, 0 } - }; - - while((arg = getopt_long(argc, argv, "?aehu:p:qd:l:t:irs:w", l_opt, &l_index)) != -1) { + if (argc > 1) + { + int arg; + extern int optind; + +#ifdef HAVE_GETOPT_LONG + int l_index = 0; + static struct option l_opt[] = { + {"help", no_argument, 0, 'h'}, + {"user", required_argument, 0, 'u'}, + {"pwd", required_argument, 0, 'p'}, + {"db", required_argument, 0, 'd'}, + {"host", required_argument, 0, 'h'}, + {"space", required_argument, 0, 's'}, + {"import", no_argument, 0, 'i'}, + {"export", no_argument, 0, 'e'}, + {"remove", no_argument, 0, 'r'}, + {"quiet", no_argument, 0, 'q'}, + {"all", no_argument, 0, 'a'}, + {"show", no_argument, 0, 'w'}, + {NULL, 0, 0, 0} + }; + + while ((arg = getopt_long(argc, argv, "?aehu:p:qd:l:t:irs:w", l_opt, &l_index)) != -1) + { #else - while((arg = getopt(argc, argv, "?aehu:p:qd:l:t:irs:w")) != -1) { + while ((arg = getopt(argc, argv, "?aehu:p:qd:l:t:irs:w")) != -1) + { #endif - switch(arg) { - case '?': - case 'h': - usage(); + switch (arg) + { + case '?': + case 'h': + usage(); exit(RE_OK); - case 'u': - pgLO->user = strdup(optarg); - break; - case 't': - pgLO->host = strdup(optarg); - break; - case 'p': - pwd = strdup(optarg); - break; - case 'd': - pgLO->db = strdup(optarg); - break; - case 's': - pgLO->space = strdup(optarg); - break; - case 'i': - pgLO->action = ACTION_IMPORT; - break; - case 'l': - pgLO->action = ACTION_EXPORT_ATTR; - pgLO->lolist_start = optind-1; - parse_lolist (pgLO); - break; - case 'e': - case 'a': + case 'u': + pgLO->user = strdup(optarg); + break; + case 't': + pgLO->host = strdup(optarg); + break; + case 'p': + pwd = strdup(optarg); + break; + case 'd': + pgLO->db = strdup(optarg); + break; + case 's': + pgLO->space = strdup(optarg); + break; + case 'i': + pgLO->action = ACTION_IMPORT; + break; + case 'l': + pgLO->action = ACTION_EXPORT_ATTR; + pgLO->lolist_start = optind - 1; + parse_lolist(pgLO); + break; + case 'e': + case 'a': pgLO->action = ACTION_EXPORT_ALL; break; case 'w': pgLO->action = ACTION_SHOW; - break; - case 'r': - pgLO->remove = TRUE; - break; - case 'q': - pgLO->quiet = TRUE; - break; - default: - fprintf(stderr, "%s: bad arg -%c\n", progname, arg); - usage(); - exit(RE_ERROR); + break; + case 'r': + pgLO->remove = TRUE; + break; + case 'q': + pgLO->quiet = TRUE; + break; + default: + fprintf(stderr, "%s: bad arg -%c\n", progname, arg); + usage(); + exit(RE_ERROR); } - } - } else { + } + } + else + { usage(); - exit(RE_ERROR); - } + exit(RE_ERROR); + } /* ---------- * Check space * ---------- */ - if (! pgLO->space && ! pgLO->action == ACTION_SHOW) { - if (!(pgLO->space = getenv("PWD"))) { + if (!pgLO->space && !pgLO->action == ACTION_SHOW) + { + if (!(pgLO->space = getenv("PWD"))) + { fprintf(stderr, "%s: not set space for dump-tree (option '-s' or $PWD).\n", progname); exit(RE_ERROR); - } + } } - - if (!pgLO->action) { + + if (!pgLO->action) + { fprintf(stderr, "%s: What do you want - export or import?\n", progname); exit(RE_ERROR); } - + /* ---------- * Make connection * ---------- */ - pgLO->conn = PQsetdbLogin(pgLO->host, NULL, NULL, NULL, pgLO->db, - pgLO->user, pwd); - - if (PQstatus(pgLO->conn) == CONNECTION_BAD) { + pgLO->conn = PQsetdbLogin(pgLO->host, NULL, NULL, NULL, pgLO->db, + pgLO->user, pwd); + + if (PQstatus(pgLO->conn) == CONNECTION_BAD) + { fprintf(stderr, "%s (connection): %s\n", progname, PQerrorMessage(pgLO->conn)); exit(RE_ERROR); - } + } pgLO->host = PQhost(pgLO->conn) ? PQhost(pgLO->conn) : "localhost"; - pgLO->db = PQdb(pgLO->conn); - pgLO->user = PQuser(pgLO->conn); - - + pgLO->db = PQdb(pgLO->conn); + pgLO->user = PQuser(pgLO->conn); + + /* ---------- * Init index file * ---------- */ - if (pgLO->action != ACTION_SHOW) + if (pgLO->action != ACTION_SHOW) index_file(pgLO); - + PQexec(pgLO->conn, "BEGIN"); - switch(pgLO->action) { - + switch (pgLO->action) + { + case ACTION_SHOW: case ACTION_EXPORT_ALL: load_lolist(pgLO); /* FALL THROUGH */ - + case ACTION_EXPORT_ATTR: pglo_export(pgLO); - if (!pgLO->quiet) { + if (!pgLO->quiet) + { if (pgLO->action == ACTION_SHOW) printf("\nDatabase '%s' contains %d large objects.\n\n", pgLO->db, pgLO->counter); - else + else printf("\nExported %d large objects.\n\n", pgLO->counter); } break; - + case ACTION_IMPORT: pglo_import(pgLO); if (!pgLO->quiet) printf("\nImported %d large objects.\n\n", pgLO->counter); - break; - } + break; + } PQexec(pgLO->conn, "COMMIT"); - PQfinish(pgLO->conn); - + PQfinish(pgLO->conn); + if (pgLO->action != ACTION_SHOW) fclose(pgLO->index); - + exit(RE_OK); } static void -parse_lolist (LODumpMaster *pgLO) +parse_lolist(LODumpMaster * pgLO) { - LOlist *ll; - char **d, - *loc, - buff[MAX_TABLE_NAME + MAX_ATTR_NAME +1]; + LOlist *ll; + char **d, + *loc, + buff[MAX_TABLE_NAME + MAX_ATTR_NAME + 1]; pgLO->lolist = (LOlist *) malloc(pgLO->argc * sizeof(LOlist)); - - if (! pgLO->lolist) { + + if (!pgLO->lolist) + { fprintf(stderr, "%s: can't allocate memory\n", progname); exit(RE_ERROR); } - - for( d=pgLO->argv + pgLO->lolist_start, ll=pgLO->lolist; - *d != NULL; - d++, ll++) { - + + for (d = pgLO->argv + pgLO->lolist_start, ll = pgLO->lolist; + *d != NULL; + d++, ll++) + { + strncpy(buff, *d, MAX_TABLE_NAME + MAX_ATTR_NAME); - - if ((loc = strchr(buff, '.')) == NULL) { + + if ((loc = strchr(buff, '.')) == NULL) + { fprintf(stderr, "%s: '%s' is bad 'table.attr'\n", progname, buff); - exit(RE_ERROR); + exit(RE_ERROR); } *loc = '\0'; ll->lo_table = strdup(buff); @@ -254,55 +270,55 @@ parse_lolist (LODumpMaster *pgLO) } -static void +static void usage() { printf("\npg_dumplo %s - PostgreSQL large objects dump\n", VERSION); - puts("pg_dumplo [option]\n\n" + puts("pg_dumplo [option]\n\n" #ifdef HAVE_GETOPT_LONG - - "-h --help this help\n" - "-u --user=<username> username for connection to server\n" - "-p --password=<password> password for connection to server\n" - "-d --db=<database> database name\n" - "-t --host=<hostname> server hostname\n" - "-s --space=<dir> directory with dump tree (for export/import)\n" - "-i --import import large obj dump tree to DB\n" - "-e --export export (dump) large obj to dump tree\n" - "-l <table.attr ...> dump attribute (columns) with LO to dump tree\n" - "-a --all dump all LO in DB (default)\n" - "-r --remove if is set '-i' try remove old LO\n" - "-q --quiet run quietly\n" - "-w --show not dump, but show all LO in DB\n" - ); /* puts() */ + + "-h --help this help\n" + "-u --user=<username> username for connection to server\n" + "-p --password=<password> password for connection to server\n" + "-d --db=<database> database name\n" + "-t --host=<hostname> server hostname\n" + "-s --space=<dir> directory with dump tree (for export/import)\n" + "-i --import import large obj dump tree to DB\n" + "-e --export export (dump) large obj to dump tree\n" + "-l <table.attr ...> dump attribute (columns) with LO to dump tree\n" + "-a --all dump all LO in DB (default)\n" + "-r --remove if is set '-i' try remove old LO\n" + "-q --quiet run quietly\n" + "-w --show not dump, but show all LO in DB\n" + ); /* puts() */ #else - "-h this help\n" - "-u <username> username for connection to server\n" - "-p <password> password for connection to server\n" - "-d <database> database name\n" - "-t <hostname> server hostname\n" - "-s <dir> directory with dump tree (for export/import)\n" - "-i import large obj dump tree to DB\n" - "-e export (dump) large obj to dump tree\n" - "-l <table.attr ...> dump attribute (columns) with LO to dump tree\n" - "-a dump all LO in DB (default)\n" - "-r if is set '-i' try remove old LO\n" - "-q run quietly\n" - "-w not dump, but show all LO in DB\n" - ); /* puts() */ + "-h this help\n" + "-u <username> username for connection to server\n" + "-p <password> password for connection to server\n" + "-d <database> database name\n" + "-t <hostname> server hostname\n" + "-s <dir> directory with dump tree (for export/import)\n" + "-i import large obj dump tree to DB\n" + "-e export (dump) large obj to dump tree\n" + "-l <table.attr ...> dump attribute (columns) with LO to dump tree\n" + "-a dump all LO in DB (default)\n" + "-r if is set '-i' try remove old LO\n" + "-q run quietly\n" + "-w not dump, but show all LO in DB\n" + ); /* puts() */ #endif puts( - "Example (dump): pg_dumplo -d my_db -s /my_dump/dir -l t1.a t1.b t2.a\n" - " pg_dumplo -a -d my_db -s /my_dump/dir\n" - "Example (import): pg_dumplo -i -d my_db -s /my_dump/dir\n" - "Example (show): pg_dumplo -w -d my_db\n\n" - "Note: * option '-l' must be last option!\n" - " * option '-i' without option '-r' make new large obj in DB\n" - " not rewrite old, the '-i' UPDATE oid numbers in table.attr only!\n" - " * if is not set option -s, the pg_dumplo use $PWD\n" - ); /* puts()*/ + "Example (dump): pg_dumplo -d my_db -s /my_dump/dir -l t1.a t1.b t2.a\n" + " pg_dumplo -a -d my_db -s /my_dump/dir\n" + "Example (import): pg_dumplo -i -d my_db -s /my_dump/dir\n" + "Example (show): pg_dumplo -w -d my_db\n\n" + "Note: * option '-l' must be last option!\n" + " * option '-i' without option '-r' make new large obj in DB\n" + " not rewrite old, the '-i' UPDATE oid numbers in table.attr only!\n" + " * if is not set option -s, the pg_dumplo use $PWD\n" + ); /* puts() */ } diff --git a/contrib/pg_dumplo/pg_dumplo.h b/contrib/pg_dumplo/pg_dumplo.h index 7513c71b9b..3ab25495cb 100644 --- a/contrib/pg_dumplo/pg_dumplo.h +++ b/contrib/pg_dumplo/pg_dumplo.h @@ -1,7 +1,7 @@ /* ------------------------------------------------------------------------- * pg_dumplo * - * $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/pg_dumplo.h,v 1.3 2001/01/24 19:42:45 momjian Exp $ + * $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/pg_dumplo.h,v 1.4 2001/03/22 03:59:10 momjian Exp $ * * Karel Zak 1999-2000 * ------------------------------------------------------------------------- @@ -17,12 +17,12 @@ /* ---------- * Define * ---------- - */ + */ #define QUERY_BUFSIZ (8*1024) #define DIR_UMASK 0755 #define FILE_UMASK 0644 -#define TRUE 1 +#define TRUE 1 #define FALSE 0 #define RE_OK 0 #define RE_ERROR 1 @@ -36,44 +36,47 @@ * LO struct * ---------- */ -typedef struct { - char *lo_table, - *lo_attr; - Oid lo_oid; -} LOlist; +typedef struct +{ + char *lo_table, + *lo_attr; + Oid lo_oid; +} LOlist; -typedef struct { - int action; - LOlist *lolist; - char **argv, - *user, - *db, - *host, - *space; - FILE *index; - int counter, - argc, - lolist_start, - remove, - quiet; - PGresult *res; - PGconn *conn; -} LODumpMaster; +typedef struct +{ + int action; + LOlist *lolist; + char **argv, + *user, + *db, + *host, + *space; + FILE *index; + int counter, + argc, + lolist_start, + remove, + quiet; + PGresult *res; + PGconn *conn; +} LODumpMaster; -typedef enum { +typedef enum +{ ACTION_NONE, ACTION_SHOW, - ACTION_EXPORT_ATTR, - ACTION_EXPORT_ALL, + ACTION_EXPORT_ATTR, + ACTION_EXPORT_ALL, ACTION_IMPORT -} PGLODUMP_ACTIONS; +} PGLODUMP_ACTIONS; extern char *progname; -extern void notice (LODumpMaster *pgLO, int set); -extern void index_file (LODumpMaster *pgLO); -extern void load_lolist (LODumpMaster *pgLO); -extern void pglo_export (LODumpMaster *pgLO); -extern void pglo_import (LODumpMaster *pgLO); +extern void notice(LODumpMaster * pgLO, int set); +extern void index_file(LODumpMaster * pgLO); +extern void load_lolist(LODumpMaster * pgLO); +extern void pglo_export(LODumpMaster * pgLO); +extern void pglo_import(LODumpMaster * pgLO); -#endif /* PG_DUMPLO_H */ +#endif /* PG_DUMPLO_H */ diff --git a/contrib/pg_dumplo/utils.c b/contrib/pg_dumplo/utils.c index dc3f5bbf9a..d36ee4be08 100644 --- a/contrib/pg_dumplo/utils.c +++ b/contrib/pg_dumplo/utils.c @@ -1,20 +1,20 @@ /* ------------------------------------------------------------------------- * pg_dumplo * - * $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/utils.c,v 1.3 2001/01/24 19:42:45 momjian Exp $ + * $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/utils.c,v 1.4 2001/03/22 03:59:10 momjian Exp $ * * Karel Zak 1999-2000 * ------------------------------------------------------------------------- */ -#include <stdio.h> +#include <stdio.h> #include <unistd.h> #include <stdlib.h> #include <string.h> #include <sys/stat.h> #include <sys/types.h> #include <fcntl.h> -#include <errno.h> +#include <errno.h> #include <time.h> #include <libpq-fe.h> @@ -22,65 +22,76 @@ #include "pg_dumplo.h" -extern int errno; +extern int errno; + +static void Dummy_NoticeProcessor(void *arg, const char *message); +static void Default_NoticeProcessor(void *arg, const char *message); -static void Dummy_NoticeProcessor(void * arg, const char * message); -static void Default_NoticeProcessor(void * arg, const char * message); - void -index_file(LODumpMaster *pgLO) +index_file(LODumpMaster * pgLO) { - char path[BUFSIZ]; + char path[BUFSIZ]; if (pgLO->action == ACTION_SHOW) return; - - sprintf(path, "%s/%s", pgLO->space, pgLO->db); - + + sprintf(path, "%s/%s", pgLO->space, pgLO->db); + if (pgLO->action == ACTION_EXPORT_ATTR || - pgLO->action == ACTION_EXPORT_ALL) { - - if (mkdir(path, DIR_UMASK) == -1) { - if (errno != EEXIST) { + pgLO->action == ACTION_EXPORT_ALL) + { + + if (mkdir(path, DIR_UMASK) == -1) + { + if (errno != EEXIST) + { perror(path); - exit(RE_ERROR); - } + exit(RE_ERROR); + } } - - sprintf(path, "%s/lo_dump.index", path); - if ((pgLO->index = fopen(path, "w")) == NULL) { + sprintf(path, "%s/lo_dump.index", path); + + if ((pgLO->index = fopen(path, "w")) == NULL) + { perror(path); exit(RE_ERROR); } - - } else if (pgLO->action != ACTION_NONE ) { - - sprintf(path, "%s/lo_dump.index", path); - if ((pgLO->index = fopen(path, "r")) == NULL) { + } + else if (pgLO->action != ACTION_NONE) + { + + sprintf(path, "%s/lo_dump.index", path); + + if ((pgLO->index = fopen(path, "r")) == NULL) + { perror(path); exit(RE_ERROR); } } } -static -void Dummy_NoticeProcessor(void * arg, const char * message) +static +void +Dummy_NoticeProcessor(void *arg, const char *message) { - ; + ; } -static -void Default_NoticeProcessor(void * arg, const char * message) +static +void +Default_NoticeProcessor(void *arg, const char *message) { - fprintf(stderr, "%s", message); + fprintf(stderr, "%s", message); } -void -notice(LODumpMaster *pgLO, int set) -{ - if (set)PQsetNoticeProcessor(pgLO->conn, Default_NoticeProcessor, NULL); - else PQsetNoticeProcessor(pgLO->conn, Dummy_NoticeProcessor, NULL); +void +notice(LODumpMaster * pgLO, int set) +{ + if (set) + PQsetNoticeProcessor(pgLO->conn, Default_NoticeProcessor, NULL); + else + PQsetNoticeProcessor(pgLO->conn, Dummy_NoticeProcessor, NULL); } diff --git a/contrib/pg_logger/pg_logger.c b/contrib/pg_logger/pg_logger.c index af56a249c6..cc2fdbed30 100644 --- a/contrib/pg_logger/pg_logger.c +++ b/contrib/pg_logger/pg_logger.c @@ -2,10 +2,10 @@ * * Copyright 2001 by Nathan Myers <[email protected]> * This software is distributed free of charge with no warranty of any kind. - * You have permission to make copies for any purpose, provided that (1) - * this copyright notice is retained unchanged, and (2) you agree to - * absolve the author of all responsibility for all consequences arising - * from any use. + * You have permission to make copies for any purpose, provided that (1) + * this copyright notice is retained unchanged, and (2) you agree to + * absolve the author of all responsibility for all consequences arising + * from any use. */ #include <stdio.h> @@ -13,73 +13,94 @@ #include <syslog.h> #include <string.h> -struct { - const char *tag; - int size; - int priority; -} tags[] = { - { "", 0, LOG_NOTICE }, - { "emerg:", sizeof("emerg"), LOG_EMERG }, - { "alert:", sizeof("alert"), LOG_ALERT }, - { "crit:", sizeof("crit"), LOG_CRIT }, - { "err:", sizeof("err"), LOG_ERR }, - { "error:", sizeof("error"), LOG_ERR }, - { "warning:", sizeof("warning"), LOG_WARNING }, - { "notice:", sizeof("notice"), LOG_NOTICE }, - { "info:", sizeof("info"), LOG_INFO }, - { "debug:", sizeof("debug"), LOG_DEBUG } +struct +{ + const char *tag; + int size; + int priority; +} tags[] = + +{ + { + "", 0, LOG_NOTICE + }, + { + "emerg:", sizeof("emerg"), LOG_EMERG + }, + { + "alert:", sizeof("alert"), LOG_ALERT + }, + { + "crit:", sizeof("crit"), LOG_CRIT + }, + { + "err:", sizeof("err"), LOG_ERR + }, + { + "error:", sizeof("error"), LOG_ERR + }, + { + "warning:", sizeof("warning"), LOG_WARNING + }, + { + "notice:", sizeof("notice"), LOG_NOTICE + }, + { + "info:", sizeof("info"), LOG_INFO + }, + { + "debug:", sizeof("debug"), LOG_DEBUG + } }; -int main() +int +main() { - char buf[301]; - int c; - char *pos = buf; - const char *colon = 0; + char buf[301]; + int c; + char *pos = buf; + const char *colon = 0; #ifndef DEBUG - openlog("postgresql", LOG_CONS, LOG_LOCAL1); + openlog("postgresql", LOG_CONS, LOG_LOCAL1); #endif - while ( (c = getchar()) != EOF) { - if (c == '\r') { - continue; - } - if (c == '\n') { - int level = sizeof(tags)/sizeof(*tags); - char *bol; + while ((c = getchar()) != EOF) + { + if (c == '\r') + continue; + if (c == '\n') + { + int level = sizeof(tags) / sizeof(*tags); + char *bol; - if (colon == 0 || (size_t)(colon - buf) > sizeof("warning")) { - level = 1; - } - *pos = 0; - while (--level) { - if (pos - buf >= tags[level].size - && strncmp(buf, tags[level].tag, tags[level].size) == 0) { - break; - } - } - bol = buf + tags[level].size; - if (bol > buf && *bol == ' ') { - ++bol; - } - if (pos - bol > 0) { + if (colon == 0 || (size_t) (colon - buf) > sizeof("warning")) + level = 1; + *pos = 0; + while (--level) + { + if (pos - buf >= tags[level].size + && strncmp(buf, tags[level].tag, tags[level].size) == 0) + break; + } + bol = buf + tags[level].size; + if (bol > buf && *bol == ' ') + ++bol; + if (pos - bol > 0) + { #ifndef DEBUG - syslog(tags[level].priority, "%s", bol); + syslog(tags[level].priority, "%s", bol); #else - printf("%d/%s\n", tags[level].priority, bol); + printf("%d/%s\n", tags[level].priority, bol); #endif - } - pos = buf; - colon = (char const *)0; - continue; - } - if (c == ':' && !colon) { - colon = pos; - } - if ((size_t)(pos - buf) < sizeof(buf)-1) { - *pos++ = c; - } - } - return 0; + } + pos = buf; + colon = (char const *) 0; + continue; + } + if (c == ':' && !colon) + colon = pos; + if ((size_t) (pos - buf) < sizeof(buf) - 1) + *pos++ = c; + } + return 0; } - diff --git a/contrib/pg_resetxlog/pg_resetxlog.c b/contrib/pg_resetxlog/pg_resetxlog.c index 5137cddd91..848bbb9267 100644 --- a/contrib/pg_resetxlog/pg_resetxlog.c +++ b/contrib/pg_resetxlog/pg_resetxlog.c @@ -5,15 +5,15 @@ * Can also rebuild pg_control if needed. * * The theory of operation is fairly simple: - * 1. Read the existing pg_control (which will include the last + * 1. Read the existing pg_control (which will include the last * checkpoint record). If it is an old format then update to * current format. * 2. If pg_control is corrupt, attempt to intuit reasonable values, * by scanning the old xlog if necessary. * 3. Modify pg_control to reflect a "shutdown" state with a checkpoint - * record at the start of xlog. + * record at the start of xlog. * 4. Flush the existing xlog files and write a new segment with - * just a checkpoint record in it. The new segment is positioned + * just a checkpoint record in it. The new segment is positioned * just past the end of the old xlog, so that existing LSNs in * data pages will appear to be "in the past". * This is all pretty straightforward except for the intuition part of @@ -23,7 +23,7 @@ * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group * Portions Copyright (c) 1994, Regents of the University of California * - * $Header: /cvsroot/pgsql/contrib/pg_resetxlog/Attic/pg_resetxlog.c,v 1.2 2001/03/16 05:08:39 tgl Exp $ + * $Header: /cvsroot/pgsql/contrib/pg_resetxlog/Attic/pg_resetxlog.c,v 1.3 2001/03/22 03:59:10 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -63,7 +63,7 @@ * Compute ID and segment from an XLogRecPtr. * * For XLByteToSeg, do the computation at face value. For XLByteToPrevSeg, - * a boundary byte is taken to be in the previous segment. This is suitable + * a boundary byte is taken to be in the previous segment. This is suitable * for deciding which segment to write given a pointer to a record end, * for example. */ @@ -109,8 +109,9 @@ static char *DataDir; /* locations of important stuff */ static char XLogDir[MAXPGPATH]; static char ControlFilePath[MAXPGPATH]; -static ControlFileData ControlFile; /* pg_control values */ -static uint32 newXlogId, newXlogSeg; /* ID/Segment of new XLOG segment */ +static ControlFileData ControlFile; /* pg_control values */ +static uint32 newXlogId, + newXlogSeg; /* ID/Segment of new XLOG segment */ static bool guessed = false; /* T if we had to guess at any values */ @@ -139,17 +140,18 @@ XLogFileOpen(uint32 log, uint32 seg) static bool ReadControlFile(void) { - int fd; - int len; - char *buffer; - crc64 crc; + int fd; + int len; + char *buffer; + crc64 crc; if ((fd = open(ControlFilePath, O_RDONLY)) < 0) { + /* - * If pg_control is not there at all, or we can't read it, - * the odds are we've been handed a bad DataDir path, so give up. - * User can do "touch pg_control" to force us to proceed. + * If pg_control is not there at all, or we can't read it, the + * odds are we've been handed a bad DataDir path, so give up. User + * can do "touch pg_control" to force us to proceed. */ perror("Failed to open $PGDATA/global/pg_control for reading"); if (errno == ENOENT) @@ -175,7 +177,7 @@ ReadControlFile(void) { /* Seems to be current version --- check the CRC. */ INIT_CRC64(crc); - COMP_CRC64(crc, + COMP_CRC64(crc, buffer + sizeof(crc64), sizeof(ControlFileData) - sizeof(crc64)); FIN_CRC64(crc); @@ -193,6 +195,7 @@ ReadControlFile(void) guessed = true; return true; } + /* * Maybe it's a 7.1beta pg_control. */ @@ -217,75 +220,75 @@ ReadControlFile(void) typedef struct crc64V0 { - uint32 crc1; - uint32 crc2; -} crc64V0; + uint32 crc1; + uint32 crc2; +} crc64V0; static uint32 crc_tableV0[] = { -0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, -0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, -0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2, -0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, -0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, -0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, -0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c, -0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59, -0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, -0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, -0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106, -0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433, -0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, -0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, -0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, -0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, -0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, -0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, -0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, -0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, -0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, -0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, -0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84, -0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, -0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, -0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, -0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e, -0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, -0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, -0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, -0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28, -0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d, -0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f, -0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, -0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, -0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777, -0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, -0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, -0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, -0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, -0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, -0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, -0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d + 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, + 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, + 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2, + 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, + 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, + 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, + 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c, + 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59, + 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, + 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, + 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106, + 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433, + 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, + 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, + 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, + 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, + 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, + 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, + 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, + 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, + 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, + 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, + 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84, + 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, + 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, + 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, + 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e, + 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, + 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, + 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, + 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28, + 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d, + 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f, + 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, + 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, + 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777, + 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, + 0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, + 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, + 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, + 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, + 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, + 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d }; #define INIT_CRC64V0(crc) ((crc).crc1 = 0xffffffff, (crc).crc2 = 0xffffffff) #define FIN_CRC64V0(crc) ((crc).crc1 ^= 0xffffffff, (crc).crc2 ^= 0xffffffff) #define COMP_CRC64V0(crc, data, len) \ {\ - uint32 __c1 = (crc).crc1;\ - uint32 __c2 = (crc).crc2;\ - char *__data = (char *) (data);\ - uint32 __len = (len);\ + uint32 __c1 = (crc).crc1;\ + uint32 __c2 = (crc).crc2;\ + char *__data = (char *) (data);\ + uint32 __len = (len);\ \ - while (__len >= 2)\ - {\ - __c1 = crc_tableV0[(__c1 ^ *__data++) & 0xff] ^ (__c1 >> 8);\ - __c2 = crc_tableV0[(__c2 ^ *__data++) & 0xff] ^ (__c2 >> 8);\ - __len -= 2;\ - }\ - if (__len > 0)\ - __c1 = crc_tableV0[(__c1 ^ *__data++) & 0xff] ^ (__c1 >> 8);\ - (crc).crc1 = __c1;\ - (crc).crc2 = __c2;\ + while (__len >= 2)\ + {\ + __c1 = crc_tableV0[(__c1 ^ *__data++) & 0xff] ^ (__c1 >> 8);\ + __c2 = crc_tableV0[(__c2 ^ *__data++) & 0xff] ^ (__c2 >> 8);\ + __len -= 2;\ + }\ + if (__len > 0)\ + __c1 = crc_tableV0[(__c1 ^ *__data++) & 0xff] ^ (__c1 >> 8);\ + (crc).crc1 = __c1;\ + (crc).crc2 = __c2;\ } #define EQ_CRC64V0(c1,c2) ((c1).crc1 == (c2).crc1 && (c1).crc2 == (c2).crc2) @@ -295,51 +298,51 @@ static uint32 crc_tableV0[] = { typedef struct ControlFileDataV0 { - crc64V0 crc; - uint32 logId; /* current log file id */ - uint32 logSeg; /* current log file segment (1-based) */ - XLogRecPtr checkPoint; /* last check point record ptr */ - time_t time; /* time stamp of last modification */ - DBState state; /* see enum above */ - uint32 blcksz; /* block size for this DB */ - uint32 relseg_size; /* blocks per segment of large relation */ - uint32 catalog_version_no; /* internal version number */ - char lc_collate[LOCALE_NAME_BUFLEN_V0]; - char lc_ctype[LOCALE_NAME_BUFLEN_V0]; - char archdir[MAXPGPATH]; /* where to move offline log files */ -} ControlFileDataV0; + crc64V0 crc; + uint32 logId; /* current log file id */ + uint32 logSeg; /* current log file segment (1-based) */ + XLogRecPtr checkPoint; /* last check point record ptr */ + time_t time; /* time stamp of last modification */ + DBState state; /* see enum above */ + uint32 blcksz; /* block size for this DB */ + uint32 relseg_size; /* blocks per segment of large relation */ + uint32 catalog_version_no; /* internal version number */ + char lc_collate[LOCALE_NAME_BUFLEN_V0]; + char lc_ctype[LOCALE_NAME_BUFLEN_V0]; + char archdir[MAXPGPATH]; /* where to move offline log files */ +} ControlFileDataV0; typedef struct CheckPointV0 { - XLogRecPtr redo; /* next RecPtr available when we */ - /* began to create CheckPoint */ - /* (i.e. REDO start point) */ - XLogRecPtr undo; /* first record of oldest in-progress */ - /* transaction when we started */ - /* (i.e. UNDO end point) */ - StartUpID ThisStartUpID; - TransactionId nextXid; - Oid nextOid; - bool Shutdown; -} CheckPointV0; + XLogRecPtr redo; /* next RecPtr available when we */ + /* began to create CheckPoint */ + /* (i.e. REDO start point) */ + XLogRecPtr undo; /* first record of oldest in-progress */ + /* transaction when we started */ + /* (i.e. UNDO end point) */ + StartUpID ThisStartUpID; + TransactionId nextXid; + Oid nextOid; + bool Shutdown; +} CheckPointV0; typedef struct XLogRecordV0 { - crc64V0 xl_crc; - XLogRecPtr xl_prev; /* ptr to previous record in log */ - XLogRecPtr xl_xact_prev; /* ptr to previous record of this xact */ - TransactionId xl_xid; /* xact id */ - uint16 xl_len; /* total len of record *data* */ - uint8 xl_info; - RmgrId xl_rmid; /* resource manager inserted this record */ -} XLogRecordV0; + crc64V0 xl_crc; + XLogRecPtr xl_prev; /* ptr to previous record in log */ + XLogRecPtr xl_xact_prev; /* ptr to previous record of this xact */ + TransactionId xl_xid; /* xact id */ + uint16 xl_len; /* total len of record *data* */ + uint8 xl_info; + RmgrId xl_rmid; /* resource manager inserted this record */ +} XLogRecordV0; #define SizeOfXLogRecordV0 DOUBLEALIGN(sizeof(XLogRecordV0)) typedef struct XLogContRecordV0 { - uint16 xl_len; /* len of data left */ -} XLogContRecordV0; + uint16 xl_len; /* len of data left */ +} XLogContRecordV0; #define SizeOfXLogContRecordV0 DOUBLEALIGN(sizeof(XLogContRecordV0)) @@ -347,16 +350,16 @@ typedef struct XLogContRecordV0 typedef struct XLogPageHeaderDataV0 { - uint32 xlp_magic; - uint16 xlp_info; -} XLogPageHeaderDataV0; + uint32 xlp_magic; + uint16 xlp_info; +} XLogPageHeaderDataV0; #define SizeOfXLogPHDV0 DOUBLEALIGN(sizeof(XLogPageHeaderDataV0)) typedef XLogPageHeaderDataV0 *XLogPageHeaderV0; -static bool RecordIsValidV0(XLogRecordV0 *record); +static bool RecordIsValidV0(XLogRecordV0 * record); static XLogRecordV0 *ReadRecordV0(XLogRecPtr *RecPtr, char *buffer); static bool ValidXLOGHeaderV0(XLogPageHeaderV0 hdr); @@ -376,7 +379,7 @@ CheckControlVersion0(char *buffer, int len) return false; /* Check CRC the version-0 way. */ INIT_CRC64V0(crc); - COMP_CRC64V0(crc, + COMP_CRC64V0(crc, buffer + sizeof(crc64V0), sizeof(ControlFileDataV0) - sizeof(crc64V0)); FIN_CRC64V0(crc); @@ -409,12 +412,13 @@ CheckControlVersion0(char *buffer, int len) (char *) malloc(_INTL_MAXLOGRECSZ)); if (record == NULL) { + /* * We have to guess at the checkpoint contents. */ guessed = true; ControlFile.checkPointCopy.ThisStartUpID = 0; - ControlFile.checkPointCopy.nextXid = (TransactionId) 514; /* XXX */ + ControlFile.checkPointCopy.nextXid = (TransactionId) 514; /* XXX */ ControlFile.checkPointCopy.nextOid = BootstrapObjectIdData; return true; } @@ -435,26 +439,26 @@ CheckControlVersion0(char *buffer, int len) * We assume all of the record has been read into memory at *record. */ static bool -RecordIsValidV0(XLogRecordV0 *record) +RecordIsValidV0(XLogRecordV0 * record) { crc64V0 crc; uint32 len = record->xl_len; /* * NB: this code is not right for V0 records containing backup blocks, - * but for now it's only going to be applied to checkpoint records, - * so I'm not going to worry about it... + * but for now it's only going to be applied to checkpoint records, so + * I'm not going to worry about it... */ INIT_CRC64V0(crc); COMP_CRC64V0(crc, XLogRecGetData(record), len); - COMP_CRC64V0(crc, (char*) record + sizeof(crc64V0), + COMP_CRC64V0(crc, (char *) record + sizeof(crc64V0), SizeOfXLogRecordV0 - sizeof(crc64V0)); FIN_CRC64V0(crc); if (!EQ_CRC64V0(record->xl_crc, crc)) return false; - return(true); + return (true); } /* @@ -489,7 +493,7 @@ ReadRecordV0(XLogRecPtr *RecPtr, char *buffer) readFile = XLogFileOpen(readId, readSeg); if (readFile < 0) goto next_record_is_invalid; - readOff = (uint32) (-1); /* force read to occur below */ + readOff = (uint32) (-1);/* force read to occur below */ } targetPageOff = ((RecPtr->xrecoff % XLogSegSize) / BLCKSZ) * BLCKSZ; @@ -510,10 +514,13 @@ ReadRecordV0(XLogRecPtr *RecPtr, char *buffer) if (record->xl_len == 0) goto next_record_is_invalid; + /* - * Compute total length of record including any appended backup blocks. + * Compute total length of record including any appended backup + * blocks. */ total_len = SizeOfXLogRecordV0 + record->xl_len; + /* * Make sure it will fit in buffer (currently, it is mechanically * impossible for this test to fail, but it seems like a good idea @@ -526,7 +533,7 @@ ReadRecordV0(XLogRecPtr *RecPtr, char *buffer) { /* Need to reassemble record */ XLogContRecordV0 *contrecord; - uint32 gotlen = len; + uint32 gotlen = len; memcpy(buffer, record, len); record = (XLogRecordV0 *) buffer; @@ -551,13 +558,13 @@ ReadRecordV0(XLogRecPtr *RecPtr, char *buffer) if (!(((XLogPageHeaderV0) readBuf)->xlp_info & XLP_FIRST_IS_CONTRECORD)) goto next_record_is_invalid; contrecord = (XLogContRecordV0 *) ((char *) readBuf + SizeOfXLogPHDV0); - if (contrecord->xl_len == 0 || + if (contrecord->xl_len == 0 || total_len != (contrecord->xl_len + gotlen)) goto next_record_is_invalid; len = BLCKSZ - SizeOfXLogPHDV0 - SizeOfXLogContRecordV0; if (contrecord->xl_len > len) { - memcpy(buffer, (char *)contrecord + SizeOfXLogContRecordV0, len); + memcpy(buffer, (char *) contrecord + SizeOfXLogContRecordV0, len); gotlen += len; buffer += len; continue; @@ -587,7 +594,7 @@ next_record_is_invalid:; * Check whether the xlog header of a page just read in looks valid. * * This is just a convenience subroutine to avoid duplicated code in - * ReadRecord. It's not intended for use from anywhere else. + * ReadRecord. It's not intended for use from anywhere else. */ static bool ValidXLOGHeaderV0(XLogPageHeaderV0 hdr) @@ -610,6 +617,7 @@ GuessControlValues(void) { #ifdef USE_LOCALE char *localeptr; + #endif /* @@ -625,7 +633,7 @@ GuessControlValues(void) ControlFile.checkPointCopy.redo.xrecoff = SizeOfXLogPHD; ControlFile.checkPointCopy.undo = ControlFile.checkPointCopy.redo; ControlFile.checkPointCopy.ThisStartUpID = 0; - ControlFile.checkPointCopy.nextXid = (TransactionId) 514; /* XXX */ + ControlFile.checkPointCopy.nextXid = (TransactionId) 514; /* XXX */ ControlFile.checkPointCopy.nextOid = BootstrapObjectIdData; ControlFile.checkPointCopy.time = time(NULL); @@ -677,7 +685,7 @@ PrintControlValues(void) "pg_control version number: %u\n" "Catalog version number: %u\n" "Current log file id: %u\n" - "Next log file segment: %u\n" + "Next log file segment: %u\n" "Latest checkpoint's StartUpID: %u\n" "Latest checkpoint's NextXID: %u\n" "Latest checkpoint's NextOID: %u\n" @@ -707,11 +715,11 @@ static void RewriteControlFile(void) { int fd; - char buffer[BLCKSZ]; /* need not be aligned */ + char buffer[BLCKSZ]; /* need not be aligned */ /* - * Adjust fields as needed to force an empty XLOG starting at the - * next available segment. + * Adjust fields as needed to force an empty XLOG starting at the next + * available segment. */ newXlogId = ControlFile.logId; newXlogSeg = ControlFile.logSeg; @@ -734,17 +742,17 @@ RewriteControlFile(void) /* Contents are protected with a CRC */ INIT_CRC64(ControlFile.crc); - COMP_CRC64(ControlFile.crc, - (char*) &ControlFile + sizeof(crc64), + COMP_CRC64(ControlFile.crc, + (char *) &ControlFile + sizeof(crc64), sizeof(ControlFileData) - sizeof(crc64)); FIN_CRC64(ControlFile.crc); /* - * We write out BLCKSZ bytes into pg_control, zero-padding the - * excess over sizeof(ControlFileData). This reduces the odds - * of premature-EOF errors when reading pg_control. We'll still - * fail when we check the contents of the file, but hopefully with - * a more specific error than "couldn't read pg_control". + * We write out BLCKSZ bytes into pg_control, zero-padding the excess + * over sizeof(ControlFileData). This reduces the odds of + * premature-EOF errors when reading pg_control. We'll still fail + * when we check the contents of the file, but hopefully with a more + * specific error than "couldn't read pg_control". */ if (sizeof(ControlFileData) > BLCKSZ) { @@ -786,9 +794,9 @@ RewriteControlFile(void) static void KillExistingXLOG(void) { - DIR *xldir; - struct dirent *xlde; - char path[MAXPGPATH]; + DIR *xldir; + struct dirent *xlde; + char path[MAXPGPATH]; xldir = opendir(XLogDir); if (xldir == NULL) @@ -803,7 +811,7 @@ KillExistingXLOG(void) if (strlen(xlde->d_name) == 16 && strspn(xlde->d_name, "0123456789ABCDEF") == 16) { - sprintf(path, "%s%c%s", XLogDir, SEP_CHAR, xlde->d_name); + sprintf(path, "%s%c%s", XLogDir, SEP_CHAR, xlde->d_name); if (unlink(path) < 0) { perror(path); @@ -858,7 +866,7 @@ WriteEmptyXLOG(void) INIT_CRC64(crc); COMP_CRC64(crc, &ControlFile.checkPointCopy, sizeof(CheckPoint)); - COMP_CRC64(crc, (char*) record + sizeof(crc64), + COMP_CRC64(crc, (char *) record + sizeof(crc64), SizeOfXLogRecord - sizeof(crc64)); FIN_CRC64(crc); record->xl_crc = crc; @@ -914,13 +922,13 @@ usage(void) int -main(int argc, char ** argv) +main(int argc, char **argv) { - int argn; - bool force = false; - bool noupdate = false; - int fd; - char path[MAXPGPATH]; + int argn; + bool force = false; + bool noupdate = false; + int fd; + char path[MAXPGPATH]; for (argn = 1; argn < argc; argn++) { @@ -934,7 +942,7 @@ main(int argc, char ** argv) usage(); } - if (argn != argc-1) /* one required non-switch argument */ + if (argn != argc - 1) /* one required non-switch argument */ usage(); DataDir = argv[argn++]; @@ -946,7 +954,8 @@ main(int argc, char ** argv) /* * Check for a postmaster lock file --- if there is one, refuse to - * proceed, on grounds we might be interfering with a live installation. + * proceed, on grounds we might be interfering with a live + * installation. */ snprintf(path, MAXPGPATH, "%s%cpostmaster.pid", DataDir, SEP_CHAR); @@ -973,8 +982,8 @@ main(int argc, char ** argv) GuessControlValues(); /* - * If we had to guess anything, and -f was not given, just print - * the guessed values and exit. Also print if -n is given. + * If we had to guess anything, and -f was not given, just print the + * guessed values and exit. Also print if -n is given. */ if ((guessed && !force) || noupdate) { diff --git a/contrib/pgcrypto/encode.c b/contrib/pgcrypto/encode.c index 0ad0a8f56c..b6db217c83 100644 --- a/contrib/pgcrypto/encode.c +++ b/contrib/pgcrypto/encode.c @@ -1,7 +1,7 @@ /* * encode.c * Various data encoding/decoding things. - * + * * Copyright (c) 2001 Marko Kreen * All rights reserved. * @@ -9,15 +9,15 @@ * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. + * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) @@ -26,7 +26,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $Id: encode.c,v 1.3 2001/02/10 02:31:25 tgl Exp $ + * $Id: encode.c,v 1.4 2001/03/22 03:59:10 momjian Exp $ */ #include "postgres.h" @@ -43,9 +43,9 @@ #endif static pg_coding * -find_coding(pg_coding *hbuf, text *name, int silent); + find_coding(pg_coding * hbuf, text *name, int silent); static pg_coding * -pg_find_coding(pg_coding *res, char *name); + pg_find_coding(pg_coding * res, char *name); /* SQL function: encode(bytea, text) returns text */ @@ -54,34 +54,37 @@ PG_FUNCTION_INFO_V1(encode); Datum encode(PG_FUNCTION_ARGS) { - text *arg; - text *name; - uint len, rlen, rlen0; - pg_coding *c, cbuf; - text *res; - + text *arg; + text *name; + uint len, + rlen, + rlen0; + pg_coding *c, + cbuf; + text *res; + if (PG_ARGISNULL(0) || PG_ARGISNULL(1)) PG_RETURN_NULL(); - - name = PG_GETARG_TEXT_P(1); - c = find_coding(&cbuf, name, 0); /* will give error if fails */ + + name = PG_GETARG_TEXT_P(1); + c = find_coding(&cbuf, name, 0); /* will give error if fails */ arg = PG_GETARG_TEXT_P(0); len = VARSIZE(arg) - VARHDRSZ; - + rlen0 = c->encode_len(len); - - res = (text *)palloc(rlen0 + VARHDRSZ); - + + res = (text *) palloc(rlen0 + VARHDRSZ); + rlen = c->encode(VARDATA(arg), len, VARDATA(res)); VARATT_SIZEP(res) = rlen + VARHDRSZ; if (rlen > rlen0) elog(FATAL, "pg_encode: overflow, encode estimate too small"); - + PG_FREE_IF_COPY(arg, 0); PG_FREE_IF_COPY(name, 1); - + PG_RETURN_TEXT_P(res); } @@ -91,54 +94,58 @@ PG_FUNCTION_INFO_V1(decode); Datum decode(PG_FUNCTION_ARGS) { - text *arg; - text *name; - uint len, rlen, rlen0; - pg_coding *c, cbuf; - text *res; - + text *arg; + text *name; + uint len, + rlen, + rlen0; + pg_coding *c, + cbuf; + text *res; + if (PG_ARGISNULL(0) || PG_ARGISNULL(1)) PG_RETURN_NULL(); - - name = PG_GETARG_TEXT_P(1); - c = find_coding(&cbuf, name, 0); /* will give error if fails */ + + name = PG_GETARG_TEXT_P(1); + c = find_coding(&cbuf, name, 0); /* will give error if fails */ arg = PG_GETARG_TEXT_P(0); len = VARSIZE(arg) - VARHDRSZ; - + rlen0 = c->decode_len(len); - - res = (text *)palloc(rlen0 + VARHDRSZ); - + + res = (text *) palloc(rlen0 + VARHDRSZ); + rlen = c->decode(VARDATA(arg), len, VARDATA(res)); VARATT_SIZEP(res) = rlen + VARHDRSZ; if (rlen > rlen0) elog(FATAL, "pg_decode: overflow, decode estimate too small"); - + PG_FREE_IF_COPY(arg, 0); PG_FREE_IF_COPY(name, 1); - + PG_RETURN_TEXT_P(res); } static pg_coding * -find_coding(pg_coding *dst, text *name, int silent) +find_coding(pg_coding * dst, text *name, int silent) { - pg_coding *p; - char buf[NAMEDATALEN]; - uint len; - + pg_coding *p; + char buf[NAMEDATALEN]; + uint len; + len = VARSIZE(name) - VARHDRSZ; - if (len >= NAMEDATALEN) { + if (len >= NAMEDATALEN) + { if (silent) return NULL; elog(ERROR, "Encoding type does not exist (name too long)"); } - + memcpy(buf, VARDATA(name), len); buf[len] = 0; - + p = pg_find_coding(dst, buf); if (p == NULL && !silent) @@ -151,21 +158,23 @@ static char *hextbl = "0123456789abcdef"; uint hex_encode(uint8 *src, uint len, uint8 *dst) { - uint8 *end = src + len; - while (src < end) { + uint8 *end = src + len; + + while (src < end) + { *dst++ = hextbl[(*src >> 4) & 0xF]; *dst++ = hextbl[*src & 0xF]; src++; } - return len*2; + return len * 2; } /* probably should use lookup table */ static uint8 get_hex(char c) { - uint8 res = 0; - + uint8 res = 0; + if (c >= '0' && c <= '9') res = c - '0'; else if (c >= 'a' && c <= 'f') @@ -174,19 +183,26 @@ get_hex(char c) res = c - 'A' + 10; else elog(ERROR, "Bad hex code: '%c'", c); - + return res; } uint hex_decode(uint8 *src, uint len, uint8 *dst) { - uint8 *s, *srcend, v1, v2, *p = dst; - + uint8 *s, + *srcend, + v1, + v2, + *p = dst; + srcend = src + len; - s = src; p = dst; - while (s < srcend) { - if (*s == ' ' || *s == '\n' || *s == '\t' || *s == '\r') { + s = src; + p = dst; + while (s < srcend) + { + if (*s == ' ' || *s == '\n' || *s == '\t' || *s == '\r') + { s++; continue; } @@ -196,30 +212,36 @@ hex_decode(uint8 *src, uint len, uint8 *dst) v2 = get_hex(*s++); *p++ = v1 | v2; } - + return p - dst; } static unsigned char _base64[] = - "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; +"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; uint b64_encode(uint8 *src, uint len, uint8 *dst) { - uint8 *s, *p, *end = src + len, *lend = dst + 76; - int pos = 2; + uint8 *s, + *p, + *end = src + len, + *lend = dst + 76; + int pos = 2; unsigned long buf = 0; - s = src; p = dst; - - while (s < end) { + s = src; + p = dst; + + while (s < end) + { buf |= *s << (pos << 3); pos--; s++; - + /* write it out */ - if (pos < 0) { + if (pos < 0) + { *p++ = _base64[(buf >> 18) & 0x3f]; *p++ = _base64[(buf >> 12) & 0x3f]; *p++ = _base64[(buf >> 6) & 0x3f]; @@ -228,12 +250,14 @@ b64_encode(uint8 *src, uint len, uint8 *dst) pos = 2; buf = 0; } - if (p >= lend) { + if (p >= lend) + { *p++ = '\n'; lend = p + 76; } } - if (pos != 2) { + if (pos != 2) + { *p++ = _base64[(buf >> 18) & 0x3f]; *p++ = _base64[(buf >> 12) & 0x3f]; *p++ = (pos == 0) ? _base64[(buf >> 6) & 0x3f] : '='; @@ -247,14 +271,17 @@ b64_encode(uint8 *src, uint len, uint8 *dst) uint b64_decode(uint8 *src, uint len, uint8 *dst) { - char *srcend = src + len, *s = src; - uint8 *p = dst; - char c; - uint b = 0; + char *srcend = src + len, + *s = src; + uint8 *p = dst; + char c; + uint b = 0; unsigned long buf = 0; - int pos = 0, end = 0; - - while (s < srcend) { + int pos = 0, + end = 0; + + while (s < srcend) + { c = *s++; if (c >= 'A' && c <= 'Z') b = c - 'A'; @@ -266,16 +293,21 @@ b64_decode(uint8 *src, uint len, uint8 *dst) b = 62; else if (c == '/') b = 63; - else if (c == '=') { + else if (c == '=') + { /* end sequence */ - if (!end) { - if (pos == 2) end = 1; - else if (pos == 3) end = 2; + if (!end) + { + if (pos == 2) + end = 1; + else if (pos == 3) + end = 2; else elog(ERROR, "base64: unexpected '='"); } b = 0; - } else if (c == ' ' || c == '\t' || c == '\n' || c == '\r') + } + else if (c == ' ' || c == '\t' || c == '\n' || c == '\r') continue; else elog(ERROR, "base64: Invalid symbol"); @@ -283,7 +315,8 @@ b64_decode(uint8 *src, uint len, uint8 *dst) /* add it to buffer */ buf = (buf << 6) + b; pos++; - if (pos == 4) { + if (pos == 4) + { *p++ = (buf >> 16) & 255; if (end == 0 || end > 1) *p++ = (buf >> 8) & 255; @@ -326,21 +359,22 @@ b64_dec_len(uint srclen) } static pg_coding -encoding_list [] = { - { "hex", hex_enc_len, hex_dec_len, hex_encode, hex_decode}, - { "base64", b64_enc_len, b64_dec_len, b64_encode, b64_decode}, - { NULL, NULL, NULL, NULL, NULL} + encoding_list[] = { + {"hex", hex_enc_len, hex_dec_len, hex_encode, hex_decode}, + {"base64", b64_enc_len, b64_dec_len, b64_encode, b64_decode}, + {NULL, NULL, NULL, NULL, NULL} }; static pg_coding * -pg_find_coding(pg_coding *res, char *name) +pg_find_coding(pg_coding * res, char *name) { - pg_coding *p; - for (p = encoding_list; p->name; p++) { + pg_coding *p; + + for (p = encoding_list; p->name; p++) + { if (!strcasecmp(p->name, name)) return p; } return NULL; } - diff --git a/contrib/pgcrypto/encode.h b/contrib/pgcrypto/encode.h index 33e6508cb1..451e06d75b 100644 --- a/contrib/pgcrypto/encode.h +++ b/contrib/pgcrypto/encode.h @@ -1,7 +1,7 @@ /* * pg_encode.h * encode.c - * + * * Copyright (c) 2001 Marko Kreen * All rights reserved. * @@ -9,15 +9,15 @@ * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. + * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) @@ -26,35 +26,35 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $Id: encode.h,v 1.1 2001/01/24 03:46:16 momjian Exp $ + * $Id: encode.h,v 1.2 2001/03/22 03:59:10 momjian Exp $ */ #ifndef __PG_ENCODE_H #define __PG_ENCODE_H /* exported functions */ -Datum encode(PG_FUNCTION_ARGS); -Datum decode(PG_FUNCTION_ARGS); +Datum encode(PG_FUNCTION_ARGS); +Datum decode(PG_FUNCTION_ARGS); typedef struct _pg_coding pg_coding; -struct _pg_coding { - char *name; - uint (*encode_len)(uint dlen); - uint (*decode_len)(uint dlen); - uint (*encode)(uint8 *data, uint dlen, uint8 *res); - uint (*decode)(uint8 *data, uint dlen, uint8 *res); +struct _pg_coding +{ + char *name; + uint (*encode_len) (uint dlen); + uint (*decode_len) (uint dlen); + uint (*encode) (uint8 *data, uint dlen, uint8 *res); + uint (*decode) (uint8 *data, uint dlen, uint8 *res); }; /* They are for outside usage in C code, if needed */ -uint hex_encode(uint8 *src, uint len, uint8 *dst); -uint hex_decode(uint8 *src, uint len, uint8 *dst); -uint b64_encode(uint8 *src, uint len, uint8 *dst); -uint b64_decode(uint8 *src, uint len, uint8 *dst); - -uint hex_enc_len(uint srclen); -uint hex_dec_len(uint srclen); -uint b64_enc_len(uint srclen); -uint b64_dec_len(uint srclen); +uint hex_encode(uint8 *src, uint len, uint8 *dst); +uint hex_decode(uint8 *src, uint len, uint8 *dst); +uint b64_encode(uint8 *src, uint len, uint8 *dst); +uint b64_decode(uint8 *src, uint len, uint8 *dst); -#endif /* __PG_ENCODE_H */ +uint hex_enc_len(uint srclen); +uint hex_dec_len(uint srclen); +uint b64_enc_len(uint srclen); +uint b64_dec_len(uint srclen); +#endif /* __PG_ENCODE_H */ diff --git a/contrib/pgcrypto/internal.c b/contrib/pgcrypto/internal.c index 3c6e6fc80b..2d4a52717e 100644 --- a/contrib/pgcrypto/internal.c +++ b/contrib/pgcrypto/internal.c @@ -1,7 +1,7 @@ /* * internal.c * Wrapper for builtin functions - * + * * Copyright (c) 2000 Marko Kreen * All rights reserved. * @@ -9,15 +9,15 @@ * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. + * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) @@ -26,7 +26,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $Id: internal.c,v 1.2 2001/02/10 02:31:25 tgl Exp $ + * $Id: internal.c,v 1.3 2001/03/22 03:59:10 momjian Exp $ */ #include "postgres.h" @@ -49,31 +49,32 @@ #endif static uint -pg_md5_len(pg_digest *h); + pg_md5_len(pg_digest * h); static uint8 * -pg_md5_digest(pg_digest *h, uint8 *src, uint len, uint8 *buf); + pg_md5_digest(pg_digest * h, uint8 *src, uint len, uint8 *buf); static uint -pg_sha1_len(pg_digest *h); + pg_sha1_len(pg_digest * h); static uint8 * -pg_sha1_digest(pg_digest *h, uint8 *src, uint len, uint8 *buf); + pg_sha1_digest(pg_digest * h, uint8 *src, uint len, uint8 *buf); static pg_digest -int_digest_list [] = { - { "md5", pg_md5_len, pg_md5_digest, {0}}, - { "sha1", pg_sha1_len, pg_sha1_digest, {0}}, - { NULL, NULL, NULL, {0}} + int_digest_list[] = { + {"md5", pg_md5_len, pg_md5_digest, {0}}, + {"sha1", pg_sha1_len, pg_sha1_digest, {0}}, + {NULL, NULL, NULL, {0}} }; static uint -pg_md5_len(pg_digest *h) { +pg_md5_len(pg_digest * h) +{ return MD5_DIGEST_LENGTH; } static uint8 * -pg_md5_digest(pg_digest *h, uint8 *src, uint len, uint8 *buf) +pg_md5_digest(pg_digest * h, uint8 *src, uint len, uint8 *buf) { - MD5_CTX ctx; + MD5_CTX ctx; MD5Init(&ctx); MD5Update(&ctx, src, len); @@ -83,32 +84,31 @@ pg_md5_digest(pg_digest *h, uint8 *src, uint len, uint8 *buf) } static uint -pg_sha1_len(pg_digest *h) { +pg_sha1_len(pg_digest * h) +{ return SHA1_DIGEST_LENGTH; } static uint8 * -pg_sha1_digest(pg_digest *h, uint8 *src, uint len, uint8 *buf) +pg_sha1_digest(pg_digest * h, uint8 *src, uint len, uint8 *buf) { - SHA1_CTX ctx; + SHA1_CTX ctx; SHA1Init(&ctx); SHA1Update(&ctx, src, len); SHA1Final(buf, &ctx); - + return buf; } -pg_digest * -pg_find_digest(pg_digest *h, char *name) +pg_digest * +pg_find_digest(pg_digest * h, char *name) { - pg_digest *p; + pg_digest *p; for (p = int_digest_list; p->name; p++) if (!strcasecmp(p->name, name)) return p; return NULL; } - - diff --git a/contrib/pgcrypto/krb.c b/contrib/pgcrypto/krb.c index 14ac44b29d..95df07ca27 100644 --- a/contrib/pgcrypto/krb.c +++ b/contrib/pgcrypto/krb.c @@ -1,7 +1,7 @@ /* * krb.c * Wrapper for Kerberos5 libdes SHA1/MD5. - * + * * Copyright (c) 2000 Marko Kreen * All rights reserved. * @@ -9,15 +9,15 @@ * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. + * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) @@ -26,12 +26,12 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * + * * NOTES * It is possible that this works with other SHA1/MD5 * implementations too. * - * $Id: krb.c,v 1.3 2001/02/20 15:34:14 momjian Exp $ + * $Id: krb.c,v 1.4 2001/03/22 03:59:10 momjian Exp $ */ #include "postgres.h" @@ -54,31 +54,32 @@ #endif static uint -pg_md5_len(pg_digest *h); + pg_md5_len(pg_digest * h); static uint8 * -pg_md5_digest(pg_digest *h, uint8 *src, uint len, uint8 *buf); + pg_md5_digest(pg_digest * h, uint8 *src, uint len, uint8 *buf); static uint -pg_sha1_len(pg_digest *h); + pg_sha1_len(pg_digest * h); static uint8 * -pg_sha1_digest(pg_digest *h, uint8 *src, uint len, uint8 *buf); + pg_sha1_digest(pg_digest * h, uint8 *src, uint len, uint8 *buf); static pg_digest -int_digest_list [] = { - { "md5", pg_md5_len, pg_md5_digest, {0}}, - { "sha1", pg_sha1_len, pg_sha1_digest, {0}}, - { NULL, NULL, NULL, {0}} + int_digest_list[] = { + {"md5", pg_md5_len, pg_md5_digest, {0}}, + {"sha1", pg_sha1_len, pg_sha1_digest, {0}}, + {NULL, NULL, NULL, {0}} }; static uint -pg_md5_len(pg_digest *h) { +pg_md5_len(pg_digest * h) +{ return MD5_DIGEST_LENGTH; } static uint8 * -pg_md5_digest(pg_digest *h, uint8 *src, uint len, uint8 *buf) +pg_md5_digest(pg_digest * h, uint8 *src, uint len, uint8 *buf) { - MD5_CTX ctx; + MD5_CTX ctx; MD5Init(&ctx); MD5Update(&ctx, src, len); @@ -88,32 +89,31 @@ pg_md5_digest(pg_digest *h, uint8 *src, uint len, uint8 *buf) } static uint -pg_sha1_len(pg_digest *h) { +pg_sha1_len(pg_digest * h) +{ return SHA1_DIGEST_LENGTH; } static uint8 * -pg_sha1_digest(pg_digest *h, uint8 *src, uint len, uint8 *buf) +pg_sha1_digest(pg_digest * h, uint8 *src, uint len, uint8 *buf) { - SHA1_CTX ctx; + SHA1_CTX ctx; SHA1Init(&ctx); SHA1Update(&ctx, src, len); SHA1Final(buf, &ctx); - + return buf; } -pg_digest * -pg_find_digest(pg_digest *h, char *name) +pg_digest * +pg_find_digest(pg_digest * h, char *name) { - pg_digest *p; + pg_digest *p; for (p = int_digest_list; p->name; p++) if (!strcasecmp(p->name, name)) return p; return NULL; } - - diff --git a/contrib/pgcrypto/md5.c b/contrib/pgcrypto/md5.c index d538720231..a5cfae3497 100644 --- a/contrib/pgcrypto/md5.c +++ b/contrib/pgcrypto/md5.c @@ -1,5 +1,5 @@ -/* $Id: md5.c,v 1.4 2001/02/10 02:31:25 tgl Exp $ */ -/* $KAME: md5.c,v 1.3 2000/02/22 14:01:17 itojun Exp $ */ +/* $Id: md5.c,v 1.5 2001/03/22 03:59:10 momjian Exp $ */ +/* $KAME: md5.c,v 1.3 2000/02/22 14:01:17 itojun Exp $ */ /* * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project. @@ -9,18 +9,18 @@ * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. + * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. * 3. Neither the name of the project nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. + * may be used to endorse or promote products derived from this software + * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE + * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) @@ -93,42 +93,43 @@ /* Integer part of 4294967296 times abs(sin(i)), where i is in radians. */ static const uint32 T[65] = { 0, - 0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee, - 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501, - 0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be, - 0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821, - - 0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa, - 0xd62f105d, 0x2441453, 0xd8a1e681, 0xe7d3fbc8, - 0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed, - 0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a, - - 0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c, - 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70, - 0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x4881d05, - 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665, - - 0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039, - 0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1, - 0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1, - 0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391, + 0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee, + 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501, + 0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be, + 0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821, + + 0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa, + 0xd62f105d, 0x2441453, 0xd8a1e681, 0xe7d3fbc8, + 0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed, + 0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a, + + 0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c, + 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70, + 0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x4881d05, + 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665, + + 0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039, + 0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1, + 0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1, + 0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391, }; static const uint8 md5_paddat[MD5_BUFLEN] = { - 0x80, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, + 0x80, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, }; -static void md5_calc (uint8 *, md5_ctxt *); +static void md5_calc(uint8 *, md5_ctxt *); -void md5_init(ctxt) - md5_ctxt *ctxt; +void +md5_init(ctxt) +md5_ctxt *ctxt; { ctxt->md5_n = 0; ctxt->md5_i = 0; @@ -139,56 +140,64 @@ void md5_init(ctxt) bzero(ctxt->md5_buf, sizeof(ctxt->md5_buf)); } -void md5_loop(ctxt, input, len) - md5_ctxt *ctxt; - uint8 *input; - unsigned int len; /* number of bytes */ +void +md5_loop(ctxt, input, len) +md5_ctxt *ctxt; +uint8 *input; +unsigned int len; /* number of bytes */ { - unsigned int gap, i; + unsigned int gap, + i; - ctxt->md5_n += len * 8; /* byte to bit */ + ctxt->md5_n += len * 8; /* byte to bit */ gap = MD5_BUFLEN - ctxt->md5_i; - if (len >= gap) { - bcopy((void *)input, (void *)(ctxt->md5_buf + ctxt->md5_i), - gap); + if (len >= gap) + { + bcopy((void *) input, (void *) (ctxt->md5_buf + ctxt->md5_i), + gap); md5_calc(ctxt->md5_buf, ctxt); - for (i = gap; i + MD5_BUFLEN <= len; i += MD5_BUFLEN) { - md5_calc((uint8 *)(input + i), ctxt); - } - + for (i = gap; i + MD5_BUFLEN <= len; i += MD5_BUFLEN) + md5_calc((uint8 *) (input + i), ctxt); + ctxt->md5_i = len - i; - bcopy((void *)(input + i), (void *)ctxt->md5_buf, ctxt->md5_i); - } else { - bcopy((void *)input, (void *)(ctxt->md5_buf + ctxt->md5_i), - len); + bcopy((void *) (input + i), (void *) ctxt->md5_buf, ctxt->md5_i); + } + else + { + bcopy((void *) input, (void *) (ctxt->md5_buf + ctxt->md5_i), + len); ctxt->md5_i += len; } } -void md5_pad(ctxt) - md5_ctxt *ctxt; +void +md5_pad(ctxt) +md5_ctxt *ctxt; { unsigned int gap; - /* Don't count up padding. Keep md5_n. */ + /* Don't count up padding. Keep md5_n. */ gap = MD5_BUFLEN - ctxt->md5_i; - if (gap > 8) { - bcopy((void *)md5_paddat, - (void *)(ctxt->md5_buf + ctxt->md5_i), - gap - sizeof(ctxt->md5_n)); - } else { + if (gap > 8) + { + bcopy((void *) md5_paddat, + (void *) (ctxt->md5_buf + ctxt->md5_i), + gap - sizeof(ctxt->md5_n)); + } + else + { /* including gap == 8 */ - bcopy((void *)md5_paddat, (void *)(ctxt->md5_buf + ctxt->md5_i), - gap); + bcopy((void *) md5_paddat, (void *) (ctxt->md5_buf + ctxt->md5_i), + gap); md5_calc(ctxt->md5_buf, ctxt); - bcopy((void *)(md5_paddat + gap), - (void *)ctxt->md5_buf, - MD5_BUFLEN - sizeof(ctxt->md5_n)); + bcopy((void *) (md5_paddat + gap), + (void *) ctxt->md5_buf, + MD5_BUFLEN - sizeof(ctxt->md5_n)); } - /* 8 byte word */ + /* 8 byte word */ #if BYTE_ORDER == LITTLE_ENDIAN bcopy(&ctxt->md5_n8[0], &ctxt->md5_buf[56], 8); #endif @@ -206,98 +215,192 @@ void md5_pad(ctxt) md5_calc(ctxt->md5_buf, ctxt); } -void md5_result(digest, ctxt) - uint8 *digest; - md5_ctxt *ctxt; +void +md5_result(digest, ctxt) +uint8 *digest; +md5_ctxt *ctxt; { /* 4 byte words */ #if BYTE_ORDER == LITTLE_ENDIAN bcopy(&ctxt->md5_st8[0], digest, 16); #endif #if BYTE_ORDER == BIG_ENDIAN - digest[ 0] = ctxt->md5_st8[ 3]; digest[ 1] = ctxt->md5_st8[ 2]; - digest[ 2] = ctxt->md5_st8[ 1]; digest[ 3] = ctxt->md5_st8[ 0]; - digest[ 4] = ctxt->md5_st8[ 7]; digest[ 5] = ctxt->md5_st8[ 6]; - digest[ 6] = ctxt->md5_st8[ 5]; digest[ 7] = ctxt->md5_st8[ 4]; - digest[ 8] = ctxt->md5_st8[11]; digest[ 9] = ctxt->md5_st8[10]; - digest[10] = ctxt->md5_st8[ 9]; digest[11] = ctxt->md5_st8[ 8]; - digest[12] = ctxt->md5_st8[15]; digest[13] = ctxt->md5_st8[14]; - digest[14] = ctxt->md5_st8[13]; digest[15] = ctxt->md5_st8[12]; + digest[0] = ctxt->md5_st8[3]; + digest[1] = ctxt->md5_st8[2]; + digest[2] = ctxt->md5_st8[1]; + digest[3] = ctxt->md5_st8[0]; + digest[4] = ctxt->md5_st8[7]; + digest[5] = ctxt->md5_st8[6]; + digest[6] = ctxt->md5_st8[5]; + digest[7] = ctxt->md5_st8[4]; + digest[8] = ctxt->md5_st8[11]; + digest[9] = ctxt->md5_st8[10]; + digest[10] = ctxt->md5_st8[9]; + digest[11] = ctxt->md5_st8[8]; + digest[12] = ctxt->md5_st8[15]; + digest[13] = ctxt->md5_st8[14]; + digest[14] = ctxt->md5_st8[13]; + digest[15] = ctxt->md5_st8[12]; #endif } #if BYTE_ORDER == BIG_ENDIAN -uint32 X[16]; +uint32 X[16]; + #endif -static void md5_calc(b64, ctxt) - uint8 *b64; - md5_ctxt *ctxt; +static void +md5_calc(b64, ctxt) +uint8 *b64; +md5_ctxt *ctxt; { - uint32 A = ctxt->md5_sta; - uint32 B = ctxt->md5_stb; - uint32 C = ctxt->md5_stc; - uint32 D = ctxt->md5_std; + uint32 A = ctxt->md5_sta; + uint32 B = ctxt->md5_stb; + uint32 C = ctxt->md5_stc; + uint32 D = ctxt->md5_std; + #if BYTE_ORDER == LITTLE_ENDIAN - uint32 *X = (uint32 *)b64; -#endif + uint32 *X = (uint32 *) b64; + +#endif #if BYTE_ORDER == BIG_ENDIAN /* 4 byte words */ /* what a brute force but fast! */ - uint8 *y = (uint8 *)X; - y[ 0] = b64[ 3]; y[ 1] = b64[ 2]; y[ 2] = b64[ 1]; y[ 3] = b64[ 0]; - y[ 4] = b64[ 7]; y[ 5] = b64[ 6]; y[ 6] = b64[ 5]; y[ 7] = b64[ 4]; - y[ 8] = b64[11]; y[ 9] = b64[10]; y[10] = b64[ 9]; y[11] = b64[ 8]; - y[12] = b64[15]; y[13] = b64[14]; y[14] = b64[13]; y[15] = b64[12]; - y[16] = b64[19]; y[17] = b64[18]; y[18] = b64[17]; y[19] = b64[16]; - y[20] = b64[23]; y[21] = b64[22]; y[22] = b64[21]; y[23] = b64[20]; - y[24] = b64[27]; y[25] = b64[26]; y[26] = b64[25]; y[27] = b64[24]; - y[28] = b64[31]; y[29] = b64[30]; y[30] = b64[29]; y[31] = b64[28]; - y[32] = b64[35]; y[33] = b64[34]; y[34] = b64[33]; y[35] = b64[32]; - y[36] = b64[39]; y[37] = b64[38]; y[38] = b64[37]; y[39] = b64[36]; - y[40] = b64[43]; y[41] = b64[42]; y[42] = b64[41]; y[43] = b64[40]; - y[44] = b64[47]; y[45] = b64[46]; y[46] = b64[45]; y[47] = b64[44]; - y[48] = b64[51]; y[49] = b64[50]; y[50] = b64[49]; y[51] = b64[48]; - y[52] = b64[55]; y[53] = b64[54]; y[54] = b64[53]; y[55] = b64[52]; - y[56] = b64[59]; y[57] = b64[58]; y[58] = b64[57]; y[59] = b64[56]; - y[60] = b64[63]; y[61] = b64[62]; y[62] = b64[61]; y[63] = b64[60]; + uint8 *y = (uint8 *) X; + + y[0] = b64[3]; + y[1] = b64[2]; + y[2] = b64[1]; + y[3] = b64[0]; + y[4] = b64[7]; + y[5] = b64[6]; + y[6] = b64[5]; + y[7] = b64[4]; + y[8] = b64[11]; + y[9] = b64[10]; + y[10] = b64[9]; + y[11] = b64[8]; + y[12] = b64[15]; + y[13] = b64[14]; + y[14] = b64[13]; + y[15] = b64[12]; + y[16] = b64[19]; + y[17] = b64[18]; + y[18] = b64[17]; + y[19] = b64[16]; + y[20] = b64[23]; + y[21] = b64[22]; + y[22] = b64[21]; + y[23] = b64[20]; + y[24] = b64[27]; + y[25] = b64[26]; + y[26] = b64[25]; + y[27] = b64[24]; + y[28] = b64[31]; + y[29] = b64[30]; + y[30] = b64[29]; + y[31] = b64[28]; + y[32] = b64[35]; + y[33] = b64[34]; + y[34] = b64[33]; + y[35] = b64[32]; + y[36] = b64[39]; + y[37] = b64[38]; + y[38] = b64[37]; + y[39] = b64[36]; + y[40] = b64[43]; + y[41] = b64[42]; + y[42] = b64[41]; + y[43] = b64[40]; + y[44] = b64[47]; + y[45] = b64[46]; + y[46] = b64[45]; + y[47] = b64[44]; + y[48] = b64[51]; + y[49] = b64[50]; + y[50] = b64[49]; + y[51] = b64[48]; + y[52] = b64[55]; + y[53] = b64[54]; + y[54] = b64[53]; + y[55] = b64[52]; + y[56] = b64[59]; + y[57] = b64[58]; + y[58] = b64[57]; + y[59] = b64[56]; + y[60] = b64[63]; + y[61] = b64[62]; + y[62] = b64[61]; + y[63] = b64[60]; #endif - ROUND1(A, B, C, D, 0, Sa, 1); ROUND1(D, A, B, C, 1, Sb, 2); - ROUND1(C, D, A, B, 2, Sc, 3); ROUND1(B, C, D, A, 3, Sd, 4); - ROUND1(A, B, C, D, 4, Sa, 5); ROUND1(D, A, B, C, 5, Sb, 6); - ROUND1(C, D, A, B, 6, Sc, 7); ROUND1(B, C, D, A, 7, Sd, 8); - ROUND1(A, B, C, D, 8, Sa, 9); ROUND1(D, A, B, C, 9, Sb, 10); - ROUND1(C, D, A, B, 10, Sc, 11); ROUND1(B, C, D, A, 11, Sd, 12); - ROUND1(A, B, C, D, 12, Sa, 13); ROUND1(D, A, B, C, 13, Sb, 14); - ROUND1(C, D, A, B, 14, Sc, 15); ROUND1(B, C, D, A, 15, Sd, 16); - - ROUND2(A, B, C, D, 1, Se, 17); ROUND2(D, A, B, C, 6, Sf, 18); - ROUND2(C, D, A, B, 11, Sg, 19); ROUND2(B, C, D, A, 0, Sh, 20); - ROUND2(A, B, C, D, 5, Se, 21); ROUND2(D, A, B, C, 10, Sf, 22); - ROUND2(C, D, A, B, 15, Sg, 23); ROUND2(B, C, D, A, 4, Sh, 24); - ROUND2(A, B, C, D, 9, Se, 25); ROUND2(D, A, B, C, 14, Sf, 26); - ROUND2(C, D, A, B, 3, Sg, 27); ROUND2(B, C, D, A, 8, Sh, 28); - ROUND2(A, B, C, D, 13, Se, 29); ROUND2(D, A, B, C, 2, Sf, 30); - ROUND2(C, D, A, B, 7, Sg, 31); ROUND2(B, C, D, A, 12, Sh, 32); - - ROUND3(A, B, C, D, 5, Si, 33); ROUND3(D, A, B, C, 8, Sj, 34); - ROUND3(C, D, A, B, 11, Sk, 35); ROUND3(B, C, D, A, 14, Sl, 36); - ROUND3(A, B, C, D, 1, Si, 37); ROUND3(D, A, B, C, 4, Sj, 38); - ROUND3(C, D, A, B, 7, Sk, 39); ROUND3(B, C, D, A, 10, Sl, 40); - ROUND3(A, B, C, D, 13, Si, 41); ROUND3(D, A, B, C, 0, Sj, 42); - ROUND3(C, D, A, B, 3, Sk, 43); ROUND3(B, C, D, A, 6, Sl, 44); - ROUND3(A, B, C, D, 9, Si, 45); ROUND3(D, A, B, C, 12, Sj, 46); - ROUND3(C, D, A, B, 15, Sk, 47); ROUND3(B, C, D, A, 2, Sl, 48); - - ROUND4(A, B, C, D, 0, Sm, 49); ROUND4(D, A, B, C, 7, Sn, 50); - ROUND4(C, D, A, B, 14, So, 51); ROUND4(B, C, D, A, 5, Sp, 52); - ROUND4(A, B, C, D, 12, Sm, 53); ROUND4(D, A, B, C, 3, Sn, 54); - ROUND4(C, D, A, B, 10, So, 55); ROUND4(B, C, D, A, 1, Sp, 56); - ROUND4(A, B, C, D, 8, Sm, 57); ROUND4(D, A, B, C, 15, Sn, 58); - ROUND4(C, D, A, B, 6, So, 59); ROUND4(B, C, D, A, 13, Sp, 60); - ROUND4(A, B, C, D, 4, Sm, 61); ROUND4(D, A, B, C, 11, Sn, 62); - ROUND4(C, D, A, B, 2, So, 63); ROUND4(B, C, D, A, 9, Sp, 64); + ROUND1(A, B, C, D, 0, Sa, 1); + ROUND1(D, A, B, C, 1, Sb, 2); + ROUND1(C, D, A, B, 2, Sc, 3); + ROUND1(B, C, D, A, 3, Sd, 4); + ROUND1(A, B, C, D, 4, Sa, 5); + ROUND1(D, A, B, C, 5, Sb, 6); + ROUND1(C, D, A, B, 6, Sc, 7); + ROUND1(B, C, D, A, 7, Sd, 8); + ROUND1(A, B, C, D, 8, Sa, 9); + ROUND1(D, A, B, C, 9, Sb, 10); + ROUND1(C, D, A, B, 10, Sc, 11); + ROUND1(B, C, D, A, 11, Sd, 12); + ROUND1(A, B, C, D, 12, Sa, 13); + ROUND1(D, A, B, C, 13, Sb, 14); + ROUND1(C, D, A, B, 14, Sc, 15); + ROUND1(B, C, D, A, 15, Sd, 16); + + ROUND2(A, B, C, D, 1, Se, 17); + ROUND2(D, A, B, C, 6, Sf, 18); + ROUND2(C, D, A, B, 11, Sg, 19); + ROUND2(B, C, D, A, 0, Sh, 20); + ROUND2(A, B, C, D, 5, Se, 21); + ROUND2(D, A, B, C, 10, Sf, 22); + ROUND2(C, D, A, B, 15, Sg, 23); + ROUND2(B, C, D, A, 4, Sh, 24); + ROUND2(A, B, C, D, 9, Se, 25); + ROUND2(D, A, B, C, 14, Sf, 26); + ROUND2(C, D, A, B, 3, Sg, 27); + ROUND2(B, C, D, A, 8, Sh, 28); + ROUND2(A, B, C, D, 13, Se, 29); + ROUND2(D, A, B, C, 2, Sf, 30); + ROUND2(C, D, A, B, 7, Sg, 31); + ROUND2(B, C, D, A, 12, Sh, 32); + + ROUND3(A, B, C, D, 5, Si, 33); + ROUND3(D, A, B, C, 8, Sj, 34); + ROUND3(C, D, A, B, 11, Sk, 35); + ROUND3(B, C, D, A, 14, Sl, 36); + ROUND3(A, B, C, D, 1, Si, 37); + ROUND3(D, A, B, C, 4, Sj, 38); + ROUND3(C, D, A, B, 7, Sk, 39); + ROUND3(B, C, D, A, 10, Sl, 40); + ROUND3(A, B, C, D, 13, Si, 41); + ROUND3(D, A, B, C, 0, Sj, 42); + ROUND3(C, D, A, B, 3, Sk, 43); + ROUND3(B, C, D, A, 6, Sl, 44); + ROUND3(A, B, C, D, 9, Si, 45); + ROUND3(D, A, B, C, 12, Sj, 46); + ROUND3(C, D, A, B, 15, Sk, 47); + ROUND3(B, C, D, A, 2, Sl, 48); + + ROUND4(A, B, C, D, 0, Sm, 49); + ROUND4(D, A, B, C, 7, Sn, 50); + ROUND4(C, D, A, B, 14, So, 51); + ROUND4(B, C, D, A, 5, Sp, 52); + ROUND4(A, B, C, D, 12, Sm, 53); + ROUND4(D, A, B, C, 3, Sn, 54); + ROUND4(C, D, A, B, 10, So, 55); + ROUND4(B, C, D, A, 1, Sp, 56); + ROUND4(A, B, C, D, 8, Sm, 57); + ROUND4(D, A, B, C, 15, Sn, 58); + ROUND4(C, D, A, B, 6, So, 59); + ROUND4(B, C, D, A, 13, Sp, 60); + ROUND4(A, B, C, D, 4, Sm, 61); + ROUND4(D, A, B, C, 11, Sn, 62); + ROUND4(C, D, A, B, 2, So, 63); + ROUND4(B, C, D, A, 9, Sp, 64); ctxt->md5_sta += A; ctxt->md5_stb += B; diff --git a/contrib/pgcrypto/md5.h b/contrib/pgcrypto/md5.h index b724c34ba0..54ca2558df 100644 --- a/contrib/pgcrypto/md5.h +++ b/contrib/pgcrypto/md5.h @@ -1,5 +1,5 @@ -/* $Id: md5.h,v 1.3 2001/01/09 16:07:13 momjian Exp $ */ -/* $KAME: md5.h,v 1.3 2000/02/22 14:01:18 itojun Exp $ */ +/* $Id: md5.h,v 1.4 2001/03/22 03:59:10 momjian Exp $ */ +/* $KAME: md5.h,v 1.3 2000/02/22 14:01:18 itojun Exp $ */ /* * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project. @@ -9,18 +9,18 @@ * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. + * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. * 3. Neither the name of the project nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. + * may be used to endorse or promote products derived from this software + * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE + * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) @@ -35,11 +35,13 @@ #define MD5_BUFLEN 64 -typedef struct { - union { +typedef struct +{ + union + { uint32 md5_state32[4]; uint8 md5_state8[16]; - } md5_st; + } md5_st; #define md5_sta md5_st.md5_state32[0] #define md5_stb md5_st.md5_state32[1] @@ -47,21 +49,22 @@ typedef struct { #define md5_std md5_st.md5_state32[3] #define md5_st8 md5_st.md5_state8 - union { + union + { uint64 md5_count64; uint8 md5_count8[8]; - } md5_count; + } md5_count; #define md5_n md5_count.md5_count64 #define md5_n8 md5_count.md5_count8 - unsigned int md5_i; - uint8 md5_buf[MD5_BUFLEN]; -} md5_ctxt; + unsigned int md5_i; + uint8 md5_buf[MD5_BUFLEN]; +} md5_ctxt; -extern void md5_init (md5_ctxt *); -extern void md5_loop (md5_ctxt *, uint8 *, unsigned int); -extern void md5_pad (md5_ctxt *); -extern void md5_result (uint8 *, md5_ctxt *); +extern void md5_init(md5_ctxt *); +extern void md5_loop(md5_ctxt *, uint8 *, unsigned int); +extern void md5_pad(md5_ctxt *); +extern void md5_result(uint8 *, md5_ctxt *); /* compatibility */ #define MD5_CTX md5_ctxt @@ -73,4 +76,4 @@ do { \ md5_result((x), (y)); \ } while (0) -#endif /* ! _NETINET6_MD5_H_*/ +#endif /* ! _NETINET6_MD5_H_ */ diff --git a/contrib/pgcrypto/mhash.c b/contrib/pgcrypto/mhash.c index 34ac7e9c7a..d6ada96d14 100644 --- a/contrib/pgcrypto/mhash.c +++ b/contrib/pgcrypto/mhash.c @@ -1,7 +1,7 @@ /* * mhash.c * Wrapper for mhash library. - * + * * Copyright (c) 2000 Marko Kreen * All rights reserved. * @@ -9,15 +9,15 @@ * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. + * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) @@ -26,7 +26,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $Id: mhash.c,v 1.2 2001/02/10 02:31:26 tgl Exp $ + * $Id: mhash.c,v 1.3 2001/03/22 03:59:10 momjian Exp $ */ #include "postgres.h" @@ -36,45 +36,50 @@ #include <mhash.h> static uint -pg_mhash_len(pg_digest *hash); -static uint8 * -pg_mhash_digest(pg_digest *hash, uint8 *src, - uint len, uint8 *buf); + pg_mhash_len(pg_digest * hash); +static uint8 *pg_mhash_digest(pg_digest * hash, uint8 *src, + uint len, uint8 *buf); static uint -pg_mhash_len(pg_digest *h) { +pg_mhash_len(pg_digest * h) +{ return mhash_get_block_size(h->misc.code); } static uint8 * -pg_mhash_digest(pg_digest *h, uint8 *src, uint len, uint8 *dst) +pg_mhash_digest(pg_digest * h, uint8 *src, uint len, uint8 *dst) { - uint8 *res; - - MHASH mh = mhash_init(h->misc.code); + uint8 *res; + + MHASH mh = mhash_init(h->misc.code); + mhash(mh, src, len); res = mhash_end(mh); - + memcpy(dst, res, mhash_get_block_size(h->misc.code)); mhash_free(res); - + return dst; } -pg_digest * -pg_find_digest(pg_digest *h, char *name) +pg_digest * +pg_find_digest(pg_digest * h, char *name) { - size_t hnum, i, b; - char *mname; - + size_t hnum, + i, + b; + char *mname; + hnum = mhash_count(); - for (i = 0; i <= hnum; i++) { + for (i = 0; i <= hnum; i++) + { mname = mhash_get_hash_name(i); if (mname == NULL) continue; b = strcasecmp(name, mname); free(mname); - if (!b) { + if (!b) + { h->name = mhash_get_hash_name(i); h->length = pg_mhash_len; h->digest = pg_mhash_digest; @@ -84,4 +89,3 @@ pg_find_digest(pg_digest *h, char *name) } return NULL; } - diff --git a/contrib/pgcrypto/openssl.c b/contrib/pgcrypto/openssl.c index 18fb075488..866d26f0ff 100644 --- a/contrib/pgcrypto/openssl.c +++ b/contrib/pgcrypto/openssl.c @@ -1,7 +1,7 @@ /* * openssl.c * Wrapper for OpenSSL library. - * + * * Copyright (c) 2000 Marko Kreen * All rights reserved. * @@ -9,15 +9,15 @@ * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. + * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) @@ -26,7 +26,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $Id: openssl.c,v 1.2 2001/02/10 02:31:26 tgl Exp $ + * $Id: openssl.c,v 1.3 2001/03/22 03:59:10 momjian Exp $ */ #include "postgres.h" @@ -36,50 +36,50 @@ #include <evp.h> static uint -pg_ossl_len(pg_digest *h); + pg_ossl_len(pg_digest * h); static uint8 * -pg_ossl_digest(pg_digest *h, uint8 *src, uint len, uint8 *buf); + pg_ossl_digest(pg_digest * h, uint8 *src, uint len, uint8 *buf); static uint -pg_ossl_len(pg_digest *h) { - return EVP_MD_size((EVP_MD*)h->misc.ptr); +pg_ossl_len(pg_digest * h) +{ + return EVP_MD_size((EVP_MD *) h->misc.ptr); } static uint8 * -pg_ossl_digest(pg_digest *h, uint8 *src, uint len, uint8 *buf) +pg_ossl_digest(pg_digest * h, uint8 *src, uint len, uint8 *buf) { - EVP_MD *md = (EVP_MD*)h->misc.ptr; - EVP_MD_CTX ctx; + EVP_MD *md = (EVP_MD *) h->misc.ptr; + EVP_MD_CTX ctx; EVP_DigestInit(&ctx, md); EVP_DigestUpdate(&ctx, src, len); EVP_DigestFinal(&ctx, buf, NULL); - + return buf; } -static int pg_openssl_initialized = 0; +static int pg_openssl_initialized = 0; -pg_digest * -pg_find_digest(pg_digest *h, char *name) +pg_digest * +pg_find_digest(pg_digest * h, char *name) { const EVP_MD *md; - if (!pg_openssl_initialized) { + if (!pg_openssl_initialized) + { OpenSSL_add_all_digests(); pg_openssl_initialized = 1; } - + md = EVP_get_digestbyname(name); if (md == NULL) return NULL; - + h->name = name; h->length = pg_ossl_len; h->digest = pg_ossl_digest; - h->misc.ptr = (void*)md; - + h->misc.ptr = (void *) md; + return h; } - - diff --git a/contrib/pgcrypto/pgcrypto.c b/contrib/pgcrypto/pgcrypto.c index 1feb3e4806..31e5a845bd 100644 --- a/contrib/pgcrypto/pgcrypto.c +++ b/contrib/pgcrypto/pgcrypto.c @@ -1,7 +1,7 @@ /* * pgcrypto.c * Cryptographic digests for PostgreSQL. - * + * * Copyright (c) 2000 Marko Kreen * All rights reserved. * @@ -9,15 +9,15 @@ * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. + * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) @@ -26,7 +26,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $Id: pgcrypto.c,v 1.6 2001/02/10 02:31:26 tgl Exp $ + * $Id: pgcrypto.c,v 1.7 2001/03/22 03:59:10 momjian Exp $ */ #include "postgres.h" @@ -44,12 +44,12 @@ /* exported functions */ -Datum digest(PG_FUNCTION_ARGS); -Datum digest_exists(PG_FUNCTION_ARGS); +Datum digest(PG_FUNCTION_ARGS); +Datum digest_exists(PG_FUNCTION_ARGS); /* private stuff */ static pg_digest * -find_digest(pg_digest *hbuf, text *name, int silent); + find_digest(pg_digest * hbuf, text *name, int silent); /* SQL function: hash(text, text) returns text */ @@ -58,31 +58,33 @@ PG_FUNCTION_INFO_V1(digest); Datum digest(PG_FUNCTION_ARGS) { - text *arg; - text *name; - uint len, hlen; - pg_digest *h, _hbuf; - text *res; - + text *arg; + text *name; + uint len, + hlen; + pg_digest *h, + _hbuf; + text *res; + if (PG_ARGISNULL(0) || PG_ARGISNULL(1)) PG_RETURN_NULL(); - - name = PG_GETARG_TEXT_P(1); - h = find_digest(&_hbuf, name, 0); /* will give error if fails */ + + name = PG_GETARG_TEXT_P(1); + h = find_digest(&_hbuf, name, 0); /* will give error if fails */ hlen = h->length(h); - - res = (text *)palloc(hlen + VARHDRSZ); + + res = (text *) palloc(hlen + VARHDRSZ); VARATT_SIZEP(res) = hlen + VARHDRSZ; - + arg = PG_GETARG_TEXT_P(0); len = VARSIZE(arg) - VARHDRSZ; - + h->digest(h, VARDATA(arg), len, VARDATA(res)); - + PG_FREE_IF_COPY(arg, 0); PG_FREE_IF_COPY(name, 1); - + PG_RETURN_TEXT_P(res); } @@ -92,16 +94,17 @@ PG_FUNCTION_INFO_V1(digest_exists); Datum digest_exists(PG_FUNCTION_ARGS) { - text *name; - pg_digest _hbuf, *res; + text *name; + pg_digest _hbuf, + *res; if (PG_ARGISNULL(0)) PG_RETURN_NULL(); - + name = PG_GETARG_TEXT_P(0); - + res = find_digest(&_hbuf, name, 1); - + PG_FREE_IF_COPY(name, 0); if (res != NULL) @@ -110,26 +113,26 @@ digest_exists(PG_FUNCTION_ARGS) } static pg_digest * -find_digest(pg_digest *hbuf, text *name, int silent) +find_digest(pg_digest * hbuf, text *name, int silent) { - pg_digest *p; - char buf[NAMEDATALEN]; - uint len; - + pg_digest *p; + char buf[NAMEDATALEN]; + uint len; + len = VARSIZE(name) - VARHDRSZ; - if (len >= NAMEDATALEN) { + if (len >= NAMEDATALEN) + { if (silent) return NULL; elog(ERROR, "Hash type does not exist (name too long)"); } - + memcpy(buf, VARDATA(name), len); buf[len] = 0; - + p = pg_find_digest(hbuf, buf); if (p == NULL && !silent) elog(ERROR, "Hash type does not exist: '%s'", buf); return p; } - diff --git a/contrib/pgcrypto/pgcrypto.h b/contrib/pgcrypto/pgcrypto.h index 039d6cef79..1700b89b15 100644 --- a/contrib/pgcrypto/pgcrypto.h +++ b/contrib/pgcrypto/pgcrypto.h @@ -1,7 +1,7 @@ /* * pgcrypto.h * Header file for pgcrypto. - * + * * Copyright (c) 2000 Marko Kreen * All rights reserved. * @@ -9,15 +9,15 @@ * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. + * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) @@ -26,25 +26,27 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $Id: pgcrypto.h,v 1.2 2001/01/09 16:07:13 momjian Exp $ + * $Id: pgcrypto.h,v 1.3 2001/03/22 03:59:10 momjian Exp $ */ #ifndef _PG_CRYPTO_H #define _PG_CRYPTO_H typedef struct _pg_digest pg_digest; -struct _pg_digest { - char *name; - uint (*length)(pg_digest *h); - uint8 *(*digest)(pg_digest *h, uint8 *data, - uint dlen, uint8 *buf); +struct _pg_digest +{ + char *name; + uint (*length) (pg_digest * h); + uint8 *(*digest) (pg_digest * h, uint8 *data, + uint dlen, uint8 *buf); /* private */ - union { - uint code; + union + { + uint code; const void *ptr; - } misc; + } misc; }; -extern pg_digest *pg_find_digest(pg_digest *hbuf, char *name); +extern pg_digest *pg_find_digest(pg_digest * hbuf, char *name); #endif diff --git a/contrib/pgcrypto/sha1.c b/contrib/pgcrypto/sha1.c index 63c28dc7e9..db9f1a17c6 100644 --- a/contrib/pgcrypto/sha1.c +++ b/contrib/pgcrypto/sha1.c @@ -1,5 +1,5 @@ -/* $Id: sha1.c,v 1.4 2001/02/10 02:31:26 tgl Exp $ */ -/* $KAME: sha1.c,v 1.3 2000/02/22 14:01:18 itojun Exp $ */ +/* $Id: sha1.c,v 1.5 2001/03/22 03:59:10 momjian Exp $ */ +/* $KAME: sha1.c,v 1.3 2000/02/22 14:01:18 itojun Exp $ */ /* * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project. @@ -9,18 +9,18 @@ * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. + * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. * 3. Neither the name of the project nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. + * may be used to endorse or promote products derived from this software + * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE + * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) @@ -41,120 +41,182 @@ /* sanity check */ #if BYTE_ORDER != BIG_ENDIAN -# if BYTE_ORDER != LITTLE_ENDIAN -# define unsupported 1 -# endif +#if BYTE_ORDER != LITTLE_ENDIAN +#define unsupported 1 +#endif #endif #ifndef unsupported /* constant table */ -static uint32 _K[] = { 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6 }; -#define K(t) _K[(t) / 20] +static uint32 _K[] = {0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6}; + +#define K(t) _K[(t) / 20] -#define F0(b, c, d) (((b) & (c)) | ((~(b)) & (d))) -#define F1(b, c, d) (((b) ^ (c)) ^ (d)) -#define F2(b, c, d) (((b) & (c)) | ((b) & (d)) | ((c) & (d))) -#define F3(b, c, d) (((b) ^ (c)) ^ (d)) +#define F0(b, c, d) (((b) & (c)) | ((~(b)) & (d))) +#define F1(b, c, d) (((b) ^ (c)) ^ (d)) +#define F2(b, c, d) (((b) & (c)) | ((b) & (d)) | ((c) & (d))) +#define F3(b, c, d) (((b) ^ (c)) ^ (d)) -#define S(n, x) (((x) << (n)) | ((x) >> (32 - n))) +#define S(n, x) (((x) << (n)) | ((x) >> (32 - n))) -#define H(n) (ctxt->h.b32[(n)]) -#define COUNT (ctxt->count) -#define BCOUNT (ctxt->c.b64[0] / 8) -#define W(n) (ctxt->m.b32[(n)]) +#define H(n) (ctxt->h.b32[(n)]) +#define COUNT (ctxt->count) +#define BCOUNT (ctxt->c.b64[0] / 8) +#define W(n) (ctxt->m.b32[(n)]) -#define PUTBYTE(x) { \ +#define PUTBYTE(x) { \ ctxt->m.b8[(COUNT % 64)] = (x); \ COUNT++; \ COUNT %= 64; \ ctxt->c.b64[0] += 8; \ if (COUNT % 64 == 0) \ sha1_step(ctxt); \ - } + } -#define PUTPAD(x) { \ +#define PUTPAD(x) { \ ctxt->m.b8[(COUNT % 64)] = (x); \ COUNT++; \ COUNT %= 64; \ if (COUNT % 64 == 0) \ sha1_step(ctxt); \ - } + } -static void sha1_step (struct sha1_ctxt *); +static void sha1_step(struct sha1_ctxt *); static void sha1_step(ctxt) - struct sha1_ctxt *ctxt; +struct sha1_ctxt *ctxt; { - uint32 a, b, c, d, e; - size_t t, s; - uint32 tmp; + uint32 a, + b, + c, + d, + e; + size_t t, + s; + uint32 tmp; #if BYTE_ORDER == LITTLE_ENDIAN struct sha1_ctxt tctxt; + bcopy(&ctxt->m.b8[0], &tctxt.m.b8[0], 64); - ctxt->m.b8[0] = tctxt.m.b8[3]; ctxt->m.b8[1] = tctxt.m.b8[2]; - ctxt->m.b8[2] = tctxt.m.b8[1]; ctxt->m.b8[3] = tctxt.m.b8[0]; - ctxt->m.b8[4] = tctxt.m.b8[7]; ctxt->m.b8[5] = tctxt.m.b8[6]; - ctxt->m.b8[6] = tctxt.m.b8[5]; ctxt->m.b8[7] = tctxt.m.b8[4]; - ctxt->m.b8[8] = tctxt.m.b8[11]; ctxt->m.b8[9] = tctxt.m.b8[10]; - ctxt->m.b8[10] = tctxt.m.b8[9]; ctxt->m.b8[11] = tctxt.m.b8[8]; - ctxt->m.b8[12] = tctxt.m.b8[15]; ctxt->m.b8[13] = tctxt.m.b8[14]; - ctxt->m.b8[14] = tctxt.m.b8[13]; ctxt->m.b8[15] = tctxt.m.b8[12]; - ctxt->m.b8[16] = tctxt.m.b8[19]; ctxt->m.b8[17] = tctxt.m.b8[18]; - ctxt->m.b8[18] = tctxt.m.b8[17]; ctxt->m.b8[19] = tctxt.m.b8[16]; - ctxt->m.b8[20] = tctxt.m.b8[23]; ctxt->m.b8[21] = tctxt.m.b8[22]; - ctxt->m.b8[22] = tctxt.m.b8[21]; ctxt->m.b8[23] = tctxt.m.b8[20]; - ctxt->m.b8[24] = tctxt.m.b8[27]; ctxt->m.b8[25] = tctxt.m.b8[26]; - ctxt->m.b8[26] = tctxt.m.b8[25]; ctxt->m.b8[27] = tctxt.m.b8[24]; - ctxt->m.b8[28] = tctxt.m.b8[31]; ctxt->m.b8[29] = tctxt.m.b8[30]; - ctxt->m.b8[30] = tctxt.m.b8[29]; ctxt->m.b8[31] = tctxt.m.b8[28]; - ctxt->m.b8[32] = tctxt.m.b8[35]; ctxt->m.b8[33] = tctxt.m.b8[34]; - ctxt->m.b8[34] = tctxt.m.b8[33]; ctxt->m.b8[35] = tctxt.m.b8[32]; - ctxt->m.b8[36] = tctxt.m.b8[39]; ctxt->m.b8[37] = tctxt.m.b8[38]; - ctxt->m.b8[38] = tctxt.m.b8[37]; ctxt->m.b8[39] = tctxt.m.b8[36]; - ctxt->m.b8[40] = tctxt.m.b8[43]; ctxt->m.b8[41] = tctxt.m.b8[42]; - ctxt->m.b8[42] = tctxt.m.b8[41]; ctxt->m.b8[43] = tctxt.m.b8[40]; - ctxt->m.b8[44] = tctxt.m.b8[47]; ctxt->m.b8[45] = tctxt.m.b8[46]; - ctxt->m.b8[46] = tctxt.m.b8[45]; ctxt->m.b8[47] = tctxt.m.b8[44]; - ctxt->m.b8[48] = tctxt.m.b8[51]; ctxt->m.b8[49] = tctxt.m.b8[50]; - ctxt->m.b8[50] = tctxt.m.b8[49]; ctxt->m.b8[51] = tctxt.m.b8[48]; - ctxt->m.b8[52] = tctxt.m.b8[55]; ctxt->m.b8[53] = tctxt.m.b8[54]; - ctxt->m.b8[54] = tctxt.m.b8[53]; ctxt->m.b8[55] = tctxt.m.b8[52]; - ctxt->m.b8[56] = tctxt.m.b8[59]; ctxt->m.b8[57] = tctxt.m.b8[58]; - ctxt->m.b8[58] = tctxt.m.b8[57]; ctxt->m.b8[59] = tctxt.m.b8[56]; - ctxt->m.b8[60] = tctxt.m.b8[63]; ctxt->m.b8[61] = tctxt.m.b8[62]; - ctxt->m.b8[62] = tctxt.m.b8[61]; ctxt->m.b8[63] = tctxt.m.b8[60]; + ctxt->m.b8[0] = tctxt.m.b8[3]; + ctxt->m.b8[1] = tctxt.m.b8[2]; + ctxt->m.b8[2] = tctxt.m.b8[1]; + ctxt->m.b8[3] = tctxt.m.b8[0]; + ctxt->m.b8[4] = tctxt.m.b8[7]; + ctxt->m.b8[5] = tctxt.m.b8[6]; + ctxt->m.b8[6] = tctxt.m.b8[5]; + ctxt->m.b8[7] = tctxt.m.b8[4]; + ctxt->m.b8[8] = tctxt.m.b8[11]; + ctxt->m.b8[9] = tctxt.m.b8[10]; + ctxt->m.b8[10] = tctxt.m.b8[9]; + ctxt->m.b8[11] = tctxt.m.b8[8]; + ctxt->m.b8[12] = tctxt.m.b8[15]; + ctxt->m.b8[13] = tctxt.m.b8[14]; + ctxt->m.b8[14] = tctxt.m.b8[13]; + ctxt->m.b8[15] = tctxt.m.b8[12]; + ctxt->m.b8[16] = tctxt.m.b8[19]; + ctxt->m.b8[17] = tctxt.m.b8[18]; + ctxt->m.b8[18] = tctxt.m.b8[17]; + ctxt->m.b8[19] = tctxt.m.b8[16]; + ctxt->m.b8[20] = tctxt.m.b8[23]; + ctxt->m.b8[21] = tctxt.m.b8[22]; + ctxt->m.b8[22] = tctxt.m.b8[21]; + ctxt->m.b8[23] = tctxt.m.b8[20]; + ctxt->m.b8[24] = tctxt.m.b8[27]; + ctxt->m.b8[25] = tctxt.m.b8[26]; + ctxt->m.b8[26] = tctxt.m.b8[25]; + ctxt->m.b8[27] = tctxt.m.b8[24]; + ctxt->m.b8[28] = tctxt.m.b8[31]; + ctxt->m.b8[29] = tctxt.m.b8[30]; + ctxt->m.b8[30] = tctxt.m.b8[29]; + ctxt->m.b8[31] = tctxt.m.b8[28]; + ctxt->m.b8[32] = tctxt.m.b8[35]; + ctxt->m.b8[33] = tctxt.m.b8[34]; + ctxt->m.b8[34] = tctxt.m.b8[33]; + ctxt->m.b8[35] = tctxt.m.b8[32]; + ctxt->m.b8[36] = tctxt.m.b8[39]; + ctxt->m.b8[37] = tctxt.m.b8[38]; + ctxt->m.b8[38] = tctxt.m.b8[37]; + ctxt->m.b8[39] = tctxt.m.b8[36]; + ctxt->m.b8[40] = tctxt.m.b8[43]; + ctxt->m.b8[41] = tctxt.m.b8[42]; + ctxt->m.b8[42] = tctxt.m.b8[41]; + ctxt->m.b8[43] = tctxt.m.b8[40]; + ctxt->m.b8[44] = tctxt.m.b8[47]; + ctxt->m.b8[45] = tctxt.m.b8[46]; + ctxt->m.b8[46] = tctxt.m.b8[45]; + ctxt->m.b8[47] = tctxt.m.b8[44]; + ctxt->m.b8[48] = tctxt.m.b8[51]; + ctxt->m.b8[49] = tctxt.m.b8[50]; + ctxt->m.b8[50] = tctxt.m.b8[49]; + ctxt->m.b8[51] = tctxt.m.b8[48]; + ctxt->m.b8[52] = tctxt.m.b8[55]; + ctxt->m.b8[53] = tctxt.m.b8[54]; + ctxt->m.b8[54] = tctxt.m.b8[53]; + ctxt->m.b8[55] = tctxt.m.b8[52]; + ctxt->m.b8[56] = tctxt.m.b8[59]; + ctxt->m.b8[57] = tctxt.m.b8[58]; + ctxt->m.b8[58] = tctxt.m.b8[57]; + ctxt->m.b8[59] = tctxt.m.b8[56]; + ctxt->m.b8[60] = tctxt.m.b8[63]; + ctxt->m.b8[61] = tctxt.m.b8[62]; + ctxt->m.b8[62] = tctxt.m.b8[61]; + ctxt->m.b8[63] = tctxt.m.b8[60]; #endif - a = H(0); b = H(1); c = H(2); d = H(3); e = H(4); + a = H(0); + b = H(1); + c = H(2); + d = H(3); + e = H(4); - for (t = 0; t < 20; t++) { + for (t = 0; t < 20; t++) + { s = t & 0x0f; - if (t >= 16) { - W(s) = S(1, W((s+13) & 0x0f) ^ W((s+8) & 0x0f) ^ W((s+2) & 0x0f) ^ W(s)); - } + if (t >= 16) + W(s) = S(1, W((s + 13) & 0x0f) ^ W((s + 8) & 0x0f) ^ W((s + 2) & 0x0f) ^ W(s)); tmp = S(5, a) + F0(b, c, d) + e + W(s) + K(t); - e = d; d = c; c = S(30, b); b = a; a = tmp; + e = d; + d = c; + c = S(30, b); + b = a; + a = tmp; } - for (t = 20; t < 40; t++) { + for (t = 20; t < 40; t++) + { s = t & 0x0f; - W(s) = S(1, W((s+13) & 0x0f) ^ W((s+8) & 0x0f) ^ W((s+2) & 0x0f) ^ W(s)); + W(s) = S(1, W((s + 13) & 0x0f) ^ W((s + 8) & 0x0f) ^ W((s + 2) & 0x0f) ^ W(s)); tmp = S(5, a) + F1(b, c, d) + e + W(s) + K(t); - e = d; d = c; c = S(30, b); b = a; a = tmp; + e = d; + d = c; + c = S(30, b); + b = a; + a = tmp; } - for (t = 40; t < 60; t++) { + for (t = 40; t < 60; t++) + { s = t & 0x0f; - W(s) = S(1, W((s+13) & 0x0f) ^ W((s+8) & 0x0f) ^ W((s+2) & 0x0f) ^ W(s)); + W(s) = S(1, W((s + 13) & 0x0f) ^ W((s + 8) & 0x0f) ^ W((s + 2) & 0x0f) ^ W(s)); tmp = S(5, a) + F2(b, c, d) + e + W(s) + K(t); - e = d; d = c; c = S(30, b); b = a; a = tmp; + e = d; + d = c; + c = S(30, b); + b = a; + a = tmp; } - for (t = 60; t < 80; t++) { + for (t = 60; t < 80; t++) + { s = t & 0x0f; - W(s) = S(1, W((s+13) & 0x0f) ^ W((s+8) & 0x0f) ^ W((s+2) & 0x0f) ^ W(s)); + W(s) = S(1, W((s + 13) & 0x0f) ^ W((s + 8) & 0x0f) ^ W((s + 2) & 0x0f) ^ W(s)); tmp = S(5, a) + F3(b, c, d) + e + W(s) + K(t); - e = d; d = c; c = S(30, b); b = a; a = tmp; + e = d; + d = c; + c = S(30, b); + b = a; + a = tmp; } H(0) = H(0) + a; @@ -170,7 +232,7 @@ sha1_step(ctxt) void sha1_init(ctxt) - struct sha1_ctxt *ctxt; +struct sha1_ctxt *ctxt; { bzero(ctxt, sizeof(struct sha1_ctxt)); H(0) = 0x67452301; @@ -182,55 +244,65 @@ sha1_init(ctxt) void sha1_pad(ctxt) - struct sha1_ctxt *ctxt; +struct sha1_ctxt *ctxt; { - size_t padlen; /*pad length in bytes*/ - size_t padstart; + size_t padlen; /* pad length in bytes */ + size_t padstart; PUTPAD(0x80); padstart = COUNT % 64; padlen = 64 - padstart; - if (padlen < 8) { + if (padlen < 8) + { bzero(&ctxt->m.b8[padstart], padlen); COUNT += padlen; COUNT %= 64; sha1_step(ctxt); padstart = COUNT % 64; /* should be 0 */ - padlen = 64 - padstart; /* should be 64 */ + padlen = 64 - padstart; /* should be 64 */ } bzero(&ctxt->m.b8[padstart], padlen - 8); COUNT += (padlen - 8); COUNT %= 64; #if BYTE_ORDER == BIG_ENDIAN - PUTPAD(ctxt->c.b8[0]); PUTPAD(ctxt->c.b8[1]); - PUTPAD(ctxt->c.b8[2]); PUTPAD(ctxt->c.b8[3]); - PUTPAD(ctxt->c.b8[4]); PUTPAD(ctxt->c.b8[5]); - PUTPAD(ctxt->c.b8[6]); PUTPAD(ctxt->c.b8[7]); + PUTPAD(ctxt->c.b8[0]); + PUTPAD(ctxt->c.b8[1]); + PUTPAD(ctxt->c.b8[2]); + PUTPAD(ctxt->c.b8[3]); + PUTPAD(ctxt->c.b8[4]); + PUTPAD(ctxt->c.b8[5]); + PUTPAD(ctxt->c.b8[6]); + PUTPAD(ctxt->c.b8[7]); #else - PUTPAD(ctxt->c.b8[7]); PUTPAD(ctxt->c.b8[6]); - PUTPAD(ctxt->c.b8[5]); PUTPAD(ctxt->c.b8[4]); - PUTPAD(ctxt->c.b8[3]); PUTPAD(ctxt->c.b8[2]); - PUTPAD(ctxt->c.b8[1]); PUTPAD(ctxt->c.b8[0]); + PUTPAD(ctxt->c.b8[7]); + PUTPAD(ctxt->c.b8[6]); + PUTPAD(ctxt->c.b8[5]); + PUTPAD(ctxt->c.b8[4]); + PUTPAD(ctxt->c.b8[3]); + PUTPAD(ctxt->c.b8[2]); + PUTPAD(ctxt->c.b8[1]); + PUTPAD(ctxt->c.b8[0]); #endif } void sha1_loop(ctxt, input0, len) - struct sha1_ctxt *ctxt; - const caddr_t input0; - size_t len; +struct sha1_ctxt *ctxt; +const caddr_t input0; +size_t len; { const uint8 *input; - size_t gaplen; - size_t gapstart; - size_t off; - size_t copysiz; + size_t gaplen; + size_t gapstart; + size_t off; + size_t copysiz; - input = (const uint8 *)input0; + input = (const uint8 *) input0; off = 0; - while (off < len) { + while (off < len) + { gapstart = COUNT % 64; gaplen = 64 - gapstart; @@ -247,27 +319,37 @@ sha1_loop(ctxt, input0, len) void sha1_result(ctxt, digest0) - struct sha1_ctxt *ctxt; - caddr_t digest0; +struct sha1_ctxt *ctxt; +caddr_t digest0; { - uint8 *digest; + uint8 *digest; - digest = (uint8 *)digest0; + digest = (uint8 *) digest0; sha1_pad(ctxt); #if BYTE_ORDER == BIG_ENDIAN bcopy(&ctxt->h.b8[0], digest, 20); #else - digest[0] = ctxt->h.b8[3]; digest[1] = ctxt->h.b8[2]; - digest[2] = ctxt->h.b8[1]; digest[3] = ctxt->h.b8[0]; - digest[4] = ctxt->h.b8[7]; digest[5] = ctxt->h.b8[6]; - digest[6] = ctxt->h.b8[5]; digest[7] = ctxt->h.b8[4]; - digest[8] = ctxt->h.b8[11]; digest[9] = ctxt->h.b8[10]; - digest[10] = ctxt->h.b8[9]; digest[11] = ctxt->h.b8[8]; - digest[12] = ctxt->h.b8[15]; digest[13] = ctxt->h.b8[14]; - digest[14] = ctxt->h.b8[13]; digest[15] = ctxt->h.b8[12]; - digest[16] = ctxt->h.b8[19]; digest[17] = ctxt->h.b8[18]; - digest[18] = ctxt->h.b8[17]; digest[19] = ctxt->h.b8[16]; + digest[0] = ctxt->h.b8[3]; + digest[1] = ctxt->h.b8[2]; + digest[2] = ctxt->h.b8[1]; + digest[3] = ctxt->h.b8[0]; + digest[4] = ctxt->h.b8[7]; + digest[5] = ctxt->h.b8[6]; + digest[6] = ctxt->h.b8[5]; + digest[7] = ctxt->h.b8[4]; + digest[8] = ctxt->h.b8[11]; + digest[9] = ctxt->h.b8[10]; + digest[10] = ctxt->h.b8[9]; + digest[11] = ctxt->h.b8[8]; + digest[12] = ctxt->h.b8[15]; + digest[13] = ctxt->h.b8[14]; + digest[14] = ctxt->h.b8[13]; + digest[15] = ctxt->h.b8[12]; + digest[16] = ctxt->h.b8[19]; + digest[17] = ctxt->h.b8[18]; + digest[18] = ctxt->h.b8[17]; + digest[19] = ctxt->h.b8[16]; #endif } -#endif /*unsupported*/ +#endif /* unsupported */ diff --git a/contrib/pgcrypto/sha1.h b/contrib/pgcrypto/sha1.h index cb08a1af83..cddc8651e4 100644 --- a/contrib/pgcrypto/sha1.h +++ b/contrib/pgcrypto/sha1.h @@ -1,5 +1,5 @@ -/* $Id: sha1.h,v 1.3 2001/01/09 16:07:13 momjian Exp $ */ -/* $KAME: sha1.h,v 1.4 2000/02/22 14:01:18 itojun Exp $ */ +/* $Id: sha1.h,v 1.4 2001/03/22 03:59:10 momjian Exp $ */ +/* $KAME: sha1.h,v 1.4 2000/02/22 14:01:18 itojun Exp $ */ /* * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project. @@ -9,18 +9,18 @@ * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. + * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. * 3. Neither the name of the project nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. + * may be used to endorse or promote products derived from this software + * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE + * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) @@ -38,33 +38,38 @@ #ifndef _NETINET6_SHA1_H_ #define _NETINET6_SHA1_H_ -struct sha1_ctxt { - union { +struct sha1_ctxt +{ + union + { uint8 b8[20]; uint32 b32[5]; - } h; - union { + } h; + union + { uint8 b8[8]; uint64 b64[1]; - } c; - union { + } c; + union + { uint8 b8[64]; uint32 b32[16]; - } m; - uint8 count; + } m; + uint8 count; }; -extern void sha1_init (struct sha1_ctxt *); -extern void sha1_pad (struct sha1_ctxt *); -extern void sha1_loop (struct sha1_ctxt *, const caddr_t, size_t); -extern void sha1_result (struct sha1_ctxt *, caddr_t); +extern void sha1_init(struct sha1_ctxt *); +extern void sha1_pad(struct sha1_ctxt *); +extern void sha1_loop(struct sha1_ctxt *, const caddr_t, size_t); +extern void sha1_result(struct sha1_ctxt *, caddr_t); /* compatibilty with other SHA1 source codes */ typedef struct sha1_ctxt SHA1_CTX; + #define SHA1Init(x) sha1_init((x)) -#define SHA1Update(x, y, z) sha1_loop((x), (y), (z)) +#define SHA1Update(x, y, z) sha1_loop((x), (y), (z)) #define SHA1Final(x, y) sha1_result((y), (x)) -#define SHA1_RESULTLEN (160/8) +#define SHA1_RESULTLEN (160/8) -#endif /*_NETINET6_SHA1_H_*/ +#endif /* _NETINET6_SHA1_H_ */ diff --git a/contrib/rserv/rserv.c b/contrib/rserv/rserv.c index 518dd68a53..4a7d3aed35 100644 --- a/contrib/rserv/rserv.c +++ b/contrib/rserv/rserv.c @@ -16,18 +16,20 @@ PG_FUNCTION_INFO_V1(_rserv_log_); PG_FUNCTION_INFO_V1(_rserv_sync_); PG_FUNCTION_INFO_V1(_rserv_debug_); -Datum _rserv_log_(PG_FUNCTION_ARGS); -Datum _rserv_sync_(PG_FUNCTION_ARGS); -Datum _rserv_debug_(PG_FUNCTION_ARGS); +Datum _rserv_log_(PG_FUNCTION_ARGS); +Datum _rserv_sync_(PG_FUNCTION_ARGS); +Datum _rserv_debug_(PG_FUNCTION_ARGS); + #else HeapTuple _rserv_log_(void); int32 _rserv_sync_(int32); int32 _rserv_debug_(int32); + #endif static int debug = 0; -static char* OutputValue(char *key, char *buf, int size); +static char *OutputValue(char *key, char *buf, int size); #ifdef PG_FUNCTION_INFO_V1 Datum @@ -68,7 +70,7 @@ _rserv_log_() nargs = trigger->tgnargs; args = trigger->tgargs; - if (nargs != 1) /* odd number of arguments! */ + if (nargs != 1) /* odd number of arguments! */ elog(ERROR, "_rserv_log_: need in *one* argument"); keynum = atoi(args[0]); @@ -79,7 +81,7 @@ _rserv_log_() rel = CurrentTriggerData->tg_relation; tupdesc = rel->rd_att; - deleted = (TRIGGER_FIRED_BY_DELETE(CurrentTriggerData->tg_event)) ? + deleted = (TRIGGER_FIRED_BY_DELETE(CurrentTriggerData->tg_event)) ? 1 : 0; if (TRIGGER_FIRED_BY_UPDATE(CurrentTriggerData->tg_event)) @@ -115,7 +117,7 @@ _rserv_log_() if (strcmp(newkey, key) == 0) newkey = NULL; else - deleted = 1; /* old key was deleted */ + deleted = 1; /* old key was deleted */ } if (strpbrk(key, "\\ \n'")) @@ -124,7 +126,7 @@ _rserv_log_() okey = key; sprintf(sql, "update _RSERV_LOG_ set logid = %d, logtime = now(), " - "deleted = %d where reloid = %u and key = '%s'", + "deleted = %d where reloid = %u and key = '%s'", GetCurrentTransactionId(), deleted, rel->rd_id, okey); if (debug) @@ -145,7 +147,7 @@ _rserv_log_() sprintf(sql, "insert into _RSERV_LOG_ " "(reloid, logid, logtime, deleted, key) " "values (%u, %d, now(), %d, '%s')", - rel->rd_id, GetCurrentTransactionId(), + rel->rd_id, GetCurrentTransactionId(), deleted, okey); if (debug) @@ -169,7 +171,7 @@ _rserv_log_() sprintf(sql, "insert into _RSERV_LOG_ " "(reloid, logid, logtime, deleted, key) " - "values (%u, %d, now(), 0, '%s')", + "values (%u, %d, now(), 0, '%s')", rel->rd_id, GetCurrentTransactionId(), okey); if (debug) @@ -202,13 +204,14 @@ _rserv_sync_(int32 server) #endif { #ifdef PG_FUNCTION_INFO_V1 - int32 server = PG_GETARG_INT32(0); + int32 server = PG_GETARG_INT32(0); + #endif - char sql[8192]; - char buf[8192]; - char *active = buf; - uint32 xcnt; - int ret; + char sql[8192]; + char buf[8192]; + char *active = buf; + uint32 xcnt; + int ret; if (SerializableSnapshot == NULL) elog(ERROR, "_rserv_sync_: SerializableSnapshot is NULL"); @@ -217,7 +220,7 @@ _rserv_sync_(int32 server) for (xcnt = 0; xcnt < SerializableSnapshot->xcnt; xcnt++) { sprintf(buf + strlen(buf), "%s%u", (xcnt) ? ", " : "", - SerializableSnapshot->xip[xcnt]); + SerializableSnapshot->xip[xcnt]); } if ((ret = SPI_connect()) < 0) @@ -225,7 +228,7 @@ _rserv_sync_(int32 server) sprintf(sql, "insert into _RSERV_SYNC_ " "(server, syncid, synctime, status, minid, maxid, active) " - "values (%u, currval('_rserv_sync_seq_'), now(), 0, %d, %d, '%s')", + "values (%u, currval('_rserv_sync_seq_'), now(), 0, %d, %d, '%s')", server, SerializableSnapshot->xmin, SerializableSnapshot->xmax, active); ret = SPI_exec(sql, 0); @@ -247,18 +250,19 @@ _rserv_debug_(int32 newval) #endif { #ifdef PG_FUNCTION_INFO_V1 - int32 newval = PG_GETARG_INT32(0); + int32 newval = PG_GETARG_INT32(0); + #endif - int32 oldval = debug; + int32 oldval = debug; debug = newval; return (oldval); } -#define ExtendBy 1024 +#define ExtendBy 1024 -static char* +static char * OutputValue(char *key, char *buf, int size) { int i = 0; @@ -267,39 +271,45 @@ OutputValue(char *key, char *buf, int size) int slen = 0; size--; - for ( ; ; ) + for (;;) { switch (*key) { - case '\\': subst ="\\\\"; - slen = 2; - break; - case ' ': subst = "\\011"; - slen = 4; - break; - case '\n': subst = "\\012"; - slen = 4; - break; - case '\'': subst = "\\047"; - slen = 4; - break; - case '\0': out[i] = 0; - return(out); - default: slen = 1; - break; + case '\\': + subst = "\\\\"; + slen = 2; + break; + case ' ': + subst = "\\011"; + slen = 4; + break; + case '\n': + subst = "\\012"; + slen = 4; + break; + case '\'': + subst = "\\047"; + slen = 4; + break; + case '\0': + out[i] = 0; + return (out); + default: + slen = 1; + break; } if (i + slen >= size) { if (out == buf) { - out = (char*) palloc(size + ExtendBy); + out = (char *) palloc(size + ExtendBy); strncpy(out, buf, i); size += ExtendBy; } else { - out = (char*) repalloc(out, size + ExtendBy); + out = (char *) repalloc(out, size + ExtendBy); size += ExtendBy; } } @@ -314,6 +324,6 @@ OutputValue(char *key, char *buf, int size) key++; } - return(out); + return (out); } diff --git a/contrib/seg/buffer.c b/contrib/seg/buffer.c index f4dfc1edcd..baeba5e515 100644 --- a/contrib/seg/buffer.c +++ b/contrib/seg/buffer.c @@ -4,76 +4,81 @@ #include "utils/elog.h" -static char * PARSE_BUFFER; -static char * PARSE_BUFFER_PTR; -static unsigned int PARSE_BUFFER_SIZE; +static char *PARSE_BUFFER; +static char *PARSE_BUFFER_PTR; +static unsigned int PARSE_BUFFER_SIZE; static unsigned int SCANNER_POS; -void set_parse_buffer( char* s ); -void reset_parse_buffer( void ); -int read_parse_buffer( void ); -char * parse_buffer( void ); -char * parse_buffer_ptr( void ); -unsigned int parse_buffer_curr_char( void ); -unsigned int parse_buffer_size( void ); -unsigned int parse_buffer_pos( void ); +void set_parse_buffer(char *s); +void reset_parse_buffer(void); +int read_parse_buffer(void); +char *parse_buffer(void); +char *parse_buffer_ptr(void); +unsigned int parse_buffer_curr_char(void); +unsigned int parse_buffer_size(void); +unsigned int parse_buffer_pos(void); -extern void seg_flush_scanner_buffer(void); /* defined in segscan.l */ +extern void seg_flush_scanner_buffer(void); /* defined in segscan.l */ -void set_parse_buffer( char* s ) +void +set_parse_buffer(char *s) { - PARSE_BUFFER = s; - PARSE_BUFFER_SIZE = strlen(s); - if ( PARSE_BUFFER_SIZE == 0 ) { - elog(ERROR, "seg_in: can't parse an empty string"); - } - PARSE_BUFFER_PTR = PARSE_BUFFER; - SCANNER_POS = 0; + PARSE_BUFFER = s; + PARSE_BUFFER_SIZE = strlen(s); + if (PARSE_BUFFER_SIZE == 0) + elog(ERROR, "seg_in: can't parse an empty string"); + PARSE_BUFFER_PTR = PARSE_BUFFER; + SCANNER_POS = 0; } -void reset_parse_buffer( void ) +void +reset_parse_buffer(void) { - PARSE_BUFFER_PTR = PARSE_BUFFER; - SCANNER_POS = 0; - seg_flush_scanner_buffer(); + PARSE_BUFFER_PTR = PARSE_BUFFER; + SCANNER_POS = 0; + seg_flush_scanner_buffer(); } -int read_parse_buffer( void ) +int +read_parse_buffer(void) { - int c; - /* - c = *PARSE_BUFFER_PTR++; - SCANNER_POS++; - */ - c = PARSE_BUFFER[SCANNER_POS]; - if(SCANNER_POS < PARSE_BUFFER_SIZE) - SCANNER_POS++; - return c; + int c; + + /* + * c = *PARSE_BUFFER_PTR++; SCANNER_POS++; + */ + c = PARSE_BUFFER[SCANNER_POS]; + if (SCANNER_POS < PARSE_BUFFER_SIZE) + SCANNER_POS++; + return c; } -char * parse_buffer( void ) +char * +parse_buffer(void) { - return PARSE_BUFFER; + return PARSE_BUFFER; } -unsigned int parse_buffer_curr_char( void ) +unsigned int +parse_buffer_curr_char(void) { - return PARSE_BUFFER[SCANNER_POS]; + return PARSE_BUFFER[SCANNER_POS]; } -char * parse_buffer_ptr( void ) +char * +parse_buffer_ptr(void) { - return PARSE_BUFFER_PTR; + return PARSE_BUFFER_PTR; } -unsigned int parse_buffer_pos( void ) +unsigned int +parse_buffer_pos(void) { - return SCANNER_POS; + return SCANNER_POS; } -unsigned int parse_buffer_size( void ) +unsigned int +parse_buffer_size(void) { - return PARSE_BUFFER_SIZE; + return PARSE_BUFFER_SIZE; } - - diff --git a/contrib/seg/buffer.h b/contrib/seg/buffer.h index fd41a7b69b..eef9124dac 100644 --- a/contrib/seg/buffer.h +++ b/contrib/seg/buffer.h @@ -1,8 +1,8 @@ -extern void set_parse_buffer( char* s ); -extern void reset_parse_buffer( void ); -extern int read_parse_buffer( void ); -extern char * parse_buffer( void ); -extern char * parse_buffer_ptr( void ); -extern unsigned int parse_buffer_curr_char( void ); -extern unsigned int parse_buffer_pos( void ); -extern unsigned int parse_buffer_size( void ); +extern void set_parse_buffer(char *s); +extern void reset_parse_buffer(void); +extern int read_parse_buffer(void); +extern char *parse_buffer(void); +extern char *parse_buffer_ptr(void); +extern unsigned int parse_buffer_curr_char(void); +extern unsigned int parse_buffer_pos(void); +extern unsigned int parse_buffer_size(void); diff --git a/contrib/seg/seg.c b/contrib/seg/seg.c index 1609b42b1e..3ed7926389 100644 --- a/contrib/seg/seg.c +++ b/contrib/seg/seg.c @@ -16,79 +16,80 @@ #include "segdata.h" -#define max(a,b) ((a) > (b) ? (a) : (b)) -#define min(a,b) ((a) <= (b) ? (a) : (b)) -#define abs(a) ((a) < (0) ? (-a) : (a)) +#define max(a,b) ((a) > (b) ? (a) : (b)) +#define min(a,b) ((a) <= (b) ? (a) : (b)) +#define abs(a) ((a) < (0) ? (-a) : (a)) -/* +/* #define GIST_DEBUG -#define GIST_QUERY_DEBUG +#define GIST_QUERY_DEBUG */ -extern void set_parse_buffer(char *str); -extern int seg_yyparse(); +extern void set_parse_buffer(char *str); +extern int seg_yyparse(); + /* -extern int seg_yydebug; +extern int seg_yydebug; */ /* ** Input/Output routines */ -SEG * seg_in(char *str); -char * seg_out(SEG *seg); -float32 seg_lower(SEG *seg); -float32 seg_upper(SEG *seg); -float32 seg_center(SEG *seg); +SEG *seg_in(char *str); +char *seg_out(SEG * seg); +float32 seg_lower(SEG * seg); +float32 seg_upper(SEG * seg); +float32 seg_center(SEG * seg); -/* +/* ** GiST support methods */ -bool gseg_consistent(GISTENTRY *entry, SEG *query, StrategyNumber strategy); -GISTENTRY * gseg_compress(GISTENTRY *entry); -GISTENTRY * gseg_decompress(GISTENTRY *entry); -float * gseg_penalty(GISTENTRY *origentry, GISTENTRY *newentry, float *result); -GIST_SPLITVEC * gseg_picksplit(bytea *entryvec, GIST_SPLITVEC *v); -bool gseg_leaf_consistent(SEG *key, SEG *query, StrategyNumber strategy); -bool gseg_internal_consistent(SEG *key, SEG *query, StrategyNumber strategy); -SEG * gseg_union(bytea *entryvec, int *sizep); -SEG * gseg_binary_union(SEG *r1, SEG *r2, int *sizep); -bool * gseg_same(SEG *b1, SEG *b2, bool *result); +bool gseg_consistent(GISTENTRY *entry, SEG * query, StrategyNumber strategy); +GISTENTRY *gseg_compress(GISTENTRY *entry); +GISTENTRY *gseg_decompress(GISTENTRY *entry); +float *gseg_penalty(GISTENTRY *origentry, GISTENTRY *newentry, float *result); +GIST_SPLITVEC *gseg_picksplit(bytea *entryvec, GIST_SPLITVEC *v); +bool gseg_leaf_consistent(SEG * key, SEG * query, StrategyNumber strategy); +bool gseg_internal_consistent(SEG * key, SEG * query, StrategyNumber strategy); +SEG *gseg_union(bytea *entryvec, int *sizep); +SEG *gseg_binary_union(SEG * r1, SEG * r2, int *sizep); +bool *gseg_same(SEG * b1, SEG * b2, bool *result); /* ** R-tree suport functions */ -bool seg_same(SEG *a, SEG *b); -bool seg_contains_int(SEG *a, int *b); -bool seg_contains_float4(SEG *a, float4 *b); -bool seg_contains_float8(SEG *a, float8 *b); -bool seg_contains(SEG *a, SEG *b); -bool seg_contained(SEG *a, SEG *b); -bool seg_overlap(SEG *a, SEG *b); -bool seg_left(SEG *a, SEG *b); -bool seg_over_left(SEG *a, SEG *b); -bool seg_right(SEG *a, SEG *b); -bool seg_over_right(SEG *a, SEG *b); -SEG * seg_union(SEG *a, SEG *b); -SEG * seg_inter(SEG *a, SEG *b); -void rt_seg_size(SEG *a, float* sz); -float * seg_size(SEG *a); +bool seg_same(SEG * a, SEG * b); +bool seg_contains_int(SEG * a, int *b); +bool seg_contains_float4(SEG * a, float4 *b); +bool seg_contains_float8(SEG * a, float8 *b); +bool seg_contains(SEG * a, SEG * b); +bool seg_contained(SEG * a, SEG * b); +bool seg_overlap(SEG * a, SEG * b); +bool seg_left(SEG * a, SEG * b); +bool seg_over_left(SEG * a, SEG * b); +bool seg_right(SEG * a, SEG * b); +bool seg_over_right(SEG * a, SEG * b); +SEG *seg_union(SEG * a, SEG * b); +SEG *seg_inter(SEG * a, SEG * b); +void rt_seg_size(SEG * a, float *sz); +float *seg_size(SEG * a); /* ** Various operators */ -int32 seg_cmp(SEG *a, SEG *b); -bool seg_lt(SEG *a, SEG *b); -bool seg_le(SEG *a, SEG *b); -bool seg_gt(SEG *a, SEG *b); -bool seg_ge(SEG *a, SEG *b); -bool seg_different(SEG *a, SEG *b); - -/* +int32 seg_cmp(SEG * a, SEG * b); +bool seg_lt(SEG * a, SEG * b); +bool seg_le(SEG * a, SEG * b); +bool seg_gt(SEG * a, SEG * b); +bool seg_ge(SEG * a, SEG * b); +bool seg_different(SEG * a, SEG * b); + +/* ** Auxiliary funxtions */ -static int restore(char *s, float val, int n); -int significant_digits (char* s); +static int restore(char *s, float val, int n); +int significant_digits(char *s); /***************************************************************************** @@ -98,104 +99,113 @@ int significant_digits (char* s); SEG * seg_in(char *str) { - SEG * result = palloc(sizeof(SEG)); - set_parse_buffer( str ); - - /* - seg_yydebug = 1; - */ - if ( seg_yyparse(result) != 0 ) { - pfree ( result ); - return NULL; - } - return ( result ); + SEG *result = palloc(sizeof(SEG)); + + set_parse_buffer(str); + + /* + * seg_yydebug = 1; + */ + if (seg_yyparse(result) != 0) + { + pfree(result); + return NULL; + } + return (result); } /* * You might have noticed a slight inconsistency between the following * declaration and the SQL definition: - * CREATE FUNCTION seg_out(opaque) RETURNS opaque ... + * CREATE FUNCTION seg_out(opaque) RETURNS opaque ... * The reason is that the argument passed into seg_out is really just a * pointer. POSTGRES thinks all output functions are: - * char *out_func(char *); + * char *out_func(char *); */ char * -seg_out(SEG *seg) +seg_out(SEG * seg) { - char *result; - char *p; - - if (seg == NULL) return(NULL); - - p = result = (char *) palloc(40); - - if ( seg->l_ext == '>' || seg->l_ext == '<' || seg->l_ext == '~' ) { - p += sprintf(p, "%c", seg->l_ext); - } - - if ( seg->lower == seg->upper && seg->l_ext == seg->u_ext ) { - /* indicates that this interval was built by seg_in off a single point */ - p += restore(p, seg->lower, seg->l_sigd); - } - else { - if ( seg->l_ext != '-' ) { - /* print the lower boudary if exists */ - p += restore(p, seg->lower, seg->l_sigd); - p += sprintf(p, " "); - } - p += sprintf(p, ".."); - if ( seg->u_ext != '-' ) { - /* print the upper boudary if exists */ - p += sprintf(p, " "); - if ( seg->u_ext == '>' || seg->u_ext == '<' || seg->l_ext == '~' ) { - p += sprintf(p, "%c", seg->u_ext); + char *result; + char *p; + + if (seg == NULL) + return (NULL); + + p = result = (char *) palloc(40); + + if (seg->l_ext == '>' || seg->l_ext == '<' || seg->l_ext == '~') + p += sprintf(p, "%c", seg->l_ext); + + if (seg->lower == seg->upper && seg->l_ext == seg->u_ext) + { + + /* + * indicates that this interval was built by seg_in off a single + * point + */ + p += restore(p, seg->lower, seg->l_sigd); + } + else + { + if (seg->l_ext != '-') + { + /* print the lower boudary if exists */ + p += restore(p, seg->lower, seg->l_sigd); + p += sprintf(p, " "); + } + p += sprintf(p, ".."); + if (seg->u_ext != '-') + { + /* print the upper boudary if exists */ + p += sprintf(p, " "); + if (seg->u_ext == '>' || seg->u_ext == '<' || seg->l_ext == '~') + p += sprintf(p, "%c", seg->u_ext); + p += restore(p, seg->upper, seg->u_sigd); + } } - p += restore(p, seg->upper, seg->u_sigd); - } - } - return(result); + return (result); } float32 -seg_center(SEG *seg) +seg_center(SEG * seg) { - float32 result = (float32) palloc(sizeof(float32data)); + float32 result = (float32) palloc(sizeof(float32data)); - if (!seg) - return (float32) NULL; + if (!seg) + return (float32) NULL; - *result = ((float)seg->lower + (float)seg->upper)/2.0; - return (result); + *result = ((float) seg->lower + (float) seg->upper) / 2.0; + return (result); } float32 -seg_lower(SEG *seg) +seg_lower(SEG * seg) { - float32 result = (float32) palloc(sizeof(float32data)); + float32 result = (float32) palloc(sizeof(float32data)); - if (!seg) - return (float32) NULL; + if (!seg) + return (float32) NULL; - *result = (float)seg->lower; - return (result); + *result = (float) seg->lower; + return (result); } float32 -seg_upper(SEG *seg) +seg_upper(SEG * seg) { - float32 result = (float32) palloc(sizeof(float32data)); + float32 result = (float32) palloc(sizeof(float32data)); - if (!seg) - return (float32) NULL; + if (!seg) + return (float32) NULL; - *result = (float)seg->upper; - return (result); + *result = (float) seg->upper; + return (result); } /***************************************************************************** - * GiST functions + * GiST functions *****************************************************************************/ /* @@ -204,19 +214,20 @@ seg_upper(SEG *seg) ** the predicate x op query == FALSE, where op is the oper ** corresponding to strategy in the pg_amop table. */ -bool +bool gseg_consistent(GISTENTRY *entry, - SEG *query, - StrategyNumber strategy) + SEG * query, + StrategyNumber strategy) { - /* - ** if entry is not leaf, use gseg_internal_consistent, - ** else use gseg_leaf_consistent - */ - if (GIST_LEAF(entry)) - return(gseg_leaf_consistent((SEG *)(entry->pred), query, strategy)); - else - return(gseg_internal_consistent((SEG *)(entry->pred), query, strategy)); + + /* + * * if entry is not leaf, use gseg_internal_consistent, * else use + * gseg_leaf_consistent + */ + if (GIST_LEAF(entry)) + return (gseg_leaf_consistent((SEG *) (entry->pred), query, strategy)); + else + return (gseg_internal_consistent((SEG *) (entry->pred), query, strategy)); } /* @@ -226,49 +237,54 @@ gseg_consistent(GISTENTRY *entry, SEG * gseg_union(bytea *entryvec, int *sizep) { - int numranges, i; - SEG *out = (SEG *)NULL; - SEG *tmp; + int numranges, + i; + SEG *out = (SEG *) NULL; + SEG *tmp; #ifdef GIST_DEBUG - fprintf(stderr, "union\n"); + fprintf(stderr, "union\n"); #endif - numranges = (VARSIZE(entryvec) - VARHDRSZ)/sizeof(GISTENTRY); - tmp = (SEG *)(((GISTENTRY *)(VARDATA(entryvec)))[0]).pred; - *sizep = sizeof(SEG); + numranges = (VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY); + tmp = (SEG *) (((GISTENTRY *) (VARDATA(entryvec)))[0]).pred; + *sizep = sizeof(SEG); - for (i = 1; i < numranges; i++) { - out = gseg_binary_union(tmp, (SEG *) - (((GISTENTRY *)(VARDATA(entryvec)))[i]).pred, - sizep); + for (i = 1; i < numranges; i++) + { + out = gseg_binary_union(tmp, (SEG *) + (((GISTENTRY *) (VARDATA(entryvec)))[i]).pred, + sizep); #ifdef GIST_DEBUG - /* - fprintf(stderr, "\t%s ^ %s -> %s\n", seg_out(tmp), seg_out((SEG *)(((GISTENTRY *)(VARDATA(entryvec)))[i]).pred), seg_out(out)); - */ + + /* + * fprintf(stderr, "\t%s ^ %s -> %s\n", seg_out(tmp), seg_out((SEG + * *)(((GISTENTRY *)(VARDATA(entryvec)))[i]).pred), seg_out(out)); + */ #endif - if (i > 1) pfree(tmp); - tmp = out; - } + if (i > 1) + pfree(tmp); + tmp = out; + } - return(out); + return (out); } /* ** GiST Compress and Decompress methods for segments ** do not do anything. */ -GISTENTRY * +GISTENTRY * gseg_compress(GISTENTRY *entry) { - return(entry); + return (entry); } -GISTENTRY * +GISTENTRY * gseg_decompress(GISTENTRY *entry) { - return(entry); + return (entry); } /* @@ -278,287 +294,312 @@ gseg_decompress(GISTENTRY *entry) float * gseg_penalty(GISTENTRY *origentry, GISTENTRY *newentry, float *result) { - Datum ud; - float tmp1, tmp2; - - ud = (Datum)seg_union((SEG *)(origentry->pred), (SEG *)(newentry->pred)); - rt_seg_size((SEG *)ud, &tmp1); - rt_seg_size((SEG *)(origentry->pred), &tmp2); - *result = tmp1 - tmp2; - pfree((char *)ud); + Datum ud; + float tmp1, + tmp2; + + ud = (Datum) seg_union((SEG *) (origentry->pred), (SEG *) (newentry->pred)); + rt_seg_size((SEG *) ud, &tmp1); + rt_seg_size((SEG *) (origentry->pred), &tmp2); + *result = tmp1 - tmp2; + pfree((char *) ud); #ifdef GIST_DEBUG - fprintf(stderr, "penalty\n"); - fprintf(stderr, "\t%g\n", *result); + fprintf(stderr, "penalty\n"); + fprintf(stderr, "\t%g\n", *result); #endif - return(result); + return (result); } /* ** The GiST PickSplit method for segments -** We use Guttman's poly time split algorithm +** We use Guttman's poly time split algorithm */ GIST_SPLITVEC * gseg_picksplit(bytea *entryvec, - GIST_SPLITVEC *v) + GIST_SPLITVEC *v) { - OffsetNumber i, j; - SEG *datum_alpha, *datum_beta; - SEG *datum_l, *datum_r; - SEG *union_d, *union_dl, *union_dr; - SEG *inter_d; - bool firsttime; - float size_alpha, size_beta, size_union, size_inter; - float size_waste, waste; - float size_l, size_r; - int nbytes; - OffsetNumber seed_1 = 0, seed_2 = 0; - OffsetNumber *left, *right; - OffsetNumber maxoff; + OffsetNumber i, + j; + SEG *datum_alpha, + *datum_beta; + SEG *datum_l, + *datum_r; + SEG *union_d, + *union_dl, + *union_dr; + SEG *inter_d; + bool firsttime; + float size_alpha, + size_beta, + size_union, + size_inter; + float size_waste, + waste; + float size_l, + size_r; + int nbytes; + OffsetNumber seed_1 = 0, + seed_2 = 0; + OffsetNumber *left, + *right; + OffsetNumber maxoff; #ifdef GIST_DEBUG - fprintf(stderr, "picksplit\n"); + fprintf(stderr, "picksplit\n"); #endif - maxoff = ((VARSIZE(entryvec) - VARHDRSZ)/sizeof(GISTENTRY)) - 2; - nbytes = (maxoff + 2) * sizeof(OffsetNumber); - v->spl_left = (OffsetNumber *) palloc(nbytes); - v->spl_right = (OffsetNumber *) palloc(nbytes); - - firsttime = true; - waste = 0.0; - - for (i = FirstOffsetNumber; i < maxoff; i = OffsetNumberNext(i)) { - datum_alpha = (SEG *)(((GISTENTRY *)(VARDATA(entryvec)))[i].pred); - for (j = OffsetNumberNext(i); j <= maxoff; j = OffsetNumberNext(j)) { - datum_beta = (SEG *)(((GISTENTRY *)(VARDATA(entryvec)))[j].pred); - - /* compute the wasted space by unioning these guys */ - /* size_waste = size_union - size_inter; */ - union_d = (SEG *)seg_union(datum_alpha, datum_beta); - rt_seg_size(union_d, &size_union); - inter_d = (SEG *)seg_inter(datum_alpha, datum_beta); - rt_seg_size(inter_d, &size_inter); - size_waste = size_union - size_inter; - - pfree(union_d); - - if (inter_d != (SEG *) NULL) - pfree(inter_d); - - /* - * are these a more promising split that what we've - * already seen? - */ - - if (size_waste > waste || firsttime) { - waste = size_waste; - seed_1 = i; - seed_2 = j; - firsttime = false; - } + maxoff = ((VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY)) - 2; + nbytes = (maxoff + 2) * sizeof(OffsetNumber); + v->spl_left = (OffsetNumber *) palloc(nbytes); + v->spl_right = (OffsetNumber *) palloc(nbytes); + + firsttime = true; + waste = 0.0; + + for (i = FirstOffsetNumber; i < maxoff; i = OffsetNumberNext(i)) + { + datum_alpha = (SEG *) (((GISTENTRY *) (VARDATA(entryvec)))[i].pred); + for (j = OffsetNumberNext(i); j <= maxoff; j = OffsetNumberNext(j)) + { + datum_beta = (SEG *) (((GISTENTRY *) (VARDATA(entryvec)))[j].pred); + + /* compute the wasted space by unioning these guys */ + /* size_waste = size_union - size_inter; */ + union_d = (SEG *) seg_union(datum_alpha, datum_beta); + rt_seg_size(union_d, &size_union); + inter_d = (SEG *) seg_inter(datum_alpha, datum_beta); + rt_seg_size(inter_d, &size_inter); + size_waste = size_union - size_inter; + + pfree(union_d); + + if (inter_d != (SEG *) NULL) + pfree(inter_d); + + /* + * are these a more promising split that what we've already + * seen? + */ + + if (size_waste > waste || firsttime) + { + waste = size_waste; + seed_1 = i; + seed_2 = j; + firsttime = false; + } + } } - } - - left = v->spl_left; - v->spl_nleft = 0; - right = v->spl_right; - v->spl_nright = 0; - - datum_alpha = (SEG *)(((GISTENTRY *)(VARDATA(entryvec)))[seed_1].pred); - datum_l = (SEG *)seg_union(datum_alpha, datum_alpha); - rt_seg_size((SEG *)datum_l, &size_l); - datum_beta = (SEG *)(((GISTENTRY *)(VARDATA(entryvec)))[seed_2].pred);; - datum_r = (SEG *)seg_union(datum_beta, datum_beta); - rt_seg_size((SEG *)datum_r, &size_r); - - /* - * Now split up the regions between the two seeds. An important - * property of this split algorithm is that the split vector v - * has the indices of items to be split in order in its left and - * right vectors. We exploit this property by doing a merge in - * the code that actually splits the page. - * - * For efficiency, we also place the new index tuple in this loop. - * This is handled at the very end, when we have placed all the - * existing tuples and i == maxoff + 1. - */ - - maxoff = OffsetNumberNext(maxoff); - for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) { - + + left = v->spl_left; + v->spl_nleft = 0; + right = v->spl_right; + v->spl_nright = 0; + + datum_alpha = (SEG *) (((GISTENTRY *) (VARDATA(entryvec)))[seed_1].pred); + datum_l = (SEG *) seg_union(datum_alpha, datum_alpha); + rt_seg_size((SEG *) datum_l, &size_l); + datum_beta = (SEG *) (((GISTENTRY *) (VARDATA(entryvec)))[seed_2].pred);; + datum_r = (SEG *) seg_union(datum_beta, datum_beta); + rt_seg_size((SEG *) datum_r, &size_r); + /* - * If we've already decided where to place this item, just - * put it on the right list. Otherwise, we need to figure - * out which page needs the least enlargement in order to - * store the item. + * Now split up the regions between the two seeds. An important + * property of this split algorithm is that the split vector v has the + * indices of items to be split in order in its left and right + * vectors. We exploit this property by doing a merge in the code + * that actually splits the page. + * + * For efficiency, we also place the new index tuple in this loop. This + * is handled at the very end, when we have placed all the existing + * tuples and i == maxoff + 1. */ - - if (i == seed_1) { - *left++ = i; - v->spl_nleft++; - continue; - } else if (i == seed_2) { - *right++ = i; - v->spl_nright++; - continue; - } - - /* okay, which page needs least enlargement? */ - datum_alpha = (SEG *)(((GISTENTRY *)(VARDATA(entryvec)))[i].pred); - union_dl = (SEG *)seg_union(datum_l, datum_alpha); - union_dr = (SEG *)seg_union(datum_r, datum_alpha); - rt_seg_size((SEG *)union_dl, &size_alpha); - rt_seg_size((SEG *)union_dr, &size_beta); - - /* pick which page to add it to */ - if (size_alpha - size_l < size_beta - size_r) { - pfree(datum_l); - pfree(union_dr); - datum_l = union_dl; - size_l = size_alpha; - *left++ = i; - v->spl_nleft++; - } else { - pfree(datum_r); - pfree(union_dl); - datum_r = union_dr; - size_r = size_alpha; - *right++ = i; - v->spl_nright++; + + maxoff = OffsetNumberNext(maxoff); + for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) + { + + /* + * If we've already decided where to place this item, just put it + * on the right list. Otherwise, we need to figure out which page + * needs the least enlargement in order to store the item. + */ + + if (i == seed_1) + { + *left++ = i; + v->spl_nleft++; + continue; + } + else if (i == seed_2) + { + *right++ = i; + v->spl_nright++; + continue; + } + + /* okay, which page needs least enlargement? */ + datum_alpha = (SEG *) (((GISTENTRY *) (VARDATA(entryvec)))[i].pred); + union_dl = (SEG *) seg_union(datum_l, datum_alpha); + union_dr = (SEG *) seg_union(datum_r, datum_alpha); + rt_seg_size((SEG *) union_dl, &size_alpha); + rt_seg_size((SEG *) union_dr, &size_beta); + + /* pick which page to add it to */ + if (size_alpha - size_l < size_beta - size_r) + { + pfree(datum_l); + pfree(union_dr); + datum_l = union_dl; + size_l = size_alpha; + *left++ = i; + v->spl_nleft++; + } + else + { + pfree(datum_r); + pfree(union_dl); + datum_r = union_dr; + size_r = size_alpha; + *right++ = i; + v->spl_nright++; + } } - } - *left = *right = FirstOffsetNumber; /* sentinel value, see dosplit() */ - - v->spl_ldatum = (char *)datum_l; - v->spl_rdatum = (char *)datum_r; + *left = *right = FirstOffsetNumber; /* sentinel value, see dosplit() */ + + v->spl_ldatum = (char *) datum_l; + v->spl_rdatum = (char *) datum_r; - return v; + return v; } /* ** Equality methods */ bool * -gseg_same(SEG *b1, SEG *b2, bool *result) +gseg_same(SEG * b1, SEG * b2, bool *result) { - if (seg_same(b1, b2)) - *result = TRUE; - else *result = FALSE; + if (seg_same(b1, b2)) + *result = TRUE; + else + *result = FALSE; #ifdef GIST_DEBUG - fprintf(stderr, "same: %s\n", (*result ? "TRUE" : "FALSE" )); + fprintf(stderr, "same: %s\n", (*result ? "TRUE" : "FALSE")); #endif - return(result); + return (result); } -/* +/* ** SUPPORT ROUTINES */ -bool -gseg_leaf_consistent(SEG *key, - SEG *query, - StrategyNumber strategy) +bool +gseg_leaf_consistent(SEG * key, + SEG * query, + StrategyNumber strategy) { - bool retval; + bool retval; #ifdef GIST_QUERY_DEBUG - fprintf(stderr, "leaf_consistent, %d\n", strategy); + fprintf(stderr, "leaf_consistent, %d\n", strategy); #endif - switch(strategy) { - case RTLeftStrategyNumber: - retval = (bool)seg_left(key, query); - break; - case RTOverLeftStrategyNumber: - retval = (bool)seg_over_left(key,query); - break; - case RTOverlapStrategyNumber: - retval = (bool)seg_overlap(key, query); - break; - case RTOverRightStrategyNumber: - retval = (bool)seg_over_right(key, query); - break; - case RTRightStrategyNumber: - retval = (bool)seg_right(key, query); - break; - case RTSameStrategyNumber: - retval = (bool)seg_same(key, query); - break; - case RTContainsStrategyNumber: - retval = (bool)seg_contains(key, query); - break; - case RTContainedByStrategyNumber: - retval = (bool)seg_contained(key,query); - break; - default: - retval = FALSE; - } - return(retval); + switch (strategy) + { + case RTLeftStrategyNumber: + retval = (bool) seg_left(key, query); + break; + case RTOverLeftStrategyNumber: + retval = (bool) seg_over_left(key, query); + break; + case RTOverlapStrategyNumber: + retval = (bool) seg_overlap(key, query); + break; + case RTOverRightStrategyNumber: + retval = (bool) seg_over_right(key, query); + break; + case RTRightStrategyNumber: + retval = (bool) seg_right(key, query); + break; + case RTSameStrategyNumber: + retval = (bool) seg_same(key, query); + break; + case RTContainsStrategyNumber: + retval = (bool) seg_contains(key, query); + break; + case RTContainedByStrategyNumber: + retval = (bool) seg_contained(key, query); + break; + default: + retval = FALSE; + } + return (retval); } -bool -gseg_internal_consistent(SEG *key, - SEG *query, - StrategyNumber strategy) +bool +gseg_internal_consistent(SEG * key, + SEG * query, + StrategyNumber strategy) { - bool retval; + bool retval; #ifdef GIST_QUERY_DEBUG - fprintf(stderr, "internal_consistent, %d\n", strategy); + fprintf(stderr, "internal_consistent, %d\n", strategy); #endif - switch(strategy) { - case RTLeftStrategyNumber: - case RTOverLeftStrategyNumber: - retval = (bool)seg_over_left(key,query); - break; - case RTOverlapStrategyNumber: - retval = (bool)seg_overlap(key, query); - break; - case RTOverRightStrategyNumber: - case RTRightStrategyNumber: - retval = (bool)seg_right(key, query); - break; - case RTSameStrategyNumber: - case RTContainsStrategyNumber: - retval = (bool)seg_contains(key, query); - break; - case RTContainedByStrategyNumber: - retval = (bool)seg_overlap(key, query); - break; - default: - retval = FALSE; - } - return(retval); + switch (strategy) + { + case RTLeftStrategyNumber: + case RTOverLeftStrategyNumber: + retval = (bool) seg_over_left(key, query); + break; + case RTOverlapStrategyNumber: + retval = (bool) seg_overlap(key, query); + break; + case RTOverRightStrategyNumber: + case RTRightStrategyNumber: + retval = (bool) seg_right(key, query); + break; + case RTSameStrategyNumber: + case RTContainsStrategyNumber: + retval = (bool) seg_contains(key, query); + break; + case RTContainedByStrategyNumber: + retval = (bool) seg_overlap(key, query); + break; + default: + retval = FALSE; + } + return (retval); } SEG * -gseg_binary_union(SEG *r1, SEG *r2, int *sizep) +gseg_binary_union(SEG * r1, SEG * r2, int *sizep) { - SEG *retval; + SEG *retval; - retval = seg_union(r1, r2); - *sizep = sizeof(SEG); + retval = seg_union(r1, r2); + *sizep = sizeof(SEG); - return (retval); + return (retval); } bool -seg_contains(SEG *a, SEG *b) +seg_contains(SEG * a, SEG * b) { - return ( (a->lower <= b->lower) && (a->upper >= b->upper) ); + return ((a->lower <= b->lower) && (a->upper >= b->upper)); } bool -seg_contained(SEG *a, SEG *b) +seg_contained(SEG * a, SEG * b) { - return ( seg_contains(b, a) ); + return (seg_contains(b, a)); } /***************************************************************************** @@ -566,209 +607,214 @@ seg_contained(SEG *a, SEG *b) *****************************************************************************/ bool -seg_same(SEG *a, SEG *b) +seg_same(SEG * a, SEG * b) { - return seg_cmp(a, b) == 0; + return seg_cmp(a, b) == 0; } -/* seg_overlap -- does a overlap b? +/* seg_overlap -- does a overlap b? */ bool -seg_overlap(SEG *a, SEG *b) +seg_overlap(SEG * a, SEG * b) { - return ( - ((a->upper >= b->upper) && (a->lower <= b->upper)) - || - ((b->upper >= a->upper) && (b->lower <= a->upper)) - ); + return ( + ((a->upper >= b->upper) && (a->lower <= b->upper)) + || + ((b->upper >= a->upper) && (b->lower <= a->upper)) + ); } -/* seg_overleft -- is the right edge of (a) located to the left of the right edge of (b)? +/* seg_overleft -- is the right edge of (a) located to the left of the right edge of (b)? */ bool -seg_over_left(SEG *a, SEG *b) +seg_over_left(SEG * a, SEG * b) { - return ( a->upper <= b->upper && !seg_left(a, b) && !seg_right(a, b)); + return (a->upper <= b->upper && !seg_left(a, b) && !seg_right(a, b)); } -/* seg_left -- is (a) entirely on the left of (b)? +/* seg_left -- is (a) entirely on the left of (b)? */ bool -seg_left(SEG *a, SEG *b) +seg_left(SEG * a, SEG * b) { - return ( a->upper < b->lower ); + return (a->upper < b->lower); } -/* seg_right -- is (a) entirely on the right of (b)? +/* seg_right -- is (a) entirely on the right of (b)? */ bool -seg_right(SEG *a, SEG *b) +seg_right(SEG * a, SEG * b) { - return ( a->lower > b->upper ); + return (a->lower > b->upper); } -/* seg_overright -- is the left edge of (a) located to the right of the left edge of (b)? +/* seg_overright -- is the left edge of (a) located to the right of the left edge of (b)? */ bool -seg_over_right(SEG *a, SEG *b) +seg_over_right(SEG * a, SEG * b) { - return (a->lower >= b->lower && !seg_left(a, b) && !seg_right(a, b)); + return (a->lower >= b->lower && !seg_left(a, b) && !seg_right(a, b)); } SEG * -seg_union(SEG *a, SEG *b) +seg_union(SEG * a, SEG * b) { - SEG *n; - - n = (SEG *) palloc(sizeof(*n)); - - /* take max of upper endpoints */ - if (a->upper > b->upper) - { - n->upper = a->upper; - n->u_sigd = a->u_sigd; - n->u_ext = a->u_ext; - } - else - { - n->upper = b->upper; - n->u_sigd = b->u_sigd; - n->u_ext = b->u_ext; - } - - /* take min of lower endpoints */ - if (a->lower < b->lower) - { - n->lower = a->lower; - n->l_sigd = a->l_sigd; - n->l_ext = a->l_ext; - } - else - { - n->lower = b->lower; - n->l_sigd = b->l_sigd; - n->l_ext = b->l_ext; - } - - return (n); + SEG *n; + + n = (SEG *) palloc(sizeof(*n)); + + /* take max of upper endpoints */ + if (a->upper > b->upper) + { + n->upper = a->upper; + n->u_sigd = a->u_sigd; + n->u_ext = a->u_ext; + } + else + { + n->upper = b->upper; + n->u_sigd = b->u_sigd; + n->u_ext = b->u_ext; + } + + /* take min of lower endpoints */ + if (a->lower < b->lower) + { + n->lower = a->lower; + n->l_sigd = a->l_sigd; + n->l_ext = a->l_ext; + } + else + { + n->lower = b->lower; + n->l_sigd = b->l_sigd; + n->l_ext = b->l_ext; + } + + return (n); } SEG * -seg_inter(SEG *a, SEG *b) +seg_inter(SEG * a, SEG * b) { - SEG *n; - - n = (SEG *) palloc(sizeof(*n)); - - /* take min of upper endpoints */ - if (a->upper < b->upper) - { - n->upper = a->upper; - n->u_sigd = a->u_sigd; - n->u_ext = a->u_ext; - } - else - { - n->upper = b->upper; - n->u_sigd = b->u_sigd; - n->u_ext = b->u_ext; - } - - /* take max of lower endpoints */ - if (a->lower > b->lower) - { - n->lower = a->lower; - n->l_sigd = a->l_sigd; - n->l_ext = a->l_ext; - } - else - { - n->lower = b->lower; - n->l_sigd = b->l_sigd; - n->l_ext = b->l_ext; - } - - return (n); + SEG *n; + + n = (SEG *) palloc(sizeof(*n)); + + /* take min of upper endpoints */ + if (a->upper < b->upper) + { + n->upper = a->upper; + n->u_sigd = a->u_sigd; + n->u_ext = a->u_ext; + } + else + { + n->upper = b->upper; + n->u_sigd = b->u_sigd; + n->u_ext = b->u_ext; + } + + /* take max of lower endpoints */ + if (a->lower > b->lower) + { + n->lower = a->lower; + n->l_sigd = a->l_sigd; + n->l_ext = a->l_ext; + } + else + { + n->lower = b->lower; + n->l_sigd = b->l_sigd; + n->l_ext = b->l_ext; + } + + return (n); } void -rt_seg_size(SEG *a, float *size) +rt_seg_size(SEG * a, float *size) { - if (a == (SEG *) NULL || a->upper <= a->lower) - *size = 0.0; - else - *size = (float) abs(a->upper - a->lower); - - return; + if (a == (SEG *) NULL || a->upper <= a->lower) + *size = 0.0; + else + *size = (float) abs(a->upper - a->lower); + + return; } float * -seg_size(SEG *a) +seg_size(SEG * a) { - float *result; + float *result; + + result = (float *) palloc(sizeof(float)); - result = (float *) palloc(sizeof(float)); - - *result = (float) abs(a->upper - a->lower); + *result = (float) abs(a->upper - a->lower); - return(result); + return (result); } /***************************************************************************** - * Miscellaneous operators + * Miscellaneous operators *****************************************************************************/ int32 -seg_cmp(SEG *a, SEG *b) +seg_cmp(SEG * a, SEG * b) { + /* * First compare on lower boundary position */ - if ( a->lower < b->lower ) + if (a->lower < b->lower) return -1; - if ( a->lower > b->lower ) + if (a->lower > b->lower) return 1; + /* * a->lower == b->lower, so consider type of boundary. * - * A '-' lower bound is < any other kind (this could only be relevant - * if -HUGE is used as a regular data value). - * A '<' lower bound is < any other kind except '-'. - * A '>' lower bound is > any other kind. + * A '-' lower bound is < any other kind (this could only be relevant if + * -HUGE is used as a regular data value). A '<' lower bound is < any + * other kind except '-'. A '>' lower bound is > any other kind. */ - if ( a->l_ext != b->l_ext ) + if (a->l_ext != b->l_ext) { - if ( a->l_ext == '-') + if (a->l_ext == '-') return -1; - if ( b->l_ext == '-') + if (b->l_ext == '-') return 1; - if ( a->l_ext == '<') + if (a->l_ext == '<') return -1; - if ( b->l_ext == '<') + if (b->l_ext == '<') return 1; - if ( a->l_ext == '>') + if (a->l_ext == '>') return 1; - if ( b->l_ext == '>') + if (b->l_ext == '>') return -1; } + /* * For other boundary types, consider # of significant digits first. */ - if ( a->l_sigd < b->l_sigd ) /* (a) is blurred and is likely to include (b) */ + if (a->l_sigd < b->l_sigd) /* (a) is blurred and is likely to include + * (b) */ return -1; - if ( a->l_sigd > b->l_sigd ) /* (a) is less blurred and is likely to be included in (b) */ + if (a->l_sigd > b->l_sigd) /* (a) is less blurred and is likely to be + * included in (b) */ return 1; + /* * For same # of digits, an approximate boundary is more blurred than * exact. */ - if ( a->l_ext != b->l_ext ) + if (a->l_ext != b->l_ext) { - if ( a->l_ext == '~' ) /* (a) is approximate, while (b) is exact */ + if (a->l_ext == '~') /* (a) is approximate, while (b) is exact */ return -1; - if ( b->l_ext == '~' ) + if (b->l_ext == '~') return 1; /* can't get here unless data is corrupt */ elog(ERROR, "seg_cmp: bogus lower boundary types %d %d", @@ -780,50 +826,54 @@ seg_cmp(SEG *a, SEG *b) /* * First compare on upper boundary position */ - if ( a->upper < b->upper ) + if (a->upper < b->upper) return -1; - if ( a->upper > b->upper ) + if (a->upper > b->upper) return 1; + /* * a->upper == b->upper, so consider type of boundary. * - * A '-' upper bound is > any other kind (this could only be relevant - * if HUGE is used as a regular data value). - * A '<' upper bound is < any other kind. - * A '>' upper bound is > any other kind except '-'. + * A '-' upper bound is > any other kind (this could only be relevant if + * HUGE is used as a regular data value). A '<' upper bound is < any + * other kind. A '>' upper bound is > any other kind except '-'. */ - if ( a->u_ext != b->u_ext ) + if (a->u_ext != b->u_ext) { - if ( a->u_ext == '-') + if (a->u_ext == '-') return 1; - if ( b->u_ext == '-') + if (b->u_ext == '-') return -1; - if ( a->u_ext == '<') + if (a->u_ext == '<') return -1; - if ( b->u_ext == '<') + if (b->u_ext == '<') return 1; - if ( a->u_ext == '>') + if (a->u_ext == '>') return 1; - if ( b->u_ext == '>') + if (b->u_ext == '>') return -1; } + /* * For other boundary types, consider # of significant digits first. * Note result here is converse of the lower-boundary case. */ - if ( a->u_sigd < b->u_sigd ) /* (a) is blurred and is likely to include (b) */ + if (a->u_sigd < b->u_sigd) /* (a) is blurred and is likely to include + * (b) */ return 1; - if ( a->u_sigd > b->u_sigd ) /* (a) is less blurred and is likely to be included in (b) */ + if (a->u_sigd > b->u_sigd) /* (a) is less blurred and is likely to be + * included in (b) */ return -1; + /* * For same # of digits, an approximate boundary is more blurred than * exact. Again, result is converse of lower-boundary case. */ - if ( a->u_ext != b->u_ext ) + if (a->u_ext != b->u_ext) { - if ( a->u_ext == '~' ) /* (a) is approximate, while (b) is exact */ + if (a->u_ext == '~') /* (a) is approximate, while (b) is exact */ return 1; - if ( b->u_ext == '~' ) + if (b->u_ext == '~') return -1; /* can't get here unless data is corrupt */ elog(ERROR, "seg_cmp: bogus upper boundary types %d %d", @@ -834,40 +884,40 @@ seg_cmp(SEG *a, SEG *b) } bool -seg_lt(SEG *a, SEG *b) +seg_lt(SEG * a, SEG * b) { - return seg_cmp(a, b) < 0; + return seg_cmp(a, b) < 0; } bool -seg_le(SEG *a, SEG *b) +seg_le(SEG * a, SEG * b) { - return seg_cmp(a, b) <= 0; + return seg_cmp(a, b) <= 0; } bool -seg_gt(SEG *a, SEG *b) +seg_gt(SEG * a, SEG * b) { - return seg_cmp(a, b) > 0; + return seg_cmp(a, b) > 0; } bool -seg_ge(SEG *a, SEG *b) +seg_ge(SEG * a, SEG * b) { - return seg_cmp(a, b) >= 0; + return seg_cmp(a, b) >= 0; } bool -seg_different(SEG *a, SEG *b) +seg_different(SEG * a, SEG * b) { - return seg_cmp(a, b) != 0; + return seg_cmp(a, b) != 0; } /***************************************************************************** - * Auxiliary functions + * Auxiliary functions *****************************************************************************/ /* The purpose of this routine is to print the floating point @@ -875,126 +925,150 @@ seg_different(SEG *a, SEG *b) * is similar to %.ng except it prints 8.00 where %.ng would * print 8 */ -static int restore ( char * result, float val, int n ) +static int +restore(char *result, float val, int n) { - static char efmt[8] = {'%', '-', '1', '5', '.', '#', 'e', 0}; - char buf[25] = { - '0', '0', '0', '0', '0', - '0', '0', '0', '0', '0', - '0', '0', '0', '0', '0', - '0', '0', '0', '0', '0', - '0', '0', '0', '0', '\0' - }; - char *p; - char *mant; - int exp; - int i, dp, sign; - - /* put a cap on the number of siugnificant digits to avoid - nonsense in the output */ - n = min(n, FLT_DIG); - - /* remember the sign */ - sign = ( val < 0 ? 1 : 0 ); - - efmt[5] = '0' + (n-1)%10; /* makes %-15.(n-1)e -- this format guarantees that - the exponent is always present */ - - sprintf(result, efmt, val); - - /* trim the spaces left by the %e */ - for( p = result; *p != ' '; p++ ); *p = '\0'; - - /* get the exponent */ - mant = (char *)strtok( strdup(result), "e" ); - exp = atoi(strtok( NULL, "e" )); - - if ( exp == 0 ) { - /* use the supplied mantyssa with sign */ - strcpy((char *)index(result, 'e'), ""); - } - else { - if ( abs( exp ) <= 4 ) { - /* remove the decimal point from the mantyssa and write the digits to the buf array */ - for( p = result + sign, i = 10, dp = 0; *p != 'e'; p++, i++ ) { - buf[i] = *p; - if( *p == '.' ) { - dp = i--; /* skip the decimal point */ - } - } - if (dp == 0) dp = i--; /* no decimal point was found in the above for() loop */ - - if ( exp > 0 ) { - if ( dp - 10 + exp >= n ) { - /* - the decimal point is behind the last significant digit; - the digits in between must be converted to the exponent - and the decimal point placed after the first digit - */ - exp = dp - 10 + exp - n; - buf[10+n] = '\0'; - - /* insert the decimal point */ - if ( n > 1 ) { - dp = 11; - for ( i = 23; i > dp; i-- ) { - buf[i] = buf[i-1]; - } - buf[dp] = '.'; - } - - /* adjust the exponent by the number of digits after the decimal point */ - if ( n > 1 ) { - sprintf(&buf[11+n], "e%d", exp + n - 1); - } - else { - sprintf(&buf[11], "e%d", exp + n - 1); - } - - if ( sign ) { - buf[9] = '-'; - strcpy(result, &buf[9]); - } - else { - strcpy(result, &buf[10]); - } - } - else { /* insert the decimal point */ - dp += exp; - for ( i = 23; i > dp; i-- ) { - buf[i] = buf[i-1]; - } - buf[11+n] = '\0'; - buf[dp] = '.'; - if ( sign ) { - buf[9] = '-'; - strcpy(result, &buf[9]); - } - else { - strcpy(result, &buf[10]); - } + static char efmt[8] = {'%', '-', '1', '5', '.', '#', 'e', 0}; + char buf[25] = { + '0', '0', '0', '0', '0', + '0', '0', '0', '0', '0', + '0', '0', '0', '0', '0', + '0', '0', '0', '0', '0', + '0', '0', '0', '0', '\0' + }; + char *p; + char *mant; + int exp; + int i, + dp, + sign; + + /* + * put a cap on the number of siugnificant digits to avoid nonsense in + * the output + */ + n = min(n, FLT_DIG); + + /* remember the sign */ + sign = (val < 0 ? 1 : 0); + + efmt[5] = '0' + (n - 1) % 10; /* makes %-15.(n-1)e -- this + * format guarantees that the + * exponent is always present */ + + sprintf(result, efmt, val); + + /* trim the spaces left by the %e */ + for (p = result; *p != ' '; p++); + *p = '\0'; + + /* get the exponent */ + mant = (char *) strtok(strdup(result), "e"); + exp = atoi(strtok(NULL, "e")); + + if (exp == 0) + { + /* use the supplied mantyssa with sign */ + strcpy((char *) index(result, 'e'), ""); } - } - else { /* exp <= 0 */ - dp += exp - 1; - buf[10+n] = '\0'; - buf[dp] = '.'; - if ( sign ) { - buf[dp-2] = '-'; - strcpy(result, &buf[dp-2]); + else + { + if (abs(exp) <= 4) + { + + /* + * remove the decimal point from the mantyssa and write the + * digits to the buf array + */ + for (p = result + sign, i = 10, dp = 0; *p != 'e'; p++, i++) + { + buf[i] = *p; + if (*p == '.') + { + dp = i--; /* skip the decimal point */ + } + } + if (dp == 0) + dp = i--; /* no decimal point was found in the above + * for() loop */ + + if (exp > 0) + { + if (dp - 10 + exp >= n) + { + + /* + * the decimal point is behind the last significant + * digit; the digits in between must be converted to + * the exponent and the decimal point placed after the + * first digit + */ + exp = dp - 10 + exp - n; + buf[10 + n] = '\0'; + + /* insert the decimal point */ + if (n > 1) + { + dp = 11; + for (i = 23; i > dp; i--) + buf[i] = buf[i - 1]; + buf[dp] = '.'; + } + + /* + * adjust the exponent by the number of digits after + * the decimal point + */ + if (n > 1) + sprintf(&buf[11 + n], "e%d", exp + n - 1); + else + sprintf(&buf[11], "e%d", exp + n - 1); + + if (sign) + { + buf[9] = '-'; + strcpy(result, &buf[9]); + } + else + strcpy(result, &buf[10]); + } + else + { /* insert the decimal point */ + dp += exp; + for (i = 23; i > dp; i--) + buf[i] = buf[i - 1]; + buf[11 + n] = '\0'; + buf[dp] = '.'; + if (sign) + { + buf[9] = '-'; + strcpy(result, &buf[9]); + } + else + strcpy(result, &buf[10]); + } + } + else + { /* exp <= 0 */ + dp += exp - 1; + buf[10 + n] = '\0'; + buf[dp] = '.'; + if (sign) + { + buf[dp - 2] = '-'; + strcpy(result, &buf[dp - 2]); + } + else + strcpy(result, &buf[dp - 1]); + } + } + + /* do nothing for abs(exp) > 4; %e must be OK */ + /* just get rid of zeroes after [eE]- and +zeroes after [Ee]. */ + + /* ... this is not done yet. */ } - else { - strcpy(result, &buf[dp-1]); - } - } - } - - /* do nothing for abs(exp) > 4; %e must be OK */ - /* just get rid of zeroes after [eE]- and +zeroes after [Ee]. */ - - /* ... this is not done yet. */ - } - return ( strlen ( result ) ); + return (strlen(result)); } @@ -1003,47 +1077,56 @@ static int restore ( char * result, float val, int n ) */ bool -seg_contains_int(SEG *a, int *b) +seg_contains_int(SEG * a, int *b) { - return ( (a->lower <= *b) && (a->upper >= *b) ); + return ((a->lower <= *b) && (a->upper >= *b)); } bool -seg_contains_float4(SEG *a, float4 *b) +seg_contains_float4(SEG * a, float4 *b) { - return ( (a->lower <= *b) && (a->upper >= *b) ); + return ((a->lower <= *b) && (a->upper >= *b)); } bool -seg_contains_float8(SEG *a, float8 *b) +seg_contains_float8(SEG * a, float8 *b) { - return ( (a->lower <= *b) && (a->upper >= *b) ); + return ((a->lower <= *b) && (a->upper >= *b)); } -/* find out the number of significant digits in a string representing +/* find out the number of significant digits in a string representing * a floating point number */ -int significant_digits ( char* s ) +int +significant_digits(char *s) { - char * p = s; - int n, c, zeroes; + char *p = s; + int n, + c, + zeroes; - zeroes = 1; - /* skip leading zeroes and sign */ - for ( c = *p; (c == '0' || c == '+' || c == '-') && c != 0; c = *(++p) ); + zeroes = 1; + /* skip leading zeroes and sign */ + for (c = *p; (c == '0' || c == '+' || c == '-') && c != 0; c = *(++p)); - /* skip decimal point and following zeroes */ - for ( c = *p; (c == '0' || c == '.' ) && c != 0; c = *(++p) ) { - if ( c != '.') zeroes++; - } + /* skip decimal point and following zeroes */ + for (c = *p; (c == '0' || c == '.') && c != 0; c = *(++p)) + { + if (c != '.') + zeroes++; + } - /* count significant digits (n) */ - for ( c = *p, n = 0; c != 0; c = *(++p) ) { - if ( !( (c >= '0' && c <= '9') || (c == '.') ) ) break; - if ( c != '.') n++; - } + /* count significant digits (n) */ + for (c = *p, n = 0; c != 0; c = *(++p)) + { + if (!((c >= '0' && c <= '9') || (c == '.'))) + break; + if (c != '.') + n++; + } - if (!n) return ( zeroes ); + if (!n) + return (zeroes); - return( n ); + return (n); } diff --git a/contrib/seg/segdata.h b/contrib/seg/segdata.h index 709f576340..773883bbb7 100644 --- a/contrib/seg/segdata.h +++ b/contrib/seg/segdata.h @@ -1,8 +1,9 @@ -typedef struct SEG { - float lower; - float upper; - char l_sigd; - char u_sigd; - char l_ext; - char u_ext; -} SEG; +typedef struct SEG +{ + float lower; + float upper; + char l_sigd; + char u_sigd; + char l_ext; + char u_ext; +} SEG; diff --git a/contrib/soundex/soundex.c b/contrib/soundex/soundex.c index 5a7e238e38..ff1b0f7aec 100644 --- a/contrib/soundex/soundex.c +++ b/contrib/soundex/soundex.c @@ -1,4 +1,4 @@ -/* $Header: /cvsroot/pgsql/contrib/soundex/Attic/soundex.c,v 1.10 2001/02/10 02:31:26 tgl Exp $ */ +/* $Header: /cvsroot/pgsql/contrib/soundex/Attic/soundex.c,v 1.11 2001/03/22 03:59:10 momjian Exp $ */ #include "postgres.h" #include <ctype.h> @@ -7,7 +7,7 @@ #include "utils/builtins.h" -Datum text_soundex(PG_FUNCTION_ARGS); +Datum text_soundex(PG_FUNCTION_ARGS); static void soundex(const char *instr, char *outstr); @@ -37,11 +37,12 @@ text_soundex(PG_FUNCTION_ARGS) PG_RETURN_TEXT_P(_textin(outstr)); } -#endif /* not SOUNDEX_TEST */ +#endif /* not SOUNDEX_TEST */ -/* ABCDEFGHIJKLMNOPQRSTUVWXYZ */ +/* ABCDEFGHIJKLMNOPQRSTUVWXYZ */ static const char *soundex_table = "01230120022455012623010202"; + #define soundex_code(letter) soundex_table[toupper((unsigned char) (letter)) - 'A'] @@ -98,7 +99,7 @@ soundex(const char *instr, char *outstr) #ifdef SOUNDEX_TEST int -main (int argc, char *argv[]) +main(int argc, char *argv[]) { if (argc < 2) { @@ -107,11 +108,12 @@ main (int argc, char *argv[]) } else { - char output[SOUNDEX_LEN + 1]; + char output[SOUNDEX_LEN + 1]; soundex(argv[1], output); printf("soundex(%s) = %s\n", argv[1], output); return 0; } } -#endif /* SOUNDEX_TEST */ + +#endif /* SOUNDEX_TEST */ diff --git a/contrib/spi/insert_username.c b/contrib/spi/insert_username.c index 3d083bf2f0..0bedaa98ae 100644 --- a/contrib/spi/insert_username.c +++ b/contrib/spi/insert_username.c @@ -10,7 +10,7 @@ #include "commands/trigger.h" /* -"- and triggers */ #include "miscadmin.h" /* for GetUserName() */ -extern Datum insert_username(PG_FUNCTION_ARGS); +extern Datum insert_username(PG_FUNCTION_ARGS); PG_FUNCTION_INFO_V1(insert_username); @@ -65,7 +65,7 @@ insert_username(PG_FUNCTION_ARGS) /* create fields containing name */ newval = DirectFunctionCall1(textin, - CStringGetDatum(GetUserName(GetUserId()))); + CStringGetDatum(GetUserName(GetUserId()))); /* construct new tuple */ rettuple = SPI_modifytuple(rel, rettuple, 1, &attnum, &newval, NULL); diff --git a/contrib/spi/moddatetime.c b/contrib/spi/moddatetime.c index 73b1518518..bd45dc72b3 100644 --- a/contrib/spi/moddatetime.c +++ b/contrib/spi/moddatetime.c @@ -15,7 +15,7 @@ OH, me, I'm Terry Mackintosh <[email protected]> #include "executor/spi.h" /* this is what you need to work with SPI */ #include "commands/trigger.h" /* -"- and triggers */ -extern Datum moddatetime(PG_FUNCTION_ARGS); +extern Datum moddatetime(PG_FUNCTION_ARGS); PG_FUNCTION_INFO_V1(moddatetime); diff --git a/contrib/spi/timetravel.c b/contrib/spi/timetravel.c index 90341e208d..bc8a1112f4 100644 --- a/contrib/spi/timetravel.c +++ b/contrib/spi/timetravel.c @@ -373,7 +373,7 @@ set_timetravel(PG_FUNCTION_ARGS) else TTOff = realloc(TTOff, (nTTOff + 1) * sizeof(char *)); s = rname = DatumGetCString(DirectFunctionCall1(nameout, - NameGetDatum(relname))); + NameGetDatum(relname))); d = TTOff[nTTOff] = malloc(strlen(rname) + 1); while (*s) *d++ = tolower((unsigned char) *s++); diff --git a/contrib/vacuumlo/vacuumlo.c b/contrib/vacuumlo/vacuumlo.c index 4fdad73e09..002c77fb61 100644 --- a/contrib/vacuumlo/vacuumlo.c +++ b/contrib/vacuumlo/vacuumlo.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/contrib/vacuumlo/vacuumlo.c,v 1.8 2001/01/24 19:42:45 momjian Exp $ + * $Header: /cvsroot/pgsql/contrib/vacuumlo/vacuumlo.c,v 1.9 2001/03/22 03:59:11 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -76,6 +76,7 @@ vacuumlo(char *database, int verbose) return -1; } PQclear(res); + /* * Vacuum the temp table so that planner will generate decent plans * for the DELETEs below. @@ -96,13 +97,13 @@ vacuumlo(char *database, int verbose) /* * Now find any candidate tables who have columns of type oid. * - * NOTE: the temp table formed above is ignored, because its real - * table name will be pg_something. Also, pg_largeobject will be - * ignored. If either of these were scanned, obviously we'd end up - * with nothing to delete... + * NOTE: the temp table formed above is ignored, because its real table + * name will be pg_something. Also, pg_largeobject will be ignored. + * If either of these were scanned, obviously we'd end up with nothing + * to delete... * - * NOTE: the system oid column is ignored, as it has attnum < 1. - * This shouldn't matter for correctness, but it saves time. + * NOTE: the system oid column is ignored, as it has attnum < 1. This + * shouldn't matter for correctness, but it saves time. */ buf[0] = '\0'; strcat(buf, "SELECT c.relname, a.attname "); @@ -135,9 +136,9 @@ vacuumlo(char *database, int verbose) fprintf(stdout, "Checking %s in %s\n", field, table); /* - * We use a DELETE with implicit join for efficiency. This - * is a Postgres-ism and not portable to other DBMSs, but - * then this whole program is a Postgres-ism. + * We use a DELETE with implicit join for efficiency. This is a + * Postgres-ism and not portable to other DBMSs, but then this + * whole program is a Postgres-ism. */ sprintf(buf, "DELETE FROM vacuum_l WHERE lo = \"%s\".\"%s\" ", table, field); @@ -157,10 +158,10 @@ vacuumlo(char *database, int verbose) PQclear(res); /* - * Run the actual deletes in a single transaction. Note that this + * Run the actual deletes in a single transaction. Note that this * would be a bad idea in pre-7.1 Postgres releases (since rolling - * back a table delete used to cause problems), but it should - * be safe now. + * back a table delete used to cause problems), but it should be safe + * now. */ res = PQexec(conn, "begin"); PQclear(res); diff --git a/src/backend/access/common/heaptuple.c b/src/backend/access/common/heaptuple.c index 03d180e36f..9bb0805494 100644 --- a/src/backend/access/common/heaptuple.c +++ b/src/backend/access/common/heaptuple.c @@ -9,7 +9,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/common/heaptuple.c,v 1.69 2001/01/24 19:42:46 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/common/heaptuple.c,v 1.70 2001/03/22 03:59:11 momjian Exp $ * * NOTES * The old interface functions have been converted to macros @@ -306,8 +306,8 @@ nocachegetattr(HeapTuple tuple, int j; /* - * In for(), we test <= and not < because we want to see - * if we can go past it in initializing offsets. + * In for(), we test <= and not < because we want to see if we + * can go past it in initializing offsets. */ for (j = 0; j <= attnum; j++) { @@ -321,9 +321,9 @@ nocachegetattr(HeapTuple tuple, } /* - * If slow is false, and we got here, we know that we have a tuple with - * no nulls or varlenas before the target attribute. If possible, we - * also want to initialize the remainder of the attribute cached + * If slow is false, and we got here, we know that we have a tuple + * with no nulls or varlenas before the target attribute. If possible, + * we also want to initialize the remainder of the attribute cached * offset values. */ if (!slow) diff --git a/src/backend/access/common/indextuple.c b/src/backend/access/common/indextuple.c index e503d9b888..da8129f307 100644 --- a/src/backend/access/common/indextuple.c +++ b/src/backend/access/common/indextuple.c @@ -9,7 +9,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/common/indextuple.c,v 1.52 2001/02/22 21:48:48 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/common/indextuple.c,v 1.53 2001/03/22 03:59:11 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -45,9 +45,11 @@ index_formtuple(TupleDesc tupleDescriptor, bool hasnull = false; uint16 tupmask = 0; int numberOfAttributes = tupleDescriptor->natts; + #ifdef TOAST_INDEX_HACK Datum untoasted_value[INDEX_MAX_KEYS]; bool untoasted_free[INDEX_MAX_KEYS]; + #endif if (numberOfAttributes > INDEX_MAX_KEYS) @@ -57,7 +59,7 @@ index_formtuple(TupleDesc tupleDescriptor, #ifdef TOAST_INDEX_HACK for (i = 0; i < numberOfAttributes; i++) { - Form_pg_attribute att = tupleDescriptor->attrs[i]; + Form_pg_attribute att = tupleDescriptor->attrs[i]; untoasted_value[i] = value[i]; untoasted_free[i] = false; @@ -73,20 +75,20 @@ index_formtuple(TupleDesc tupleDescriptor, if (VARATT_IS_EXTERNAL(value[i])) { untoasted_value[i] = PointerGetDatum( - heap_tuple_fetch_attr( - (varattrib *) DatumGetPointer(value[i]))); + heap_tuple_fetch_attr( + (varattrib *) DatumGetPointer(value[i]))); untoasted_free[i] = true; } /* - * If value is above size target, and is of a compressible datatype, - * try to compress it in-line. + * If value is above size target, and is of a compressible + * datatype, try to compress it in-line. */ if (VARATT_SIZE(untoasted_value[i]) > TOAST_INDEX_TARGET && !VARATT_IS_EXTENDED(untoasted_value[i]) && (att->attstorage == 'x' || att->attstorage == 'm')) { - Datum cvalue = toast_compress_datum(untoasted_value[i]); + Datum cvalue = toast_compress_datum(untoasted_value[i]); if (DatumGetPointer(cvalue) != NULL) { @@ -146,8 +148,8 @@ index_formtuple(TupleDesc tupleDescriptor, /* * We do this because DataFill wants to initialize a "tupmask" which * is used for HeapTuples, but we want an indextuple infomask. The - * only relevant info is the "has variable attributes" field. - * We have already set the hasnull bit above. + * only relevant info is the "has variable attributes" field. We have + * already set the hasnull bit above. */ if (tupmask & HEAP_HASVARLENA) @@ -315,9 +317,9 @@ nocache_index_getattr(IndexTuple tup, } /* - * If slow is false, and we got here, we know that we have a tuple with - * no nulls or varlenas before the target attribute. If possible, we - * also want to initialize the remainder of the attribute cached + * If slow is false, and we got here, we know that we have a tuple + * with no nulls or varlenas before the target attribute. If possible, + * we also want to initialize the remainder of the attribute cached * offset values. */ if (!slow) @@ -391,9 +393,7 @@ nocache_index_getattr(IndexTuple tup, usecache = false; } else - { off += att[i]->attlen; - } } off = att_align(off, att[attnum]->attlen, att[attnum]->attalign); diff --git a/src/backend/access/common/printtup.c b/src/backend/access/common/printtup.c index 4f47ef0d45..d44bfe973e 100644 --- a/src/backend/access/common/printtup.c +++ b/src/backend/access/common/printtup.c @@ -9,7 +9,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/common/printtup.c,v 1.57 2001/01/24 19:42:47 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/common/printtup.c,v 1.58 2001/03/22 03:59:11 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -51,7 +51,7 @@ getTypeOutputInfo(Oid type, Oid *typOutput, Oid *typElem, *typOutput = pt->typoutput; *typElem = pt->typelem; - *typIsVarlena = (! pt->typbyval) && (pt->typlen == -1); + *typIsVarlena = (!pt->typbyval) && (pt->typlen == -1); ReleaseSysCache(typeTuple); return OidIsValid(*typOutput); } @@ -200,9 +200,10 @@ printtup(HeapTuple tuple, TupleDesc typeinfo, DestReceiver *self) continue; if (OidIsValid(thisState->typoutput)) { + /* - * If we have a toasted datum, forcibly detoast it here to avoid - * memory leakage inside the type's output routine. + * If we have a toasted datum, forcibly detoast it here to + * avoid memory leakage inside the type's output routine. */ if (thisState->typisvarlena) attr = PointerGetDatum(PG_DETOAST_DATUM(origattr)); @@ -210,9 +211,9 @@ printtup(HeapTuple tuple, TupleDesc typeinfo, DestReceiver *self) attr = origattr; outputstr = DatumGetCString(FunctionCall3(&thisState->finfo, - attr, - ObjectIdGetDatum(thisState->typelem), - Int32GetDatum(typeinfo->attrs[i]->atttypmod))); + attr, + ObjectIdGetDatum(thisState->typelem), + Int32GetDatum(typeinfo->attrs[i]->atttypmod))); pq_sendcountedtext(&buf, outputstr, strlen(outputstr)); @@ -308,9 +309,10 @@ debugtup(HeapTuple tuple, TupleDesc typeinfo, DestReceiver *self) if (getTypeOutputInfo(typeinfo->attrs[i]->atttypid, &typoutput, &typelem, &typisvarlena)) { + /* - * If we have a toasted datum, forcibly detoast it here to avoid - * memory leakage inside the type's output routine. + * If we have a toasted datum, forcibly detoast it here to + * avoid memory leakage inside the type's output routine. */ if (typisvarlena) attr = PointerGetDatum(PG_DETOAST_DATUM(origattr)); @@ -318,9 +320,9 @@ debugtup(HeapTuple tuple, TupleDesc typeinfo, DestReceiver *self) attr = origattr; value = DatumGetCString(OidFunctionCall3(typoutput, - attr, - ObjectIdGetDatum(typelem), - Int32GetDatum(typeinfo->attrs[i]->atttypmod))); + attr, + ObjectIdGetDatum(typelem), + Int32GetDatum(typeinfo->attrs[i]->atttypmod))); printatt((unsigned) i + 1, typeinfo->attrs[i], value); @@ -405,6 +407,7 @@ printtup_internal(HeapTuple tuple, TupleDesc typeinfo, DestReceiver *self) /* send # of bytes, and opaque data */ if (thisState->typisvarlena) { + /* * If we have a toasted datum, must detoast before sending. */ diff --git a/src/backend/access/common/tupdesc.c b/src/backend/access/common/tupdesc.c index 86bc1a56f8..e07c6296d1 100644 --- a/src/backend/access/common/tupdesc.c +++ b/src/backend/access/common/tupdesc.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/common/tupdesc.c,v 1.71 2001/01/24 19:42:47 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/common/tupdesc.c,v 1.72 2001/03/22 03:59:11 momjian Exp $ * * NOTES * some of the executor utility code such as "ExecTypeFromTL" should be @@ -242,9 +242,9 @@ equalTupleDescs(TupleDesc tupdesc1, TupleDesc tupdesc2) /* * We do not need to check every single field here, and in fact * some fields such as attdispersion probably shouldn't be - * compared. We can also disregard attnum (it was used to - * place the row in the attrs array) and everything derived - * from the column datatype. + * compared. We can also disregard attnum (it was used to place + * the row in the attrs array) and everything derived from the + * column datatype. */ if (strcmp(NameStr(attr1->attname), NameStr(attr2->attname)) != 0) return false; @@ -276,8 +276,8 @@ equalTupleDescs(TupleDesc tupdesc1, TupleDesc tupdesc2) /* * We can't assume that the items are always read from the - * system catalogs in the same order; so use the adnum field to - * identify the matching item to compare. + * system catalogs in the same order; so use the adnum field + * to identify the matching item to compare. */ for (j = 0; j < n; defval2++, j++) { @@ -298,9 +298,9 @@ equalTupleDescs(TupleDesc tupdesc1, TupleDesc tupdesc2) ConstrCheck *check2 = constr2->check; /* - * Similarly, don't assume that the checks are always read - * in the same order; match them up by name and contents. - * (The name *should* be unique, but...) + * Similarly, don't assume that the checks are always read in + * the same order; match them up by name and contents. (The + * name *should* be unique, but...) */ for (j = 0; j < n; check2++, j++) { diff --git a/src/backend/access/gist/gist.c b/src/backend/access/gist/gist.c index 9e3f935bd6..1c5577b88a 100644 --- a/src/backend/access/gist/gist.c +++ b/src/backend/access/gist/gist.c @@ -6,7 +6,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/gist/gist.c,v 1.71 2001/03/07 21:20:26 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/gist/gist.c,v 1.72 2001/03/22 03:59:12 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -25,61 +25,62 @@ #include "access/xlogutils.h" -/* result's status */ +/* result's status */ #define INSERTED 0x01 #define SPLITED 0x02 /* non-export function prototypes */ -static void gistdoinsert(Relation r, - IndexTuple itup, - InsertIndexResult *res, - GISTSTATE *GISTstate); -static int gistlayerinsert( Relation r, BlockNumber blkno, - IndexTuple **itup, - int *len, - InsertIndexResult *res, - GISTSTATE *giststate ); -static OffsetNumber gistwritebuffer( Relation r, - Page page, - IndexTuple *itup, - int len, - OffsetNumber off, - GISTSTATE *giststate ); -static int gistnospace( Page page, - IndexTuple *itvec, int len ); -static IndexTuple * gistreadbuffer( Relation r, - Buffer buffer, int *len ); -static IndexTuple * gistjoinvector( - IndexTuple *itvec, int *len, - IndexTuple *additvec, int addlen ); -static IndexTuple gistunion( Relation r, IndexTuple *itvec, - int len, GISTSTATE *giststate ); -static IndexTuple gistgetadjusted( Relation r, - IndexTuple oldtup, - IndexTuple addtup, - GISTSTATE *giststate ); -static IndexTuple * gistSplit(Relation r, - Buffer buffer, - IndexTuple *itup, - int *len, - GISTSTATE *giststate, - InsertIndexResult *res); -static void gistnewroot(GISTSTATE *giststate, Relation r, +static void gistdoinsert(Relation r, + IndexTuple itup, + InsertIndexResult *res, + GISTSTATE *GISTstate); +static int gistlayerinsert(Relation r, BlockNumber blkno, + IndexTuple **itup, + int *len, + InsertIndexResult *res, + GISTSTATE *giststate); +static OffsetNumber gistwritebuffer(Relation r, + Page page, + IndexTuple *itup, + int len, + OffsetNumber off, + GISTSTATE *giststate); +static int gistnospace(Page page, + IndexTuple *itvec, int len); +static IndexTuple *gistreadbuffer(Relation r, + Buffer buffer, int *len); +static IndexTuple *gistjoinvector( + IndexTuple *itvec, int *len, + IndexTuple *additvec, int addlen); +static IndexTuple gistunion(Relation r, IndexTuple *itvec, + int len, GISTSTATE *giststate); +static IndexTuple gistgetadjusted(Relation r, + IndexTuple oldtup, + IndexTuple addtup, + GISTSTATE *giststate); +static IndexTuple *gistSplit(Relation r, + Buffer buffer, + IndexTuple *itup, + int *len, + GISTSTATE *giststate, + InsertIndexResult *res); +static void gistnewroot(GISTSTATE *giststate, Relation r, IndexTuple *itup, int len); static void GISTInitBuffer(Buffer b, uint32 f); -static OffsetNumber gistchoose(Relation r, Page p, - IndexTuple it, - GISTSTATE *giststate); -static IndexTuple gist_tuple_replacekey(Relation r, - GISTENTRY entry, IndexTuple t); -static void gistcentryinit(GISTSTATE *giststate, - GISTENTRY *e, char *pr, - Relation r, Page pg, - OffsetNumber o, int b, bool l); +static OffsetNumber gistchoose(Relation r, Page p, + IndexTuple it, + GISTSTATE *giststate); +static IndexTuple gist_tuple_replacekey(Relation r, + GISTENTRY entry, IndexTuple t); +static void gistcentryinit(GISTSTATE *giststate, + GISTENTRY *e, char *pr, + Relation r, Page pg, + OffsetNumber o, int b, bool l); #undef GISTDEBUG #ifdef GISTDEBUG static void gist_dumptree(Relation r, int level, BlockNumber blk, OffsetNumber coff); + #endif /* @@ -88,12 +89,14 @@ static void gist_dumptree(Relation r, int level, BlockNumber blk, OffsetNumber c Datum gistbuild(PG_FUNCTION_ARGS) { - Relation heap = (Relation) PG_GETARG_POINTER(0); - Relation index = (Relation) PG_GETARG_POINTER(1); - IndexInfo *indexInfo = (IndexInfo *) PG_GETARG_POINTER(2); - Node *oldPred = (Node *) PG_GETARG_POINTER(3); + Relation heap = (Relation) PG_GETARG_POINTER(0); + Relation index = (Relation) PG_GETARG_POINTER(1); + IndexInfo *indexInfo = (IndexInfo *) PG_GETARG_POINTER(2); + Node *oldPred = (Node *) PG_GETARG_POINTER(3); + #ifdef NOT_USED - IndexStrategy istrat = (IndexStrategy) PG_GETARG_POINTER(4); + IndexStrategy istrat = (IndexStrategy) PG_GETARG_POINTER(4); + #endif HeapScanDesc hscan; HeapTuple htup; @@ -105,9 +108,11 @@ gistbuild(PG_FUNCTION_ARGS) int nhtups, nitups; Node *pred = indexInfo->ii_Predicate; + #ifndef OMIT_PARTIAL_INDEX TupleTable tupleTable; TupleTableSlot *slot; + #endif ExprContext *econtext; GISTSTATE giststate; @@ -181,6 +186,7 @@ gistbuild(PG_FUNCTION_ARGS) nhtups++; #ifndef OMIT_PARTIAL_INDEX + /* * If oldPred != NULL, this is an EXTEND INDEX command, so skip * this tuple if it was already in the existing partial index @@ -262,9 +268,7 @@ gistbuild(PG_FUNCTION_ARGS) #ifndef OMIT_PARTIAL_INDEX if (pred != NULL || oldPred != NULL) - { ExecDropTupleTable(tupleTable, true); - } #endif /* OMIT_PARTIAL_INDEX */ FreeExprContext(econtext); @@ -297,7 +301,7 @@ gistbuild(PG_FUNCTION_ARGS) } #ifdef GISTDEBUG -gist_dumptree(index, 0, GISTP_ROOT, 0); + gist_dumptree(index, 0, GISTP_ROOT, 0); #endif PG_RETURN_VOID(); @@ -312,12 +316,14 @@ gist_dumptree(index, 0, GISTP_ROOT, 0); Datum gistinsert(PG_FUNCTION_ARGS) { - Relation r = (Relation) PG_GETARG_POINTER(0); - Datum *datum = (Datum *) PG_GETARG_POINTER(1); - char *nulls = (char *) PG_GETARG_POINTER(2); - ItemPointer ht_ctid = (ItemPointer) PG_GETARG_POINTER(3); + Relation r = (Relation) PG_GETARG_POINTER(0); + Datum *datum = (Datum *) PG_GETARG_POINTER(1); + char *nulls = (char *) PG_GETARG_POINTER(2); + ItemPointer ht_ctid = (ItemPointer) PG_GETARG_POINTER(3); + #ifdef NOT_USED - Relation heapRel = (Relation) PG_GETARG_POINTER(4); + Relation heapRel = (Relation) PG_GETARG_POINTER(4); + #endif InsertIndexResult res; IndexTuple itup; @@ -380,7 +386,7 @@ gistPageAddItem(GISTSTATE *giststate, { GISTENTRY tmpcentry; IndexTuple itup = (IndexTuple) item; - OffsetNumber retval; + OffsetNumber retval; /* * recompress the item given that we now know the exact page and @@ -394,7 +400,7 @@ gistPageAddItem(GISTSTATE *giststate, offsetNumber, dentry->bytes, FALSE); *newtup = gist_tuple_replacekey(r, tmpcentry, itup); retval = PageAddItem(page, (Item) *newtup, IndexTupleSize(*newtup), - offsetNumber, flags); + offsetNumber, flags); if (retval == InvalidOffsetNumber) elog(ERROR, "gist: failed to add index item to %s", RelationGetRelationName(r)); @@ -405,189 +411,213 @@ gistPageAddItem(GISTSTATE *giststate, return (retval); } -static void -gistdoinsert( Relation r, - IndexTuple itup, - InsertIndexResult *res, - GISTSTATE *giststate ) { +static void +gistdoinsert(Relation r, + IndexTuple itup, + InsertIndexResult *res, + GISTSTATE *giststate) +{ IndexTuple *instup; - int i,ret,len = 1; + int i, + ret, + len = 1; + + instup = (IndexTuple *) palloc(sizeof(IndexTuple)); + instup[0] = (IndexTuple) palloc(IndexTupleSize(itup)); + memcpy(instup[0], itup, IndexTupleSize(itup)); - instup = ( IndexTuple* ) palloc( sizeof(IndexTuple) ); - instup[0] = ( IndexTuple ) palloc( IndexTupleSize( itup ) ); - memcpy( instup[0], itup, IndexTupleSize( itup ) ); - ret = gistlayerinsert(r, GISTP_ROOT, &instup, &len, res, giststate); - if ( ret & SPLITED ) - gistnewroot( giststate, r, instup, len ); + if (ret & SPLITED) + gistnewroot(giststate, r, instup, len); - for(i=0;i<len;i++) - pfree( instup[i] ); - pfree( instup ); + for (i = 0; i < len; i++) + pfree(instup[i]); + pfree(instup); } static int -gistlayerinsert( Relation r, BlockNumber blkno, - IndexTuple **itup, /* in - out, has compressed entry */ - int *len , /* in - out */ - InsertIndexResult *res, /* out */ - GISTSTATE *giststate ) { - Buffer buffer; - Page page; - OffsetNumber child; - int ret; +gistlayerinsert(Relation r, BlockNumber blkno, + IndexTuple **itup, /* in - out, has compressed entry */ + int *len, /* in - out */ + InsertIndexResult *res, /* out */ + GISTSTATE *giststate) +{ + Buffer buffer; + Page page; + OffsetNumber child; + int ret; GISTPageOpaque opaque; buffer = ReadBuffer(r, blkno); page = (Page) BufferGetPage(buffer); opaque = (GISTPageOpaque) PageGetSpecialPointer(page); - if (!(opaque->flags & F_LEAF)) { + if (!(opaque->flags & F_LEAF)) + { /* internal page, so we must walk on tree */ /* len IS equial 1 */ - ItemId iid; + ItemId iid; BlockNumber nblkno; ItemPointerData oldtid; - IndexTuple oldtup; - - child = gistchoose( r, page, *(*itup), giststate ); + IndexTuple oldtup; + + child = gistchoose(r, page, *(*itup), giststate); iid = PageGetItemId(page, child); oldtup = (IndexTuple) PageGetItem(page, iid); nblkno = ItemPointerGetBlockNumber(&(oldtup->t_tid)); - /* - * After this call: - * 1. if child page was splited, then itup contains - * keys for each page - * 2. if child page wasn't splited, then itup contains - * additional for adjustement of current key + /* + * After this call: 1. if child page was splited, then itup + * contains keys for each page 2. if child page wasn't splited, + * then itup contains additional for adjustement of current key */ - ret = gistlayerinsert( r, nblkno, itup, len, res, giststate ); + ret = gistlayerinsert(r, nblkno, itup, len, res, giststate); /* nothing inserted in child */ - if ( ! (ret & INSERTED) ) { + if (!(ret & INSERTED)) + { ReleaseBuffer(buffer); - return 0x00; + return 0x00; } - /* child does not splited */ - if ( ! (ret & SPLITED) ) { - IndexTuple newtup = gistgetadjusted( r, oldtup, (*itup)[0], giststate ); - if ( ! newtup ) { + /* child does not splited */ + if (!(ret & SPLITED)) + { + IndexTuple newtup = gistgetadjusted(r, oldtup, (*itup)[0], giststate); + + if (!newtup) + { /* not need to update key */ ReleaseBuffer(buffer); return 0x00; } - pfree( (*itup)[0] ); /* !!! */ + pfree((*itup)[0]); /* !!! */ (*itup)[0] = newtup; } - /* key is modified, so old version must be deleted */ + /* key is modified, so old version must be deleted */ ItemPointerSet(&oldtid, blkno, child); DirectFunctionCall2(gistdelete, - PointerGetDatum(r), - PointerGetDatum(&oldtid)); + PointerGetDatum(r), + PointerGetDatum(&oldtid)); } - ret = INSERTED; + ret = INSERTED; - if ( gistnospace(page, (*itup), *len) ) { + if (gistnospace(page, (*itup), *len)) + { /* no space for insertion */ IndexTuple *itvec; - int tlen; + int tlen; ret |= SPLITED; - itvec = gistreadbuffer( r, buffer, &tlen ); - itvec = gistjoinvector( itvec, &tlen, (*itup), *len ); - pfree( (*itup) ); - (*itup) = gistSplit( r, buffer, itvec, &tlen, giststate, - (opaque->flags & F_LEAF) ? res : NULL ); /*res only for inserting in leaf*/ - ReleaseBuffer( buffer ); - pfree( itvec ); - *len = tlen; /* now tlen >= 2 */ - } else { + itvec = gistreadbuffer(r, buffer, &tlen); + itvec = gistjoinvector(itvec, &tlen, (*itup), *len); + pfree((*itup)); + (*itup) = gistSplit(r, buffer, itvec, &tlen, giststate, + (opaque->flags & F_LEAF) ? res : NULL); /* res only for + * inserting in leaf */ + ReleaseBuffer(buffer); + pfree(itvec); + *len = tlen; /* now tlen >= 2 */ + } + else + { /* enogth space */ - OffsetNumber off, l; + OffsetNumber off, + l; - off = ( PageIsEmpty(page) ) ? - FirstOffsetNumber + off = (PageIsEmpty(page)) ? + FirstOffsetNumber : - OffsetNumberNext(PageGetMaxOffsetNumber(page)); - l = gistwritebuffer( r, page, (*itup), *len, off, giststate ); + OffsetNumberNext(PageGetMaxOffsetNumber(page)); + l = gistwritebuffer(r, page, (*itup), *len, off, giststate); WriteBuffer(buffer); - /* set res if insert into leaf page, in - this case, len = 1 always */ - if ( res && (opaque->flags & F_LEAF) ) + /* + * set res if insert into leaf page, in this case, len = 1 always + */ + if (res && (opaque->flags & F_LEAF)) ItemPointerSet(&((*res)->pointerData), blkno, l); - if ( *len > 1 ) { /* previos insert ret & SPLITED != 0 */ - int i; - /* child was splited, so we must form union - * for insertion in parent */ - IndexTuple newtup = gistunion(r, (*itup), *len, giststate); - for(i=0; i<*len; i++) - pfree( (*itup)[i] ); + if (*len > 1) + { /* previos insert ret & SPLITED != 0 */ + int i; + + /* + * child was splited, so we must form union for insertion in + * parent + */ + IndexTuple newtup = gistunion(r, (*itup), *len, giststate); + + for (i = 0; i < *len; i++) + pfree((*itup)[i]); (*itup)[0] = newtup; *len = 1; } } - - return ret; -} -/* + return ret; +} + +/* * Write itup vector to page, has no control of free space */ static OffsetNumber -gistwritebuffer( Relation r, Page page, IndexTuple *itup, - int len, OffsetNumber off, GISTSTATE *giststate) { +gistwritebuffer(Relation r, Page page, IndexTuple *itup, + int len, OffsetNumber off, GISTSTATE *giststate) +{ OffsetNumber l = InvalidOffsetNumber; - int i; - GISTENTRY tmpdentry; - IndexTuple newtup; - - for(i=0; i<len; i++) { - l = gistPageAddItem(giststate, r, page, - (Item) itup[i], IndexTupleSize(itup[i]), - off, LP_USED, &tmpdentry, &newtup); - off = OffsetNumberNext( off ); + int i; + GISTENTRY tmpdentry; + IndexTuple newtup; + + for (i = 0; i < len; i++) + { + l = gistPageAddItem(giststate, r, page, + (Item) itup[i], IndexTupleSize(itup[i]), + off, LP_USED, &tmpdentry, &newtup); + off = OffsetNumberNext(off); if (tmpdentry.pred != (((char *) itup[i]) + sizeof(IndexTupleData)) && tmpdentry.pred) pfree(tmpdentry.pred); if (itup[i] != newtup) pfree(newtup); } - return l; + return l; } /* * Check space for itup vector on page */ -static int -gistnospace( Page page, IndexTuple *itvec, int len ) { - int size = 0; - int i; - for(i=0; i<len; i++) - size += IndexTupleSize( itvec[i] )+4; /* ??? */ +static int +gistnospace(Page page, IndexTuple *itvec, int len) +{ + int size = 0; + int i; - return (PageGetFreeSpace(page) < size); -} + for (i = 0; i < len; i++) + size += IndexTupleSize(itvec[i]) + 4; /* ??? */ + + return (PageGetFreeSpace(page) < size); +} /* * Read buffer into itup vector */ static IndexTuple * -gistreadbuffer( Relation r, Buffer buffer, int *len /*out*/) { - OffsetNumber i, maxoff; - IndexTuple *itvec; - Page p = (Page) BufferGetPage(buffer); +gistreadbuffer(Relation r, Buffer buffer, int *len /* out */ ) +{ + OffsetNumber i, + maxoff; + IndexTuple *itvec; + Page p = (Page) BufferGetPage(buffer); - *len=0; + *len = 0; maxoff = PageGetMaxOffsetNumber(p); - itvec = palloc( sizeof(IndexTuple) * maxoff ); - for(i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) - itvec[ (*len)++ ] = (IndexTuple) PageGetItem(p, PageGetItemId(p, i)); + itvec = palloc(sizeof(IndexTuple) * maxoff); + for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) + itvec[(*len)++] = (IndexTuple) PageGetItem(p, PageGetItemId(p, i)); return itvec; } @@ -596,9 +626,10 @@ gistreadbuffer( Relation r, Buffer buffer, int *len /*out*/) { * join two vectors into one */ static IndexTuple * -gistjoinvector( IndexTuple *itvec, int *len, IndexTuple *additvec, int addlen ) { - itvec = (IndexTuple*) repalloc( (void*)itvec, sizeof(IndexTuple) * ( (*len) + addlen ) ); - memmove( &itvec[*len], additvec, sizeof(IndexTuple) * addlen ); +gistjoinvector(IndexTuple *itvec, int *len, IndexTuple *additvec, int addlen) +{ + itvec = (IndexTuple *) repalloc((void *) itvec, sizeof(IndexTuple) * ((*len) + addlen)); + memmove(&itvec[*len], additvec, sizeof(IndexTuple) * addlen); *len += addlen; return itvec; } @@ -607,115 +638,124 @@ gistjoinvector( IndexTuple *itvec, int *len, IndexTuple *additvec, int addlen ) * return union of itup vector */ static IndexTuple -gistunion( Relation r, IndexTuple *itvec, int len, GISTSTATE *giststate ) { - bytea *evec; - char *datum; - int datumsize, i; - GISTENTRY centry; - char isnull; - IndexTuple newtup; +gistunion(Relation r, IndexTuple *itvec, int len, GISTSTATE *giststate) +{ + bytea *evec; + char *datum; + int datumsize, + i; + GISTENTRY centry; + char isnull; + IndexTuple newtup; evec = (bytea *) palloc(len * sizeof(GISTENTRY) + VARHDRSZ); VARATT_SIZEP(evec) = len * sizeof(GISTENTRY) + VARHDRSZ; - for ( i = 0 ; i< len ; i++ ) + for (i = 0; i < len; i++) gistdentryinit(giststate, &((GISTENTRY *) VARDATA(evec))[i], - (char*) itvec[i] + sizeof(IndexTupleData), - (Relation)NULL, (Page)NULL, (OffsetNumber)NULL, - IndexTupleSize((IndexTuple)itvec[i]) - sizeof(IndexTupleData), FALSE); + (char *) itvec[i] + sizeof(IndexTupleData), + (Relation) NULL, (Page) NULL, (OffsetNumber) NULL, + IndexTupleSize((IndexTuple) itvec[i]) - sizeof(IndexTupleData), FALSE); datum = (char *) DatumGetPointer(FunctionCall2(&giststate->unionFn, - PointerGetDatum(evec), - PointerGetDatum(&datumsize))); + PointerGetDatum(evec), + PointerGetDatum(&datumsize))); + + for (i = 0; i < len; i++) + if (((GISTENTRY *) VARDATA(evec))[i].pred && + ((GISTENTRY *) VARDATA(evec))[i].pred != + ((char *) (itvec[i]) + sizeof(IndexTupleData))) + pfree(((GISTENTRY *) VARDATA(evec))[i].pred); - for ( i = 0 ; i< len ; i++ ) - if ( ((GISTENTRY *) VARDATA(evec))[i].pred && - ((GISTENTRY *) VARDATA(evec))[i].pred != - ((char*)( itvec[i] )+ sizeof(IndexTupleData)) ) - pfree( ((GISTENTRY *) VARDATA(evec))[i].pred ); - - pfree( evec ); + pfree(evec); - gistcentryinit(giststate, ¢ry, datum, - (Relation)NULL, (Page)NULL, (OffsetNumber)NULL, - datumsize, FALSE); + gistcentryinit(giststate, ¢ry, datum, + (Relation) NULL, (Page) NULL, (OffsetNumber) NULL, + datumsize, FALSE); isnull = (centry.pred) ? ' ' : 'n'; - newtup = (IndexTuple) index_formtuple( r->rd_att, (Datum *) ¢ry.pred, &isnull ); + newtup = (IndexTuple) index_formtuple(r->rd_att, (Datum *) ¢ry.pred, &isnull); if (centry.pred != datum) - pfree( datum ); + pfree(datum); return newtup; -} +} /* * Forms union of oldtup and addtup, if union == oldtup then return NULL */ static IndexTuple -gistgetadjusted( Relation r, IndexTuple oldtup, IndexTuple addtup, GISTSTATE *giststate ) { - bytea *evec; - char *datum; - int datumsize; - bool result; - char isnull; - GISTENTRY centry, *ev0p, *ev1p; - IndexTuple newtup = NULL; - +gistgetadjusted(Relation r, IndexTuple oldtup, IndexTuple addtup, GISTSTATE *giststate) +{ + bytea *evec; + char *datum; + int datumsize; + bool result; + char isnull; + GISTENTRY centry, + *ev0p, + *ev1p; + IndexTuple newtup = NULL; + evec = (bytea *) palloc(2 * sizeof(GISTENTRY) + VARHDRSZ); VARATT_SIZEP(evec) = 2 * sizeof(GISTENTRY) + VARHDRSZ; gistdentryinit(giststate, &((GISTENTRY *) VARDATA(evec))[0], - (char*) oldtup + sizeof(IndexTupleData), (Relation) NULL, - (Page) NULL, (OffsetNumber) 0, - IndexTupleSize((IndexTuple)oldtup) - sizeof(IndexTupleData), FALSE); + (char *) oldtup + sizeof(IndexTupleData), (Relation) NULL, + (Page) NULL, (OffsetNumber) 0, + IndexTupleSize((IndexTuple) oldtup) - sizeof(IndexTupleData), FALSE); ev0p = &((GISTENTRY *) VARDATA(evec))[0]; gistdentryinit(giststate, &((GISTENTRY *) VARDATA(evec))[1], - (char*) addtup + sizeof(IndexTupleData), (Relation) NULL, - (Page) NULL, (OffsetNumber) 0, - IndexTupleSize((IndexTuple)addtup) - sizeof(IndexTupleData), FALSE); + (char *) addtup + sizeof(IndexTupleData), (Relation) NULL, + (Page) NULL, (OffsetNumber) 0, + IndexTupleSize((IndexTuple) addtup) - sizeof(IndexTupleData), FALSE); ev1p = &((GISTENTRY *) VARDATA(evec))[1]; datum = (char *) DatumGetPointer(FunctionCall2(&giststate->unionFn, - PointerGetDatum(evec), - PointerGetDatum(&datumsize))); + PointerGetDatum(evec), + PointerGetDatum(&datumsize))); - if ( ! ( ev0p->pred && ev1p->pred ) ) { - result = ( ev0p->pred == NULL && ev1p->pred == NULL ); - } else { + if (!(ev0p->pred && ev1p->pred)) + result = (ev0p->pred == NULL && ev1p->pred == NULL); + else + { FunctionCall3(&giststate->equalFn, - PointerGetDatum(ev0p->pred), - PointerGetDatum(datum), - PointerGetDatum(&result)); + PointerGetDatum(ev0p->pred), + PointerGetDatum(datum), + PointerGetDatum(&result)); } - if ( result ) { + if (result) + { /* not need to update key */ - pfree( datum ); - } else { + pfree(datum); + } + else + { gistcentryinit(giststate, ¢ry, datum, ev0p->rel, ev0p->page, - ev0p->offset, datumsize, FALSE); + ev0p->offset, datumsize, FALSE); isnull = (centry.pred) ? ' ' : 'n'; - newtup = (IndexTuple) index_formtuple( r->rd_att, (Datum *) ¢ry.pred, &isnull ); - newtup->t_tid = oldtup->t_tid; + newtup = (IndexTuple) index_formtuple(r->rd_att, (Datum *) ¢ry.pred, &isnull); + newtup->t_tid = oldtup->t_tid; if (centry.pred != datum) - pfree( datum ); + pfree(datum); } - if ( ev0p->pred && - ev0p->pred != (char*) oldtup + sizeof(IndexTupleData) ) - pfree( ev0p->pred ); - if ( ev1p->pred && - ev1p->pred != (char*) addtup + sizeof(IndexTupleData) ) - pfree( ev1p->pred ); - pfree( evec ); + if (ev0p->pred && + ev0p->pred != (char *) oldtup + sizeof(IndexTupleData)) + pfree(ev0p->pred); + if (ev1p->pred && + ev1p->pred != (char *) addtup + sizeof(IndexTupleData)) + pfree(ev1p->pred); + pfree(evec); - return newtup; + return newtup; } - + /* * gistSplit -- split a page in the tree. */ @@ -728,19 +768,27 @@ gistSplit(Relation r, InsertIndexResult *res) { Page p; - Buffer leftbuf, rightbuf; - Page left, right; - OffsetNumber *spl_left, *spl_right; - IndexTuple *lvectup, *rvectup, *newtup; - int leftoff, rightoff; - BlockNumber lbknum, rbknum; + Buffer leftbuf, + rightbuf; + Page left, + right; + OffsetNumber *spl_left, + *spl_right; + IndexTuple *lvectup, + *rvectup, + *newtup; + int leftoff, + rightoff; + BlockNumber lbknum, + rbknum; GISTPageOpaque opaque; - char isnull; + char isnull; GIST_SPLITVEC v; bytea *entryvec; bool *decompvec; GISTENTRY tmpentry; - int i, nlen; + int i, + nlen; p = (Page) BufferGetPage(buffer); opaque = (GISTPageOpaque) PageGetSpecialPointer(p); @@ -773,17 +821,17 @@ gistSplit(Relation r, right = (Page) BufferGetPage(rightbuf); /* generate the item array */ - entryvec = (bytea *) palloc(VARHDRSZ + (*len+1) * sizeof(GISTENTRY)); - decompvec = (bool *) palloc(VARHDRSZ + (*len+1) * sizeof(bool)); - VARATT_SIZEP(entryvec) = (*len+1) * sizeof(GISTENTRY) + VARHDRSZ; + entryvec = (bytea *) palloc(VARHDRSZ + (*len + 1) * sizeof(GISTENTRY)); + decompvec = (bool *) palloc(VARHDRSZ + (*len + 1) * sizeof(bool)); + VARATT_SIZEP(entryvec) = (*len + 1) * sizeof(GISTENTRY) + VARHDRSZ; for (i = 1; i <= *len; i++) { gistdentryinit(giststate, &((GISTENTRY *) VARDATA(entryvec))[i], - (((char *) itup[i-1]) + sizeof(IndexTupleData)), + (((char *) itup[i - 1]) + sizeof(IndexTupleData)), r, p, i, - IndexTupleSize(itup[i-1]) - sizeof(IndexTupleData), FALSE); + IndexTupleSize(itup[i - 1]) - sizeof(IndexTupleData), FALSE); if ((char *) (((GISTENTRY *) VARDATA(entryvec))[i].pred) - == (((char *) itup[i-1]) + sizeof(IndexTupleData))) + == (((char *) itup[i - 1]) + sizeof(IndexTupleData))) decompvec[i] = FALSE; else decompvec[i] = TRUE; @@ -791,8 +839,8 @@ gistSplit(Relation r, /* now let the user-defined picksplit function set up the split vector */ FunctionCall2(&giststate->picksplitFn, - PointerGetDatum(entryvec), - PointerGetDatum(&v)); + PointerGetDatum(entryvec), + PointerGetDatum(&v)); /* clean up the entry vector: its preds need to be deleted, too */ for (i = 1; i <= *len; i++) @@ -801,35 +849,43 @@ gistSplit(Relation r, pfree(entryvec); pfree(decompvec); - spl_left = v.spl_left; spl_right = v.spl_right; - + spl_left = v.spl_left; + spl_right = v.spl_right; + /* form left and right vector */ - lvectup = (IndexTuple*) palloc( sizeof( IndexTuple )*v.spl_nleft ); - rvectup = (IndexTuple*) palloc( sizeof( IndexTuple )*v.spl_nright ); + lvectup = (IndexTuple *) palloc(sizeof(IndexTuple) * v.spl_nleft); + rvectup = (IndexTuple *) palloc(sizeof(IndexTuple) * v.spl_nright); leftoff = rightoff = 0; - for( i=1; i <= *len; i++ ) { - if (i == *(spl_left) || ( i==*len && *(spl_left) != FirstOffsetNumber ) ) { - lvectup[ leftoff++ ] = itup[ i-1 ]; + for (i = 1; i <= *len; i++) + { + if (i == *(spl_left) || (i == *len && *(spl_left) != FirstOffsetNumber)) + { + lvectup[leftoff++] = itup[i - 1]; spl_left++; - } else { - rvectup[ rightoff++ ] = itup[ i-1 ]; + } + else + { + rvectup[rightoff++] = itup[i - 1]; spl_right++; } } /* write on disk (may be need another split) */ - if ( gistnospace(right, rvectup, v.spl_nright) ) { + if (gistnospace(right, rvectup, v.spl_nright)) + { nlen = v.spl_nright; - newtup = gistSplit(r, rightbuf, rvectup, &nlen, giststate, - ( res && rvectup[ nlen-1 ] == itup[ *len - 1 ] ) ? res : NULL ); - ReleaseBuffer( rightbuf ); - } else { + newtup = gistSplit(r, rightbuf, rvectup, &nlen, giststate, + (res && rvectup[nlen - 1] == itup[*len - 1]) ? res : NULL); + ReleaseBuffer(rightbuf); + } + else + { OffsetNumber l; - - l = gistwritebuffer( r, right, rvectup, v.spl_nright, FirstOffsetNumber, giststate ); + + l = gistwritebuffer(r, right, rvectup, v.spl_nright, FirstOffsetNumber, giststate); WriteBuffer(rightbuf); - if ( res ) + if (res) ItemPointerSet(&((*res)->pointerData), rbknum, l); gistcentryinit(giststate, &tmpentry, v.spl_rdatum, (Relation) NULL, (Page) NULL, (OffsetNumber) 0, @@ -839,32 +895,35 @@ gistSplit(Relation r, v.spl_rdatum = tmpentry.pred; nlen = 1; - newtup = (IndexTuple*) palloc( sizeof(IndexTuple) * 1); - isnull = ( v.spl_rdatum ) ? ' ' : 'n'; + newtup = (IndexTuple *) palloc(sizeof(IndexTuple) * 1); + isnull = (v.spl_rdatum) ? ' ' : 'n'; newtup[0] = (IndexTuple) index_formtuple(r->rd_att, (Datum *) &(v.spl_rdatum), &isnull); ItemPointerSet(&(newtup[0]->t_tid), rbknum, 1); } - if ( gistnospace(left, lvectup, v.spl_nleft) ) { - int llen = v.spl_nleft; + if (gistnospace(left, lvectup, v.spl_nleft)) + { + int llen = v.spl_nleft; IndexTuple *lntup; - lntup = gistSplit(r, leftbuf, lvectup, &llen, giststate, - ( res && lvectup[ llen-1 ] == itup[ *len - 1 ] ) ? res : NULL ); - ReleaseBuffer( leftbuf ); + lntup = gistSplit(r, leftbuf, lvectup, &llen, giststate, + (res && lvectup[llen - 1] == itup[*len - 1]) ? res : NULL); + ReleaseBuffer(leftbuf); - newtup = gistjoinvector( newtup, &nlen, lntup, llen ); - pfree( lntup ); - } else { + newtup = gistjoinvector(newtup, &nlen, lntup, llen); + pfree(lntup); + } + else + { OffsetNumber l; - - l = gistwritebuffer( r, left, lvectup, v.spl_nleft, FirstOffsetNumber, giststate ); - if ( BufferGetBlockNumber(buffer) != GISTP_ROOT) + + l = gistwritebuffer(r, left, lvectup, v.spl_nleft, FirstOffsetNumber, giststate); + if (BufferGetBlockNumber(buffer) != GISTP_ROOT) PageRestoreTempPage(left, p); WriteBuffer(leftbuf); - if ( res ) + if (res) ItemPointerSet(&((*res)->pointerData), lbknum, l); gistcentryinit(giststate, &tmpentry, v.spl_ldatum, (Relation) NULL, (Page) NULL, (OffsetNumber) 0, @@ -874,10 +933,10 @@ gistSplit(Relation r, v.spl_ldatum = tmpentry.pred; nlen += 1; - newtup = (IndexTuple*) repalloc( (void*)newtup, sizeof(IndexTuple) * nlen); - isnull = ( v.spl_ldatum ) ? ' ' : 'n'; - newtup[nlen-1] = (IndexTuple) index_formtuple(r->rd_att, (Datum *) &(v.spl_ldatum), &isnull); - ItemPointerSet(&(newtup[nlen-1]->t_tid), lbknum, 1); + newtup = (IndexTuple *) repalloc((void *) newtup, sizeof(IndexTuple) * nlen); + isnull = (v.spl_ldatum) ? ' ' : 'n'; + newtup[nlen - 1] = (IndexTuple) index_formtuple(r->rd_att, (Datum *) &(v.spl_ldatum), &isnull); + ItemPointerSet(&(newtup[nlen - 1]->t_tid), lbknum, 1); } @@ -885,10 +944,10 @@ gistSplit(Relation r, gistadjscans(r, GISTOP_SPLIT, BufferGetBlockNumber(buffer), FirstOffsetNumber); /* !!! pfree */ - pfree( rvectup ); - pfree( lvectup ); - pfree( v.spl_left ); - pfree( v.spl_right ); + pfree(rvectup); + pfree(lvectup); + pfree(v.spl_left); + pfree(v.spl_right); *len = nlen; return newtup; @@ -903,8 +962,8 @@ gistnewroot(GISTSTATE *giststate, Relation r, IndexTuple *itup, int len) b = ReadBuffer(r, GISTP_ROOT); GISTInitBuffer(b, 0); p = BufferGetPage(b); - - gistwritebuffer( r, p, itup, len, FirstOffsetNumber, giststate ); + + gistwritebuffer(r, p, itup, len, FirstOffsetNumber, giststate); WriteBuffer(b); } @@ -1000,8 +1059,8 @@ gistfreestack(GISTSTACK *s) Datum gistdelete(PG_FUNCTION_ARGS) { - Relation r = (Relation) PG_GETARG_POINTER(0); - ItemPointer tid = (ItemPointer) PG_GETARG_POINTER(1); + Relation r = (Relation) PG_GETARG_POINTER(0); + ItemPointer tid = (ItemPointer) PG_GETARG_POINTER(1); BlockNumber blkno; OffsetNumber offnum; Buffer buf; @@ -1101,7 +1160,7 @@ gist_tuple_replacekey(Relation r, GISTENTRY entry, IndexTuple t) char *datum = (((char *) t) + sizeof(IndexTupleData)); /* if new entry fits in index tuple, copy it in */ - if ((Size) entry.bytes < IndexTupleSize(t) - sizeof(IndexTupleData) || (Size) entry.bytes == 0 ) + if ((Size) entry.bytes < IndexTupleSize(t) - sizeof(IndexTupleData) || (Size) entry.bytes == 0) { memcpy(datum, entry.pred, entry.bytes); /* clear out old size */ @@ -1116,9 +1175,9 @@ gist_tuple_replacekey(Relation r, GISTENTRY entry, IndexTuple t) /* generate a new index tuple for the compressed entry */ TupleDesc tupDesc = r->rd_att; IndexTuple newtup; - char isnull; + char isnull; - isnull = ( entry.pred ) ? ' ' : 'n'; + isnull = (entry.pred) ? ' ' : 'n'; newtup = (IndexTuple) index_formtuple(tupDesc, (Datum *) &(entry.pred), &isnull); @@ -1181,38 +1240,40 @@ gist_dumptree(Relation r, int level, BlockNumber blk, OffsetNumber coff) Page page; GISTPageOpaque opaque; IndexTuple which; - ItemId iid; - OffsetNumber i,maxoff; - BlockNumber cblk; - char *pred; + ItemId iid; + OffsetNumber i, + maxoff; + BlockNumber cblk; + char *pred; - pred = (char*) palloc( sizeof(char)*level+1 ); + pred = (char *) palloc(sizeof(char) * level + 1); MemSet(pred, '\t', level); - pred[level]='\0'; + pred[level] = '\0'; buffer = ReadBuffer(r, blk); page = (Page) BufferGetPage(buffer); opaque = (GISTPageOpaque) PageGetSpecialPointer(page); - - maxoff = PageGetMaxOffsetNumber( page ); - - elog(NOTICE,"%sPage: %d %s blk: %d maxoff: %d free: %d", pred, coff, ( opaque->flags & F_LEAF ) ? "LEAF" : "INTE", (int)blk, (int)maxoff, PageGetFreeSpace(page)); - - for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) { + + maxoff = PageGetMaxOffsetNumber(page); + + elog(NOTICE, "%sPage: %d %s blk: %d maxoff: %d free: %d", pred, coff, (opaque->flags & F_LEAF) ? "LEAF" : "INTE", (int) blk, (int) maxoff, PageGetFreeSpace(pa |