database/postgres
database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-04-21 12:05:57 +03:00
Code

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

Browse Source 
tests pass.
This commit is contained in:
Bruce Momjian 2001-10-25 05:50:21 +00:00
parent 59da2105d8
commit b81844b173
818 changed files with 21684 additions and 20491 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
contrib/array/array_iterator.h
View File

@ -34,7 +34,6 @@ int32 array_all_int4le(ArrayType *array, int4 value);
int32 array_oideq(ArrayType *array, Oid value);
int32 array_all_oidne(ArrayType *array, Oid value);
#endif
/*

122
contrib/btree_gist/btree_gist.c
View File

@ -11,18 +11,21 @@
typedef int (*CMPFUNC) (const void *a, const void *b);
typedef void (*BINARY_UNION) (Datum *, char *);
typedef struct intkey {
typedef struct intkey
{
int4 lower;
int4 upper;
} INT4KEY;
typedef struct tskey {
typedef struct tskey
{
Timestamp lower;
Timestamp upper;
} TSKEY;
/* used for sorting */
typedef struct rix {
typedef struct rix
{
int index;
char *r;
} RIX;
@ -129,17 +132,19 @@ gint4_compress(PG_FUNCTION_ARGS)
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
GISTENTRY *retval;
if ( entry->leafkey) {
if (entry->leafkey)
{
INT4KEY *r = palloc(sizeof(INT4KEY));
retval = palloc(sizeof(GISTENTRY));
r->lower = r->upper = (entry->key);
gistentryinit(*retval, PointerGetDatum(r), entry->rel, entry->page,
entry->offset, sizeof(INT4KEY), FALSE);
} else {
retval = entry;
}
else
retval = entry;
PG_RETURN_POINTER(retval);
}
@ -152,7 +157,8 @@ gint4_consistent(PG_FUNCTION_ARGS)
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
bool retval;
switch(strategy) {
switch (strategy)
{
case BTLessEqualStrategyNumber:
retval = (query >= kkk->lower);
break;
@ -188,8 +194,10 @@ Datum
gint4_union(PG_FUNCTION_ARGS)
{
bytea *entryvec = (bytea *) PG_GETARG_POINTER(0);
int i, numranges;
INT4KEY *cur, *out=palloc(sizeof(INT4KEY));
int i,
numranges;
INT4KEY *cur,
*out = palloc(sizeof(INT4KEY));
numranges = (VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY);
*(int *) PG_GETARG_POINTER(1) = sizeof(INT4KEY);
@ -198,10 +206,13 @@ gint4_union(PG_FUNCTION_ARGS)
out->lower = cur->lower;
out->upper = cur->upper;
for (i = 1; i < numranges; i++) {
for (i = 1; i < numranges; i++)
{
cur = (INT4KEY *) DatumGetPointer((((GISTENTRY *) (VARDATA(entryvec)))[i].key));
if ( out->lower > cur->lower ) out->lower = cur->lower;
if ( out->upper < cur->upper ) out->upper = cur->upper;
if (out->lower > cur->lower)
out->lower = cur->lower;
if (out->upper < cur->upper)
out->upper = cur->upper;
}
PG_RETURN_POINTER(out);
@ -247,12 +258,16 @@ gint4_binary_union(Datum *r1, char *r2)
{
INT4KEY *b1;
INT4KEY *b2 = (INT4KEY *) r2;
if ( ! DatumGetPointer( *r1 ) ) {
if (!DatumGetPointer(*r1))
{
*r1 = PointerGetDatum(palloc(sizeof(INT4KEY)));
b1 = (INT4KEY *) DatumGetPointer(*r1);
b1->upper = b2->upper;
b1->lower = b2->lower;
} else {
}
else
{
b1 = (INT4KEY *) DatumGetPointer(*r1);
b1->lower = (b1->lower > b2->lower) ?
@ -264,7 +279,8 @@ gint4_binary_union(Datum *r1, char *r2)
static int
int4key_cmp(const void *a, const void *b) {
int4key_cmp(const void *a, const void *b)
{
return (((INT4KEY *) (((RIX *) a)->r))->lower - ((INT4KEY *) (((RIX *) b)->r))->lower);
}
@ -278,24 +294,29 @@ gts_compress(PG_FUNCTION_ARGS)
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
GISTENTRY *retval;
if ( entry->leafkey) {
if (entry->leafkey)
{
TSKEY *r = (TSKEY *) palloc(sizeof(TSKEY));
retval = palloc(sizeof(GISTENTRY));
if ( entry->key ) {
if (entry->key)
{
r->lower = r->upper = *(Timestamp *) (entry->key);
gistentryinit(*retval, PointerGetDatum(r),
entry->rel, entry->page,
entry->offset, sizeof(TSKEY), FALSE);
} else {
}
else
{
gistentryinit(*retval, PointerGetDatum(NULL),
entry->rel, entry->page,
entry->offset, 0, FALSE);
}
} else {
retval = entry;
}
else
retval = entry;
PG_RETURN_POINTER(retval);
}
@ -307,15 +328,17 @@ gts_consistent(PG_FUNCTION_ARGS)
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
bool retval;
TSKEY *key;
/*
** if entry is not leaf, use gbox_internal_consistent,
** else use gbox_leaf_consistent
* * if entry is not leaf, use gbox_internal_consistent, * else use
* gbox_leaf_consistent
*/
if (!entry->key)
return FALSE;
key = (TSKEY *) DatumGetPointer(entry->key);
switch(strategy) {
switch (strategy)
{
case BTLessEqualStrategyNumber:
retval = TSGE(query, &(key->lower));
break;
@ -351,8 +374,10 @@ Datum
gts_union(PG_FUNCTION_ARGS)
{
bytea *entryvec = (bytea *) PG_GETARG_POINTER(0);
int i, numranges;
TSKEY *cur, *out=palloc(sizeof(TSKEY));
int i,
numranges;
TSKEY *cur,
*out = palloc(sizeof(TSKEY));
numranges = (VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY);
*(int *) PG_GETARG_POINTER(1) = sizeof(TSKEY);
@ -361,10 +386,13 @@ gts_union(PG_FUNCTION_ARGS)
out->lower = cur->lower;
out->upper = cur->upper;
for (i = 1; i < numranges; i++) {
for (i = 1; i < numranges; i++)
{
cur = (TSKEY *) DatumGetPointer((((GISTENTRY *) (VARDATA(entryvec)))[i].key));
if ( TSGT( &out->lower, &cur->lower ) ) out->lower = cur->lower;
if ( TSLT( &out->upper, &cur->upper ) ) out->upper = cur->upper;
if (TSGT(&out->lower, &cur->lower))
out->lower = cur->lower;
if (TSLT(&out->upper, &cur->upper))
out->upper = cur->upper;
}
PG_RETURN_POINTER(out);
@ -417,6 +445,7 @@ gts_same(PG_FUNCTION_ARGS)
TSKEY *b2 = (TSKEY *) PG_GETARG_POINTER(1);
bool *result = (bool *) PG_GETARG_POINTER(2);
if (b1 && b2)
*result = (TSEQ(&(b1->lower), &(b2->lower)) && TSEQ(&(b1->upper), &(b2->upper))) ? TRUE : FALSE;
else
@ -430,12 +459,15 @@ gts_binary_union(Datum *r1, char *r2)
TSKEY *b1;
TSKEY *b2 = (TSKEY *) r2;
if ( ! DatumGetPointer( *r1 ) ) {
if (!DatumGetPointer(*r1))
{
*r1 = PointerGetDatum(palloc(sizeof(TSKEY)));
b1 = (TSKEY *) DatumGetPointer(*r1);
b1->upper = b2->upper;
b1->lower = b2->lower;
} else {
}
else
{
b1 = (TSKEY *) DatumGetPointer(*r1);
b1->lower = (TSGT(&b1->lower, &b2->lower)) ?
@ -446,7 +478,8 @@ gts_binary_union(Datum *r1, char *r2)
}
static int
tskey_cmp(const void *a, const void *b) {
tskey_cmp(const void *a, const void *b)
{
return DatumGetInt32(
DirectFunctionCall2(
timestamp_cmp,
@ -482,19 +515,24 @@ btree_picksplit(bytea *entryvec, GIST_SPLITVEC *v, BINARY_UNION bu, CMPFUNC cmp)
array = (RIX *) palloc(sizeof(RIX) * (maxoff + 1));
/* copy the data into RIXes, and sort the RIXes */
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) {
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
{
array[i].index = i;
array[i].r = (char *) DatumGetPointer((((GISTENTRY *) (VARDATA(entryvec)))[i].key));
}
qsort((void *) &array[FirstOffsetNumber], maxoff - FirstOffsetNumber + 1,
sizeof(RIX), cmp);
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) {
if (i <= (maxoff - FirstOffsetNumber + 1)/2) {
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
{
if (i <= (maxoff - FirstOffsetNumber + 1) / 2)
{
v->spl_left[v->spl_nleft] = array[i].index;
v->spl_nleft++;
(*bu) (&v->spl_ldatum, array[i].r);
} else {
}
else
{
v->spl_right[v->spl_nright] = array[i].index;
v->spl_nright++;
(*bu) (&v->spl_rdatum, array[i].r);
@ -520,7 +558,8 @@ btree_decompress(PG_FUNCTION_ARGS)
* In/Out for keys, not really needed
**************************************************/
Datum
int4key_in(PG_FUNCTION_ARGS) {
int4key_in(PG_FUNCTION_ARGS)
{
INT4KEY *key = palloc(sizeof(INT4KEY));
if (sscanf(PG_GETARG_POINTER(0), "%d|%d", &(key->lower), &(key->upper)) != 2)
@ -529,21 +568,26 @@ int4key_in(PG_FUNCTION_ARGS) {
PG_RETURN_POINTER(key);
}
Datum int4key_out(PG_FUNCTION_ARGS) {
Datum
int4key_out(PG_FUNCTION_ARGS)
{
INT4KEY *key = (INT4KEY *) PG_GETARG_POINTER(0);
char *str = palloc(sizeof(char) * 22);
sprintf(str, "%d|%d", key->lower, key->upper);
PG_RETURN_POINTER(str);
}
Datum
tskey_in(PG_FUNCTION_ARGS) {
tskey_in(PG_FUNCTION_ARGS)
{
elog(ERROR, "Not implemented");
PG_RETURN_POINTER(NULL);
}
Datum
tskey_out(PG_FUNCTION_ARGS) {
tskey_out(PG_FUNCTION_ARGS)
{
elog(ERROR, "Not implemented");
PG_RETURN_POINTER(NULL);
}

12
contrib/chkpass/chkpass.c
View File

@ -4,7 +4,7 @@
* darcy@druid.net
* http://www.druid.net/darcy/
*
* $Id: chkpass.c,v 1.4 2001/05/30 02:11:46 darcy Exp $
* $Id: chkpass.c,v 1.5 2001/10/25 05:49:19 momjian Exp $
* best viewed with tabs set to 4
*/
@ -166,7 +166,8 @@ chkpass_eq(PG_FUNCTION_ARGS)
if (!a1 || !a2)
PG_RETURN_BOOL(0);
if (a2->vl_len < 12) sz = a2->vl_len - 4;
if (a2->vl_len < 12)
sz = a2->vl_len - 4;
strncpy(str, a2->vl_dat, sz);
str[sz] = 0;
PG_RETURN_BOOL(strcmp(a1->password, crypt(str, a1->password)) == 0);
@ -181,10 +182,11 @@ chkpass_ne(PG_FUNCTION_ARGS)
char str[10];
int sz = 8;
if (!a1 || !a2) PG_RETURN_BOOL(0);
if (a2->vl_len < 12) sz = a2->vl_len - 4;
if (!a1 || !a2)
PG_RETURN_BOOL(0);
if (a2->vl_len < 12)
sz = a2->vl_len - 4;
strncpy(str, a2->vl_dat, sz);
str[sz] = 0;
PG_RETURN_BOOL(strcmp(a1->password, crypt(str, a1->password)) != 0);
}

3
contrib/cube/cube.c
View File

@ -166,7 +166,6 @@ g_cube_consistent(GISTENTRY *entry,
NDBOX * query,
StrategyNumber strategy)
{
/*
* if entry is not leaf, use g_cube_internal_consistent, else use
* g_cube_leaf_consistent
@ -365,7 +364,6 @@ g_cube_picksplit(bytea *entryvec,
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
@ -1001,7 +999,6 @@ cube_contains(NDBOX * box_a, NDBOX * box_b)
if (a->dim < b->dim)
{
/*
* the further comparisons will make sense if the excess
* dimensions of (b) were zeroes

243
contrib/dbase/dbf.c
View File

@ -21,7 +21,9 @@
/* open a dbf-file, get it's field-info and store this information */
dbhead *dbf_open(u_char *file, int flags) {
dbhead *
dbf_open(u_char *file, int flags)
{
int file_no;
dbhead *dbh;
f_descr *fields;
@ -29,22 +31,24 @@ dbhead *dbf_open(u_char *file, int flags) {
dbf_field *fieldc;
int t;
if ((dbh = (dbhead *)malloc(sizeof(dbhead))) == NULL) {
if ((dbh = (dbhead *) malloc(sizeof(dbhead))) == NULL)
return (dbhead *) DBF_ERROR;
}
if ((head = (dbf_header *)malloc(sizeof(dbf_header))) == NULL) {
if ((head = (dbf_header *) malloc(sizeof(dbf_header))) == NULL)
{
free(dbh);
return (dbhead *) DBF_ERROR;
}
if ((fieldc = (dbf_field *)malloc(sizeof(dbf_field))) == NULL) {
if ((fieldc = (dbf_field *) malloc(sizeof(dbf_field))) == NULL)
{
free(head);
free(dbh);
return (dbhead *) DBF_ERROR;
}
if ((file_no = open(file, flags)) == -1) {
if ((file_no = open(file, flags)) == -1)
{
free(fieldc);
free(head);
free(dbh);
@ -53,7 +57,8 @@ dbhead *dbf_open(u_char *file, int flags) {
/* read in the disk-header */
if (read(file_no, head, sizeof(dbf_header)) == -1) {
if (read(file_no, head, sizeof(dbf_header)) == -1)
{
close(file_no);
free(fieldc);
free(head);
@ -61,7 +66,8 @@ dbhead *dbf_open(u_char *file, int flags) {
return (dbhead *) DBF_ERROR;
}
if (!(head->dbh_dbt & DBH_NORMAL)) {
if (!(head->dbh_dbt & DBH_NORMAL))
{
close(file_no);
free(fieldc);
free(head);
@ -70,11 +76,10 @@ dbhead *dbf_open(u_char *file, int flags) {
}
dbh->db_fd = file_no;
if (head->dbh_dbt & DBH_MEMO) {
if (head->dbh_dbt & DBH_MEMO)
dbh->db_memo = 1;
} else {
else
dbh->db_memo = 0;
}
dbh->db_year = head->dbh_year;
dbh->db_month = head->dbh_month;
dbh->db_day = head->dbh_day;
@ -84,15 +89,16 @@ dbhead *dbf_open(u_char *file, int flags) {
dbh->db_rlen = get_short((u_char *) &head->dbh_rlen);
dbh->db_nfields = (dbh->db_hlen - sizeof(dbf_header)) / sizeof(dbf_field);
/* dbh->db_hlen - sizeof(dbf_header) isn't the
correct size, cos dbh->hlen is in fact
a little more cos of the 0x0D (and
possibly another byte, 0x4E, I have
seen this somewhere). Because of rounding
everything turns out right :) */
/*
* dbh->db_hlen - sizeof(dbf_header) isn't the correct size, cos
* dbh->hlen is in fact a little more cos of the 0x0D (and possibly
* another byte, 0x4E, I have seen this somewhere). Because of
* rounding everything turns out right :)
*/
if ((fields = (f_descr *) calloc(dbh->db_nfields, sizeof(f_descr)))
== NULL) {
== NULL)
{
close(file_no);
free(fieldc);
free(head);
@ -100,11 +106,13 @@ dbhead *dbf_open(u_char *file, int flags) {
return (dbhead *) DBF_ERROR;
}
for (t = 0; t < dbh->db_nfields; t++) {
for (t = 0; t < dbh->db_nfields; t++)
{
/* Maybe I have calculated the number of fields incorrectly. This can happen
when programs reserve lots of space at the end of the header for future
expansion. This will catch this situation */
if (fields[t].db_name[0] == 0x0D) {
if (fields[t].db_name[0] == 0x0D)
{
dbh->db_nfields = t;
break;
}
@ -118,9 +126,8 @@ dbhead *dbf_open(u_char *file, int flags) {
dbh->db_offset = dbh->db_hlen;
dbh->db_fields = fields;
if ((dbh->db_buff = (u_char *)malloc(dbh->db_rlen)) == NULL) {
if ((dbh->db_buff = (u_char *) malloc(dbh->db_rlen)) == NULL)
return (dbhead *) DBF_ERROR;
}
free(fieldc);
free(head);
@ -128,14 +135,15 @@ dbhead *dbf_open(u_char *file, int flags) {
return dbh;
}
int dbf_write_head(dbhead *dbh) {
int
dbf_write_head(dbhead * dbh)
{
dbf_header head;
time_t now;
struct tm *dbf_time;
if (lseek(dbh->db_fd, 0, SEEK_SET) == -1) {
if (lseek(dbh->db_fd, 0, SEEK_SET) == -1)
return DBF_ERROR;
}
/* fill up the diskheader */
@ -143,12 +151,14 @@ int dbf_write_head(dbhead *dbh) {
memset(&head, '\0', sizeof(dbf_header));
head.dbh_dbt = DBH_NORMAL;
if (dbh->db_memo) head.dbh_dbt = DBH_MEMO;
if (dbh->db_memo)
head.dbh_dbt = DBH_MEMO;
now = time((time_t *) NULL);
dbf_time = localtime(&now);
head.dbh_year = dbf_time->tm_year;
head.dbh_month = dbf_time->tm_mon + 1; /* Months since January + 1 */
head.dbh_month = dbf_time->tm_mon + 1; /* Months since January +
* 1 */
head.dbh_day = dbf_time->tm_mday;
put_long(head.dbh_records, dbh->db_records);
@ -161,19 +171,21 @@ int dbf_write_head(dbhead *dbh) {
return 0;
}
int dbf_put_fields(dbhead *dbh) {
int
dbf_put_fields(dbhead * dbh)
{
dbf_field field;
u_long t;
u_char end = 0x0D;
if (lseek(dbh->db_fd, sizeof(dbf_header), SEEK_SET) == -1) {
if (lseek(dbh->db_fd, sizeof(dbf_header), SEEK_SET) == -1)
return DBF_ERROR;
}
/* Set dataarea of field to '\0' */
memset(&field, '\0', sizeof(dbf_field));
for (t = 0; t < dbh->db_nfields; t++) {
for (t = 0; t < dbh->db_nfields; t++)
{
strncpy(field.dbf_name, dbh->db_fields[t].db_name, DBF_NAMELEN - 1);
field.dbf_type = dbh->db_fields[t].db_type;
field.dbf_flen = dbh->db_fields[t].db_flen;
@ -189,16 +201,18 @@ int dbf_put_fields(dbhead *dbh) {
return 0;
}
int dbf_add_field(dbhead *dbh, u_char *name, u_char type,
u_char length, u_char dec) {
int
dbf_add_field(dbhead * dbh, u_char *name, u_char type,
u_char length, u_char dec)
{
f_descr *ptr;
u_char *foo;
u_long size, field_no;
u_long size,
field_no;
size = (dbh->db_nfields + 1) * sizeof(f_descr);
if (!(ptr = (f_descr *) realloc(dbh->db_fields, size))) {
if (!(ptr = (f_descr *) realloc(dbh->db_fields, size)))
return DBF_ERROR;
}
dbh->db_fields = ptr;
field_no = dbh->db_nfields;
@ -211,29 +225,34 @@ u_long size, field_no;
dbh->db_hlen += sizeof(dbf_field);
dbh->db_rlen += length;
if (!(foo = (u_char *) realloc(dbh->db_buff, dbh->db_rlen))) {
if (!(foo = (u_char *) realloc(dbh->db_buff, dbh->db_rlen)))
return DBF_ERROR;
}
dbh->db_buff = foo;
return 0;
}
dbhead *dbf_open_new(u_char *name, int flags) {
dbhead *
dbf_open_new(u_char *name, int flags)
{
dbhead *dbh;
if (!(dbh = (dbhead *)malloc(sizeof(dbhead)))) {
if (!(dbh = (dbhead *) malloc(sizeof(dbhead))))
return (dbhead *) DBF_ERROR;
}
if (flags & O_CREAT) {
if ((dbh->db_fd = open(name, flags, DBF_FILE_MODE)) == -1) {
if (flags & O_CREAT)
{
if ((dbh->db_fd = open(name, flags, DBF_FILE_MODE)) == -1)
{
free(dbh);
return (dbhead *) DBF_ERROR;
}
} else {
if ((dbh->db_fd = open(name, flags)) == -1) {
}
else
{
if ((dbh->db_fd = open(name, flags)) == -1)
{
free(dbh);
return (dbhead *) DBF_ERROR;
}
@ -256,26 +275,31 @@ dbhead *dbh;
return dbh;
}
void dbf_close(dbhead *dbh) {
void
dbf_close(dbhead * dbh)
{
int t;
close(dbh->db_fd);
for (t = 0; t < dbh->db_nfields; t++) {
for (t = 0; t < dbh->db_nfields; t++)
free(&dbh->db_fields[t]);
}
if (dbh->db_buff != NULL) {
if (dbh->db_buff != NULL)
free(dbh->db_buff);
}
free(dbh);
}
int dbf_get_record(dbhead *dbh, field *fields, u_long rec) {
int
dbf_get_record(dbhead * dbh, field * fields, u_long rec)
{
u_char *data;
int t, i, offset;
u_char *dbffield, *end;
int t,
i,
offset;
u_char *dbffield,
*end;
/* calculate at which offset we have to read. *DON'T* forget the
0x0D which seperates field-descriptions from records!
@ -284,7 +308,8 @@ int dbf_get_record(dbhead *dbh, field *fields, u_long rec) {
*/
offset = dbh->db_hlen + (rec * dbh->db_rlen);
if (lseek(dbh->db_fd, offset, SEEK_SET) == -1) {
if (lseek(dbh->db_fd, offset, SEEK_SET) == -1)
{
lseek(dbh->db_fd, 0, SEEK_SET);
dbh->db_offset = 0;
return DBF_ERROR;
@ -296,30 +321,35 @@ int dbf_get_record(dbhead *dbh, field *fields, u_long rec) {
read(dbh->db_fd, data, dbh->db_rlen);
if (data[0] == DBF_DELETED) {
if (data[0] == DBF_DELETED)
return DBF_DELETED;
}
dbffield = &data[1];
for (t = 0; t < dbh->db_nfields; t++) {
for (t = 0; t < dbh->db_nfields; t++)
{
strncpy(fields[t].db_name, dbh->db_fields[t].db_name, DBF_NAMELEN);
fields[t].db_type = dbh->db_fields[t].db_type;
fields[t].db_flen = dbh->db_fields[t].db_flen;
fields[t].db_dec = dbh->db_fields[t].db_dec;
if (fields[t].db_type == 'C') {
if (fields[t].db_type == 'C')
{
end = &dbffield[fields[t].db_flen - 1];
i = fields[t].db_flen;
while (( i > 0) && ((*end < 0x21) || (*end > 0x7E))) {
while ((i > 0) && ((*end < 0x21) || (*end > 0x7E)))
{
end--;
i--;
}
strncpy(fields[t].db_contents, dbffield, i);
fields[t].db_contents[i] = '\0';
} else {
}
else
{
end = dbffield;
i = fields[t].db_flen;
while (( i > 0) && ((*end < 0x21) || (*end > 0x7E))) {
while ((i > 0) && ((*end < 0x21) || (*end > 0x7E)))
{
end++;
i--;
}
@ -335,19 +365,24 @@ int dbf_get_record(dbhead *dbh, field *fields, u_long rec) {
return DBF_VALID;
}
field *dbf_build_record(dbhead *dbh) {
field *
dbf_build_record(dbhead * dbh)
{
int t;
field *fields;
if (!(fields = (field *)calloc(dbh->db_nfields, sizeof(field)))) {
if (!(fields = (field *) calloc(dbh->db_nfields, sizeof(field))))
return (field *) DBF_ERROR;
}
for ( t = 0; t < dbh->db_nfields; t++) {
for (t = 0; t < dbh->db_nfields; t++)
{
if (!(fields[t].db_contents =
(u_char *)malloc(dbh->db_fields[t].db_flen + 1))) {
for (t = 0; t < dbh->db_nfields; t++) {
if (fields[t].db_contents != 0) {
(u_char *) malloc(dbh->db_fields[t].db_flen + 1)))
{
for (t = 0; t < dbh->db_nfields; t++)
{
if (fields[t].db_contents != 0)
{
free(fields[t].db_contents);
free(fields);
}
@ -363,21 +398,31 @@ field *dbf_build_record(dbhead *dbh) {
return fields;
}
void dbf_free_record(dbhead *dbh, field *rec) {
void
dbf_free_record(dbhead * dbh, field * rec)
{
int t;
for ( t = 0; t < dbh->db_nfields; t++) {
for (t = 0; t < dbh->db_nfields; t++)
free(rec[t].db_contents);
}
free(rec);
}
int dbf_put_record(dbhead *dbh, field *rec, u_long where) {
u_long offset, new, idx, t, h, length;
u_char *data, end = 0x1a;
int
dbf_put_record(dbhead * dbh, field * rec, u_long where)
{
u_long offset,
new,
idx,
t,
h,
length;
u_char *data,
end = 0x1a;
double fl;
u_char foo[128], format[32];
u_char foo[128],
format[32];
/* offset: offset in file for this record
new: real offset after lseek
@ -399,16 +444,17 @@ int dbf_put_record(dbhead *dbh, field *rec, u_long where) {
DO A SEEK_END WITH 0!!!!!! USE -1 !!!!!!!!!!
*/
if (where > dbh->db_records) {
if ((new = lseek(dbh->db_fd, -1, SEEK_END)) == -1) {
if (where > dbh->db_records)
{
if ((new = lseek(dbh->db_fd, -1, SEEK_END)) == -1)
return DBF_ERROR;
}
dbh->db_records++;
} else {
offset = dbh->db_hlen + (where * dbh->db_rlen);
if ((new = lseek(dbh->db_fd, offset, SEEK_SET)) == -1) {
return DBF_ERROR;
}
else
{
offset = dbh->db_hlen + (where * dbh->db_rlen);
if ((new = lseek(dbh->db_fd, offset, SEEK_SET)) == -1)
return DBF_ERROR;
}
dbh->db_offset = new;
@ -421,32 +467,36 @@ int dbf_put_record(dbhead *dbh, field *rec, u_long where) {
/* data[0] = DBF_VALID; */
idx = 1;
for (t = 0; t < dbh->db_nfields; t++) {
for (t = 0; t < dbh->db_nfields; t++)
{
/* if field is empty, don't do a thing */
if (rec[t].db_contents[0] != '\0') {
if (rec[t].db_contents[0] != '\0')
{
/* Handle text */
if (rec[t].db_type == 'C') {
if (strlen(rec[t].db_contents) > rec[t].db_flen) {
if (rec[t].db_type == 'C')
{
if (strlen(rec[t].db_contents) > rec[t].db_flen)
length = rec[t].db_flen;
} else {
else
length = strlen(rec[t].db_contents);
}
strncpy(data + idx, rec[t].db_contents, length);
} else {
}
else
{
/* Handle the rest */
/* Numeric is special, because of real numbers */
if ((rec[t].db_type == 'N') && (rec[t].db_dec != 0)) {
if ((rec[t].db_type == 'N') && (rec[t].db_dec != 0))
{
fl = atof(rec[t].db_contents);
sprintf(format, "%%.%df", rec[t].db_dec);
sprintf(foo, format, fl);
} else {
}
else
strcpy(foo, rec[t].db_contents);
}
if (strlen(foo) > rec[t].db_flen) {
if (strlen(foo) > rec[t].db_flen)
length = rec[t].db_flen;
} else {
else
length = strlen(foo);
}
h = rec[t].db_flen - length;
strncpy(data + idx + h, foo, length);
}
@ -458,7 +508,8 @@ int dbf_put_record(dbhead *dbh, field *rec, u_long where) {
return DBF_ERROR;
/* There's a 0x1A at the end of a dbf-file */
if (where == dbh->db_records) {
if (where == dbh->db_records)
{
if (write(dbh->db_fd, &end, 1) != 1)
return DBF_ERROR;
}

27
contrib/dbase/dbf.h
View File

@ -41,7 +41,8 @@
/* diskheader */
typedef struct {
typedef struct
{
u_char dbh_dbt; /* indentification field */
u_char dbh_year; /* last modification-date */
u_char dbh_month;
@ -54,19 +55,21 @@ typedef struct {
/* disk field-description */
typedef struct {
typedef struct
{
u_char dbf_name[DBF_NAMELEN]; /* field-name terminated with \0 */
u_char dbf_type; /* field-type */
u_char dbf_reserved[4]; /* some reserved stuff */
u_char dbf_flen; /* field-length */
u_char dbf_dec; /* number of decimal positions if
type is 'N' */
u_char dbf_dec; /* number of decimal positions if type is
* 'N' */
u_char dbf_stub[14]; /* stuff we don't need */
} dbf_field;
/* memory field-description */
typedef struct {
typedef struct
{
u_char db_name[DBF_NAMELEN]; /* field-name terminated with \0 */
u_char db_type; /* field-type */
u_char db_flen; /* field-length */
@ -75,7 +78,8 @@ typedef struct {
/* memory dfb-header */
typedef struct {
typedef struct
{
int db_fd; /* file-descriptor */
u_long db_offset; /* current offset in file */
u_char db_memo; /* memo-file present */
@ -83,15 +87,14 @@ typedef struct {
u_char db_month;
u_char db_day;
u_long db_hlen; /* length of the diskheader, for
calculating the offsets */
* calculating the offsets */
u_long db_records; /* number of records */
u_long db_currec; /* current record-number starting
at 0 */
u_long db_currec; /* current record-number starting at 0 */
u_short db_rlen; /* length of the record */
u_char db_nfields; /* number of fields */
u_char *db_buff; /* record-buffer to save malloc()'s */
f_descr *db_fields; /* pointer to an array of field-
descriptions */
* descriptions */
} dbhead;
/* structure that contains everything a user wants from a field, including
@ -99,7 +102,8 @@ typedef struct {
length of db_name! This is because a field doesn't have to be completely
filled */
typedef struct {
typedef struct
{
u_char db_name[DBF_NAMELEN]; /* field-name terminated with \0 */
u_char db_type; /* field-type */
u_char db_flen; /* field-length */
@ -131,5 +135,4 @@ extern long get_long(u_char *cp);
extern void put_long(u_char *cp, long lval);
extern short get_short(u_char *cp);
extern void put_short(u_char *cp, short lval);
#endif /* _DBF_H */

367
contrib/dbase/dbf2pg.c
View File

@ -22,9 +22,14 @@
#include "libpq-fe.h"
#include "dbf.h"
int verbose = 0, upper = 0, lower = 0, create = 0, fieldlow = 0;
int verbose = 0,
upper = 0,
lower = 0,
create = 0,
fieldlow = 0;
int del = 0;
unsigned int begin = 0, end = 0;
unsigned int begin = 0,
end = 0;
unsigned int t_block = 0;
#ifdef HAVE_ICONV_H
@ -51,6 +56,7 @@ void do_inserts(PGconn *, char*, dbhead*);
int check_table(PGconn *, char *);
char *Escape(char *);
#ifdef HAVE_ICONV_H
char *convert_charset(char *string);
#endif
@ -60,48 +66,63 @@ unsigned int isinteger(char *);
char *simple_prompt(const char *prompt, int maxlen, bool echo);
unsigned int isinteger(char *buff) {
unsigned int
isinteger(char *buff)
{
char *i = buff;
while (*i != '\0') {
while (*i != '\0')
{
if (i == buff)
if ((*i == '-') ||
(*i == '+')) {
i++; continue;
(*i == '+'))
{
i++;
continue;
}
if (!isdigit((int)*i)) return 0;
if (!isdigit((int) *i))
return 0;
i++;
}
return 1;
}
inline void strtoupper(char *string) {
while(*string != '\0') {
inline void
strtoupper(char *string)
{
while (*string != '\0')
{
*string = toupper(*string);
string++;
}
}
inline void strtolower(char *string) {
while(*string != '\0') {
inline void
strtolower(char *string)
{
while (*string != '\0')
{
*string = tolower(*string);
string++;
}
}
/* FIXME: should this check for overflow? */
char *Escape(char *string) {
char *foo, *bar;
char *
Escape(char *string)
{
char *foo,
*bar;
foo = escape_buff;
bar = string;
while (*bar != '\0') {
while (*bar != '\0')
{
if ((*bar == '\t') ||
(*bar == '\n') ||
(*bar == '\\')) {
(*bar == '\\'))
*foo++ = '\\';
}
*foo++ = *bar++;
}
*foo = '\0';
@ -110,16 +131,22 @@ char *Escape(char *string) {
}
#ifdef HAVE_ICONV_H
char *convert_charset(char *string) {
size_t in_size, out_size, nconv;
char *in_ptr,*out_ptr;
char *
convert_charset(char *string)
{
size_t in_size,
out_size,
nconv;
char *in_ptr,
*out_ptr;
in_size = strlen(string) + 1;
out_size = sizeof(convert_charset_buff);
in_ptr = string;
out_ptr = convert_charset_buff;
iconv(iconv_d, NULL, &in_size, &out_ptr, &out_size); /* necessary to reset state information */
iconv(iconv_d, NULL, &in_size, &out_ptr, &out_size); /* necessary to reset
* state information */
while (in_size > 0)
{
nconv = iconv(iconv_d, &in_ptr, &in_size, &out_ptr, &out_size);
@ -136,27 +163,32 @@ char *convert_charset(char *string) {
}
#endif
int check_table(PGconn *conn, char *table) {
int
check_table(PGconn *conn, char *table)
{
char *q = "select relname from pg_class where "
"relkind='r' and relname !~* '^pg'";
PGresult *res;
int i = 0;
if (!(res = PQexec(conn, q))) {
if (!(res = PQexec(conn, q)))
{
printf("%s\n", PQerrorMessage(conn));
return 0;
}
for (i = 0; i < PQntuples(res); i++) {
if (!strcmp(table, PQgetvalue(res, i, PQfnumber(res, "relname")))) {
for (i = 0; i < PQntuples(res); i++)
{
if (!strcmp(table, PQgetvalue(res, i, PQfnumber(res, "relname"))))
return 1;
}
}
return 0;
}
void usage(void){
void
usage(void)
{
printf("dbf2pg\n"
"usage: dbf2pg [-u | -l] [-h hostname] [-W] [-U username]\n"
" [-B transaction_size] [-F charset_from [-T charset_to]]\n"
@ -169,47 +201,58 @@ void usage(void){
/* Mainly for avoiding conflicts between fieldnames and SQL-reserved */
/* keywords */
void do_substitute(char *subarg, dbhead *dbh)
void
do_substitute(char *subarg, dbhead * dbh)
{
/* NOTE: subarg is modified in this function */
int i,bad;
char *p,*oldname,*newname;
if (!subarg) {
int i,
bad;
char *p,
*oldname,
*newname;
if (!subarg)
return;
}
if (verbose>1) {
if (verbose > 1)
printf("Substituting new field names\n");
}
/* use strstr instead of strtok because of possible empty tokens */
oldname = subarg;
while (oldname && strlen(oldname) && (p=strstr(oldname,"=")) ) {
while (oldname && strlen(oldname) && (p = strstr(oldname, "=")))
{
*p = '\0'; /* mark end of oldname */
newname = ++p; /* point past \0 of oldname */
if (strlen(newname)) { /* if not an empty string */
if (strlen(newname))
{ /* if not an empty string */
p = strstr(newname, ",");
if (p) {
if (p)
{
*p = '\0'; /* mark end of newname */
p++; /* point past where the comma was */
}
}
if (strlen(newname)>=DBF_NAMELEN) {
if (strlen(newname) >= DBF_NAMELEN)
{
printf("Truncating new field name %s to %d chars\n",
newname, DBF_NAMELEN - 1);
newname[DBF_NAMELEN - 1] = '\0';
}
bad = 1;
for (i=0;i<dbh->db_nfields;i++) {
if (strcmp(dbh->db_fields[i].db_name,oldname)==0) {
for (i = 0; i < dbh->db_nfields; i++)
{
if (strcmp(dbh->db_fields[i].db_name, oldname) == 0)
{
bad = 0;
strcpy(dbh->db_fields[i].db_name, newname);
if (verbose>1) {
if (verbose > 1)
{
printf("Substitute old:%s new:%s\n",
oldname, newname);
}
break;
}
}
if (bad) {
if (bad)
{
printf("Warning: old field name %s not found\n",
oldname);
}
@ -217,18 +260,21 @@ void do_substitute(char *subarg, dbhead *dbh)
}
} /* do_substitute */
void do_create(PGconn *conn, char *table, dbhead *dbh) {
void
do_create(PGconn *conn, char *table, dbhead * dbh)
{
char *query;
char t[20];
int i, length;
int i,
length;
PGresult *res;
if (verbose > 1) {
if (verbose > 1)
printf("Building CREATE-clause\n");
}
if (!(query = (char *) malloc(
(dbh->db_nfields * 40) + 29 + strlen(table)))) {
(dbh->db_nfields * 40) + 29 + strlen(table))))
{
fprintf(stderr, "Memory allocation error in function do_create\n");
PQfinish(conn);
close(dbh->db_fd);
@ -238,39 +284,41 @@ void do_create(PGconn *conn, char *table, dbhead *dbh) {
sprintf(query, "CREATE TABLE %s (", table);
length = strlen(query);
for ( i = 0; i < dbh->db_nfields; i++) {
if (!strlen(dbh->db_fields[i].db_name)) {
for (i = 0; i < dbh->db_nfields; i++)
{
if (!strlen(dbh->db_fields[i].db_name))
{
continue;
/* skip field if length of name == 0 */
}
if ((strlen(query) != length)) {
if ((strlen(query) != length))
strcat(query, ",");
}
if (fieldlow)
strtolower(dbh->db_fields[i].db_name);
strcat(query, dbh->db_fields[i].db_name);
switch(dbh->db_fields[i].db_type) {
switch (dbh->db_fields[i].db_type)
{
case 'D':
strcat(query, " date");
break;
case 'C':
if (dbh->db_fields[i].db_flen > 1) {
if (dbh->db_fields[i].db_flen > 1)
{
strcat(query, " varchar");
sprintf(t, "(%d)",
dbh->db_fields[i].db_flen);
strcat(query, t);
} else {
strcat(query, " char");
}
else
strcat(query, " char");
break;
case 'N':
if (dbh->db_fields[i].db_dec != 0) {
if (dbh->db_fields[i].db_dec != 0)
strcat(query, " real");
} else {
else
strcat(query, " int");
}
break;
case 'L':
strcat(query, " char");
@ -280,12 +328,14 @@ void do_create(PGconn *conn, char *table, dbhead *dbh) {
strcat(query, ")");
if (verbose > 1) {
if (verbose > 1)
{
printf("Sending create-clause\n");
printf("%s\n", query);
}
if ((res = PQexec(conn, query)) == NULL) {
if ((res = PQexec(conn, query)) == NULL)
{
fprintf(stderr, "Error creating table!\n");
fprintf(stderr, "Detailed report: %s\n", PQerrorMessage(conn));
close(dbh->db_fd);
@ -300,31 +350,41 @@ void do_create(PGconn *conn, char *table, dbhead *dbh) {
}
/* FIXME: can be optimized to not use strcat, but it is worth the effort? */
void do_inserts(PGconn *conn, char *table, dbhead *dbh) {
void
do_inserts(PGconn *conn, char *table, dbhead * dbh)
{
PGresult *res;
field *fields;
int i, h, result;
char *query, *foo;
int i,
h,
result;
char *query,
*foo;
char pgdate[10];
if (verbose > 1) {
if (verbose > 1)
printf("Inserting records\n");
}
h = 2; /* 2 because of terminating \n\0 */
for ( i = 0 ; i < dbh->db_nfields ; i++ ) {
for (i = 0; i < dbh->db_nfields; i++)
{
h += dbh->db_fields[i].db_flen > 2 ?
dbh->db_fields[i].db_flen :
2; /* account for possible NULL values (\N) */
h += 1; /* the delimiter */
}
/* make sure we can build the COPY query, note that we don't need to just
add this value, since the COPY query is a separate query (see below) */
if (h < 17+strlen(table)) h = 17+strlen(table);
/*
* make sure we can build the COPY query, note that we don't need to
* just add this value, since the COPY query is a separate query (see
* below)
*/
if (h < 17 + strlen(table))
h = 17 + strlen(table);
if (!(query = (char *)malloc(h))) {
if (!(query = (char *) malloc(h)))
{
PQfinish(conn);
fprintf(stderr,
"Memory allocation error in function do_inserts (query)\n");
@ -333,7 +393,8 @@ void do_inserts(PGconn *conn, char *table, dbhead *dbh) {
exit(1);
}
if ((fields = dbf_build_record(dbh)) == (field *)DBF_ERROR) {
if ((fields = dbf_build_record(dbh)) == (field *) DBF_ERROR)
{
fprintf(stderr,
"Couldn't allocate memory for record in do_insert\n");
PQfinish(conn);
@ -342,26 +403,32 @@ void do_inserts(PGconn *conn, char *table, dbhead *dbh) {
exit(1);
}
if (end == 0) /* "end" is a user option, if not specified, */
if (end == 0) /* "end" is a user option, if not
* specified, */
end = dbh->db_records; /* then all records are processed. */
if (t_block == 0) /* user not specified transaction block size */
if (t_block == 0) /* user not specified transaction block
* size */
t_block = end - begin; /* then we set it to be the full data */
for (i = begin; i < end; i++) {
for (i = begin; i < end; i++)
{
/* we need to start a new transaction and COPY statement */
if (((i-begin) % t_block) == 0) {
if (((i - begin) % t_block) == 0)
{
if (verbose > 1)
fprintf(stderr, "Transaction: START\n");
res = PQexec(conn, "BEGIN");
if (res == NULL) {
if (res == NULL)
{
fprintf(stderr, "Error starting transaction!\n");
fprintf(stderr, "Detailed report: %s\n", PQerrorMessage(conn));
exit(1);
}
sprintf(query, "COPY %s FROM stdin", table);
res = PQexec(conn, query);
if (res == NULL) {
if (res == NULL)
{
fprintf(stderr, "Error starting COPY!\n");
fprintf(stderr, "Detailed report: %s\n", PQerrorMessage(conn));
exit(1);
@ -370,22 +437,22 @@ void do_inserts(PGconn *conn, char *table, dbhead *dbh) {
/* build line and submit */
result = dbf_get_record(dbh, fields, i);
if (result == DBF_VALID) {
if (result == DBF_VALID)
{
query[0] = '\0';
for (h = 0; h < dbh->db_nfields; h++) {
if (!strlen(fields[h].db_name)) {
for (h = 0; h < dbh->db_nfields; h++)
{
if (!strlen(fields[h].db_name))
continue;
}
if (h != 0) /* not for the first field! */
strcat(query, "\t"); /* COPY statement field separator */
strcat(query, "\t"); /* COPY statement field
* separator */
if (upper) {
if (upper)
strtoupper(fields[h].db_contents);
}
if (lower) {
if (lower)
strtolower(fields[h].db_contents);
}
foo = fields[h].db_contents;
#ifdef HAVE_ICONV_H
@ -395,53 +462,67 @@ void do_inserts(PGconn *conn, char *table, dbhead *dbh) {
foo = Escape(foo);
/* handle the date first - liuk */
if(fields[h].db_type=='D') {
if((strlen(foo)==8) && isinteger(foo)) {
if (fields[h].db_type == 'D')
{
if ((strlen(foo) == 8) && isinteger(foo))
{
sprintf(pgdate, "%c%c%c%c-%c%c-%c%c",
foo[0], foo[1], foo[2], foo[3],
foo[4], foo[5], foo[6], foo[7]);
strcat(query, pgdate);
} else {
/* empty field must be inserted as NULL value in this
way */
}
else
{
/*
* empty field must be inserted as NULL value in
* this way
*/
strcat(query, "\\N");
}
}
else if ((fields[h].db_type == 'N') &&
(fields[h].db_dec == 0)){
if (isinteger(foo)) {
(fields[h].db_dec == 0))
{
if (isinteger(foo))
strcat(query, foo);
} else {
else
{
strcat(query, "\\N");
if (verbose)
fprintf(stderr, "Illegal numeric value found "
"in record %d, field \"%s\"\n",
i, fields[h].db_name);
}
} else {
}
else
{
strcat(query, foo); /* must be character */
}
}
strcat(query, "\n");
if ((verbose > 1) && (( i % 100) == 0)) {/* Only show every 100 */
if ((verbose > 1) && ((i % 100) == 0))
{ /* Only show every 100 */
printf("Inserting record %d\n", i); /* records. */
}
PQputline(conn, query);
}
/* we need to end this copy and transaction */
if (((i-begin) % t_block) == t_block-1) {
if (((i - begin) % t_block) == t_block - 1)
{
if (verbose > 1)
fprintf(stderr, "Transaction: END\n");
PQputline(conn, "\\.\n");
if (PQendcopy(conn) != 0) {
if (PQendcopy(conn) != 0)
{
fprintf(stderr, "Something went wrong while copying. Check "
"your tables!\n");
exit(1);
}
res = PQexec(conn, "END");
if (res == NULL) {
if (res == NULL)
{
fprintf(stderr, "Error committing work!\n");
fprintf(stderr, "Detailed report: %s\n", PQerrorMessage(conn));
exit(1);
@ -451,17 +532,20 @@ void do_inserts(PGconn *conn, char *table, dbhead *dbh) {
/* last row copied in, end copy and transaction */
/* remember, i is now 1 greater then when we left the loop */
if (((i-begin) % t_block) != 0) {
if (((i - begin) % t_block) != 0)
{
if (verbose > 1)
fprintf(stderr, "Transaction: END\n");
PQputline(conn, "\\.\n");
if (PQendcopy(conn) != 0) {
if (PQendcopy(conn) != 0)
{
fprintf(stderr, "Something went wrong while copying. Check "
"your tables!\n");
}
res = PQexec(conn, "END");
if (res == NULL) {
if (res == NULL)
{
fprintf(stderr, "Error committing work!\n");
fprintf(stderr, "Detailed report: %s\n", PQerrorMessage(conn));
exit(1);
@ -492,7 +576,9 @@ simple_prompt(const char *prompt, int maxlen, bool echo)
{
int length;
char *destination;
FILE *termin, *termout;
FILE *termin,
*termout;
#ifdef HAVE_TERMIOS_H
struct termios t_orig,
t;
@ -505,8 +591,8 @@ simple_prompt(const char *prompt, int maxlen, bool echo)
prompt_state = true; /* disable SIGINT */
/*
* Do not try to collapse these into one "w+" mode file.
* Doesn't work on some platforms (eg, HPUX 10.20).
* Do not try to collapse these into one "w+" mode file. Doesn't work
* on some platforms (eg, HPUX 10.20).
*/
termin = fopen("/dev/tty", "r");
termout = fopen("/dev/tty", "w");
@ -579,7 +665,8 @@ simple_prompt(const char *prompt, int maxlen, bool echo)
}
int main(int argc, char **argv)
int
main(int argc, char **argv)
{
PGconn *conn;
int i;
@ -588,10 +675,13 @@ int main(int argc, char **argv)
char *query;
dbhead *dbh;
while ((i = getopt(argc, argv, "DWflucvh:b:e:d:t:s:B:U:F:T:")) != EOF) {
switch (i) {
while ((i = getopt(argc, argv, "DWflucvh:b:e:d:t:s:B:U:F:T:")) != EOF)
{
switch (i)
{
case 'D':
if (create) {
if (create)
{
usage();
printf("Can't use -c and -D at the same time!\n");
exit(1);
@ -608,7 +698,8 @@ int main(int argc, char **argv)
verbose++;
break;
case 'c':
if (del) {
if (del)
{
usage();
printf("Can't use -c and -D at the same time!\n");
exit(1);
@ -619,7 +710,8 @@ int main(int argc, char **argv)
lower = 1;
break;
case 'u':
if (lower) {
if (lower)
{
usage();
printf("Can't use -u and -l at the same time!\n");
exit(1);
@ -663,7 +755,11 @@ int main(int argc, char **argv)
break;
case '?':
usage();
/* FIXME: Ivan thinks this is bad: printf("unknown argument: %s\n", argv[0]); */
/*
* FIXME: Ivan thinks this is bad: printf("unknown
* argument: %s\n", argv[0]);
*/
exit(1);
break;
default:
@ -674,7 +770,8 @@ int main(int argc, char **argv)
argc -= optind;
argv = &argv[optind];
if (argc != 1) {
if (argc != 1)
{
usage();
if (username)
free(username);
@ -699,11 +796,11 @@ int main(int argc, char **argv)
}
#endif
if (verbose > 1) {
if (verbose > 1)
printf("Opening dbf-file\n");
}
if ((dbh = dbf_open(argv[0], O_RDONLY)) == (dbhead *)-1) {
if ((dbh = dbf_open(argv[0], O_RDONLY)) == (dbhead *) - 1)
{
fprintf(stderr, "Couldn't open xbase-file %s\n", argv[0]);
if (username)
free(username);
@ -718,26 +815,28 @@ int main(int argc, char **argv)
for (i = 0; i < dbh->db_nfields; i++)
strtolower(dbh->db_fields[i].db_name);
if (verbose) {
if (verbose)
{
printf("dbf-file: %s, PG-dbase: %s, PG-table: %s\n", argv[0],
dbase,
table);
printf("Number of records: %ld\n", dbh->db_records);
printf("NAME:\t\tLENGTH:\t\tTYPE:\n");
printf("-------------------------------------\n");
for (i = 0; i < dbh->db_nfields ; i++) {
for (i = 0; i < dbh->db_nfields; i++)
{
printf("%-12s\t%7d\t\t%5c\n", dbh->db_fields[i].db_name,
dbh->db_fields[i].db_flen,
dbh->db_fields[i].db_type);
}
}
if (verbose > 1) {
if (verbose > 1)
printf("Making connection to PG-server\n");
}
conn = PQsetdbLogin(host, NULL, NULL, NULL, dbase, username, password);
if (PQstatus(conn) != CONNECTION_OK) {
if (PQstatus(conn) != CONNECTION_OK)
{
fprintf(stderr, "Couldn't get a connection with the ");
fprintf(stderr, "designated host!\n");
fprintf(stderr, "Detailed report: %s\n", PQerrorMessage(conn));
@ -756,8 +855,10 @@ int main(int argc, char **argv)
do_substitute(subarg, dbh);
/* create table if specified, else check if target table exists */
if (!create) {
if (!check_table(conn, table)) {
if (!create)
{
if (!check_table(conn, table))
{
printf("Table does not exist!\n");
if (username)
free(username);
@ -767,8 +868,10 @@ int main(int argc, char **argv)
iconv_close(iconv_d);
exit(1);
}
if (del) {
if (!(query = (char *)malloc(13 + strlen(table)))) {
if (del)
{
if (!(query = (char *) malloc(13 + strlen(table))))
{
printf("Memory-allocation error in main (delete)!\n");
close(dbh->db_fd);
free(dbh);
@ -781,15 +884,17 @@ int main(int argc, char **argv)
iconv_close(iconv_d);
exit(1);
}
if (verbose > 1) {
if (verbose > 1)
printf("Deleting from original table\n");
}
sprintf(query, "DELETE FROM %s", table);
PQexec(conn, query);
free(query);
}
} else {
if (!(query = (char *)malloc(12 + strlen(table)))) {
}
else
{
if (!(query = (char *) malloc(12 + strlen(table))))
{
printf("Memory-allocation error in main (drop)!\n");
close(dbh->db_fd);
free(dbh);
@ -802,9 +907,8 @@ int main(int argc, char **argv)
iconv_close(iconv_d);
exit(1);
}
if (verbose > 1) {
if (verbose > 1)
printf("Dropping original table (if one exists)\n");
}
sprintf(query, "DROP TABLE %s", table);
PQexec(conn, query);
free(query);
@ -819,9 +923,8 @@ int main(int argc, char **argv)
PQexec(conn, "SET DATESTYLE TO 'ISO';");
do_inserts(conn, table, dbh);
if (verbose > 1) {
if (verbose > 1)
printf("Closing up....\n");
}
close(dbh->db_fd);
free(dbh);

12
contrib/dbase/endian.c
View File

@ -5,7 +5,8 @@
/*
* routine to change little endian long to host long
*/
long get_long(u_char *cp)
long
get_long(u_char *cp)
{
long ret;
@ -17,7 +18,8 @@ long get_long(u_char *cp)
return ret;
}
void put_long(u_char *cp, long lval)
void
put_long(u_char *cp, long lval)
{
cp[0] = lval & 0xff;
cp[1] = (lval >> 8) & 0xff;
@ -28,7 +30,8 @@ void put_long(u_char *cp, long lval)
/*
* routine to change little endian short to host short
*/
short get_short(u_char *cp)
short
get_short(u_char *cp)
{
short ret;
@ -38,7 +41,8 @@ short get_short(u_char *cp)
return ret;
}
void put_short(u_char *cp, short sval)
void
put_short(u_char *cp, short sval)
{
cp[0] = sval & 0xff;
cp[1] = (sval >> 8) & 0xff;

69
contrib/dblink/dblink.c
View File

@ -41,18 +41,17 @@ dblink(PG_FUNCTION_ARGS)
int ntuples = 0;
ReturnSetInfo *rsi;
if (PG_ARGISNULL(0) || PG_ARGISNULL(1)) {
if (PG_ARGISNULL(0) || PG_ARGISNULL(1))
elog(ERROR, "dblink: NULL arguments are not permitted");
}
if (fcinfo->resultinfo == NULL || ! IsA(fcinfo->resultinfo, ReturnSetInfo)) {
if (fcinfo->resultinfo == NULL || !IsA(fcinfo->resultinfo, ReturnSetInfo))
elog(ERROR, "dblink: function called in context that does not accept a set result");
}
optstr = DatumGetCString(DirectFunctionCall1(textout, PointerGetDatum(PG_GETARG_TEXT_P(0))));
sqlstatement = DatumGetCString(DirectFunctionCall1(textout, PointerGetDatum(PG_GETARG_TEXT_P(1))));
if (fcinfo->flinfo->fn_extra == NULL) {
if (fcinfo->flinfo->fn_extra == NULL)
{
conn = PQconnectdb(optstr);
if (PQstatus(conn) == CONNECTION_BAD)
@ -73,13 +72,14 @@ dblink(PG_FUNCTION_ARGS)
PQclear(res);
execstatement = (char *) palloc(strlen(curstr) + strlen(sqlstatement) + 1);
if (execstatement != NULL) {
if (execstatement != NULL)
{
strcpy(execstatement, curstr);
strcat(execstatement, sqlstatement);
strcat(execstatement, "\0");
} else {
elog(ERROR, "dblink: insufficient memory" );
}
else
elog(ERROR, "dblink: insufficient memory");
res = PQexec(conn, execstatement);
if (!res || (PQresultStatus(res) != PGRES_COMMAND_OK && PQresultStatus(res) != PGRES_TUPLES_OK))
@ -88,14 +88,17 @@ dblink(PG_FUNCTION_ARGS)
PQclear(res);
PQfinish(conn);
elog(ERROR, "dblink: sql error: %s", msg);
} else {
}
else
{
/*
* got results, start fetching them
*/
PQclear(res);
res = PQexec(conn, "FETCH ALL in mycursor");
if (!res || PQresultStatus(res) != PGRES_TUPLES_OK) {
if (!res || PQresultStatus(res) != PGRES_TUPLES_OK)
{
msg = pstrdup(PQerrorMessage(conn));
PQclear(res);
PQfinish(conn);
@ -104,7 +107,8 @@ dblink(PG_FUNCTION_ARGS)
ntuples = PQntuples(res);
if (ntuples > 0) {
if (ntuples > 0)
{
results = init_dblink_results(fcinfo->flinfo->fn_mcxt);
results->tup_num = 0;
@ -132,7 +136,9 @@ dblink(PG_FUNCTION_ARGS)
PG_RETURN_POINTER(results);
} else {
}
else
{
PQclear(res);
@ -153,7 +159,9 @@ dblink(PG_FUNCTION_ARGS)
PG_RETURN_NULL();
}
}
} else {
}
else
{
/*
* check for more results
*/
@ -162,8 +170,8 @@ dblink(PG_FUNCTION_ARGS)
results->tup_num++;
ntuples = PQntuples(results->res);
if (results->tup_num < ntuples) {
if (results->tup_num < ntuples)
{
/*
* fetch them if available
*/
@ -173,8 +181,9 @@ dblink(PG_FUNCTION_ARGS)
PG_RETURN_POINTER(results);
} else {
}
else
{
/*
* or if no more, clean things up
*/
@ -211,41 +220,41 @@ dblink_tok(PG_FUNCTION_ARGS)
int nfields = 0;
int text_len = 0;
if (PG_ARGISNULL(0) || PG_ARGISNULL(1)) {
if (PG_ARGISNULL(0) || PG_ARGISNULL(1))
elog(ERROR, "dblink: NULL arguments are not permitted");
}
results = (dblink_results *) PG_GETARG_POINTER(0);
if (results == NULL) {
if (results == NULL)
elog(ERROR, "dblink: function called with invalid result pointer");
}
fldnum = PG_GETARG_INT32(1);
if (fldnum < 0) {
if (fldnum < 0)
elog(ERROR, "dblink: field number < 0 not permitted");
}
nfields = PQnfields(results->res);
if (fldnum > (nfields - 1)) {
if (fldnum > (nfields - 1))
elog(ERROR, "dblink: field number %d does not exist", fldnum);
}
if (PQgetisnull(results->res, results->tup_num, fldnum) == 1) {
if (PQgetisnull(results->res, results->tup_num, fldnum) == 1)
{
PG_RETURN_NULL();
} else {
}
else
{
text_len = PQgetlength(results->res, results->tup_num, fldnum);
result = (char *) palloc(text_len + 1);
if (result != NULL) {
if (result != NULL)
{
strcpy(result, PQgetvalue(results->res, results->tup_num, fldnum));
strcat(result, "\0");
} else {
elog(ERROR, "dblink: insufficient memory" );
}
else
elog(ERROR, "dblink: insufficient memory");
result_text = DatumGetTextP(DirectFunctionCall1(textin, CStringGetDatum(result)));

1
contrib/dblink/dblink.h
View File

@ -66,5 +66,4 @@ extern Datum dblink_tok(PG_FUNCTION_ARGS);
* Internal declarations
*/
dblink_results *init_dblink_results(MemoryContext fn_mcxt);
#endif /* DBLINK_H */

6
contrib/fulltextindex/fti.c
View File

@ -103,7 +103,6 @@ char *StopWords[] = { /* list of words to skip in indexing */
"the",
"yes"
};
#endif /* USE_STOP_WORDS */
/* stuff for caching query-plans, stolen from contrib/spi/\*.c */
@ -205,9 +204,7 @@ fti(PG_FUNCTION_ARGS)
snprintf(query, MAX_FTI_QUERY_LENGTH, "D%s", indexname);
for (i = 1; i < nargs; i++)
{
snprintf(query, MAX_FTI_QUERY_LENGTH, "%s$%s", query, args[i]);
}
plan = find_plan(query, &DeletePlans, &nDeletePlans);
if (plan->nplans <= 0)
@ -252,9 +249,7 @@ fti(PG_FUNCTION_ARGS)
snprintf(query, MAX_FTI_QUERY_LENGTH, "I%s", indexname);
for (i = 1; i < nargs; i++)
{
snprintf(query, MAX_FTI_QUERY_LENGTH, "%s$%s", query, args[i]);
}
plan = find_plan(query, &InsertPlans, &nInsertPlans);
@ -348,7 +343,6 @@ breakup(char *string, char *substring)
while (cur_pos > string) /* don't read before start of 'string' */
{
/*
* skip pieces at the end of a string that are not alfa-numeric
* (ie. 'string$%^&', last_start first points to '&', and after

267
contrib/fuzzystrmatch/fuzzystrmatch.c
View File

@ -62,11 +62,10 @@ levenshtein(PG_FUNCTION_ARGS)
int j;
/*
* Fetch the arguments.
* str_s is referred to as the "source"
* cols = length of source + 1 to allow for the initialization column
* str_t is referred to as the "target", rows = length of target + 1
* rows = length of target + 1 to allow for the initialization row
* Fetch the arguments. str_s is referred to as the "source" cols =
* length of source + 1 to allow for the initialization column str_t
* is referred to as the "target", rows = length of target + 1 rows =
* length of target + 1 to allow for the initialization row
*/
str_s = DatumGetCString(DirectFunctionCall1(textout, PointerGetDatum(PG_GETARG_TEXT_P(0))));
str_t = DatumGetCString(DirectFunctionCall1(textout, PointerGetDatum(PG_GETARG_TEXT_P(1))));
@ -75,18 +74,19 @@ levenshtein(PG_FUNCTION_ARGS)
rows = strlen(str_t) + 1;
/*
* Restrict the length of the strings being compared to something reasonable
* because we will have to perform rows * cols calcualtions. If longer strings need to be
* compared, increase MAX_LEVENSHTEIN_STRLEN to suit (but within your tolerance for
* speed and memory usage).
* Restrict the length of the strings being compared to something
* reasonable because we will have to perform rows * cols
* calcualtions. If longer strings need to be compared, increase
* MAX_LEVENSHTEIN_STRLEN to suit (but within your tolerance for speed
* and memory usage).
*/
if ((cols > MAX_LEVENSHTEIN_STRLEN + 1) || (rows > MAX_LEVENSHTEIN_STRLEN + 1))
elog(ERROR, "levenshtein: Arguments may not exceed %d characters in length", MAX_LEVENSHTEIN_STRLEN);
/*
* If either rows or cols is 0, the answer is the other value.
* This makes sense since it would take that many insertions
* the build a matching string
* If either rows or cols is 0, the answer is the other value. This
* makes sense since it would take that many insertions the build a
* matching string
*/
if (cols == 0)
@ -96,8 +96,9 @@ levenshtein(PG_FUNCTION_ARGS)
PG_RETURN_INT32(cols);
/*
* Allocate two vectors of integers. One will be used for the "upper" row,
* the other for the "lower" row. Initialize the "upper" row to 0..cols
* Allocate two vectors of integers. One will be used for the "upper"
* row, the other for the "lower" row. Initialize the "upper" row to
* 0..cols
*/
u_cells = palloc(sizeof(int) * cols);
for (i = 0; i < cols; i++)
@ -106,19 +107,20 @@ levenshtein(PG_FUNCTION_ARGS)
l_cells = palloc(sizeof(int) * cols);
/*
* Use str_s0 to "rewind" the pointer to str_s in the nested for loop below
* Use str_s0 to "rewind" the pointer to str_s in the nested for loop
* below
*/
str_s0 = str_s;
/*
* Loop throught the rows, starting at row 1. Row 0 is used for the initial
* "upper" row.
* Loop throught the rows, starting at row 1. Row 0 is used for the
* initial "upper" row.
*/
for (j = 1; j < rows; j++)
{
/*
* We'll always start with col 1,
* and initialize lower row col 0 to j
* We'll always start with col 1, and initialize lower row col 0
* to j
*/
l_cells[0] = j;
@ -130,9 +132,10 @@ levenshtein(PG_FUNCTION_ARGS)
int c3 = 0;
/*
* The "cost" value is 0 if the character at the current col position
* in the source string, matches the character at the current row position
* in the target string; cost is 1 otherwise.
* The "cost" value is 0 if the character at the current col
* position in the source string, matches the character at the
* current row position in the target string; cost is 1
* otherwise.
*/
c = ((CHAREQ(str_s, str_t)) ? 0 : 1);
@ -152,8 +155,7 @@ levenshtein(PG_FUNCTION_ARGS)
c3 = u_cells[i - 1] + c;
/*
* The lower right cell is set to the minimum
* of c1, c2, c3
* The lower right cell is set to the minimum of c1, c2, c3
*/
l_cells[i] = (c1 < c2 ? c1 : c2) < c3 ? (c1 < c2 ? c1 : c2) : c3;
@ -164,8 +166,8 @@ levenshtein(PG_FUNCTION_ARGS)
}
/*
* Lower row now becomes the upper row, and the upper row
* gets reused as the new lower row.
* Lower row now becomes the upper row, and the upper row gets
* reused as the new lower row.
*/
tmp = u_cells;
u_cells = l_cells;
@ -183,8 +185,8 @@ levenshtein(PG_FUNCTION_ARGS)
}
/*
* Because the final value (at position row, col) was swapped from
* the lower row to the upper row, that's where we'll find it.
* Because the final value (at position row, col) was swapped from the
* lower row to the upper row, that's where we'll find it.
*/
PG_RETURN_INT32(u_cells[cols - 1]);
}
@ -266,15 +268,17 @@ metaphone(PG_FUNCTION_ARGS)
/* Allows us to safely look ahead an arbitrary # of letters */
/* I probably could have just used strlen... */
char Lookahead(char * word, int how_far) {
char
Lookahead(char *word, int how_far)
{
char letter_ahead = '\0'; /* null by default */
int idx;
for (idx = 0; word[idx] != '\0' && idx < how_far; idx++);
/* Edge forward in the string... */
letter_ahead = word[idx]; /* idx will be either == to how_far or
* at the end of the string
*/
letter_ahead = word[idx]; /* idx will be either == to how_far or at
* the end of the string */
return letter_ahead;
}
@ -290,21 +294,22 @@ char Lookahead(char * word, int how_far) {
#define Isbreak(c) (!isalpha(c))
int _metaphone (
int
_metaphone(
/* IN */
char *word,
int max_phonemes,
/* OUT */
char **phoned_word
) {
)
{
int w_idx = 0; /* point in the phonization we're at. */
int p_idx = 0; /* end of the phoned phrase */
/*-- Parameter checks --*/
/*
* Shouldn't be necessary, but left these here anyway
* jec Aug 3, 2001
* Shouldn't be necessary, but left these here anyway jec Aug 3, 2001
*/
/* Negative phoneme length is meaningless */
@ -316,11 +321,14 @@ int _metaphone (
elog(ERROR, "metaphone: Input string length must be > 0");
/*-- Allocate memory for our phoned_phrase --*/
if (max_phonemes == 0) { /* Assume largest possible */
if (max_phonemes == 0)
{ /* Assume largest possible */
*phoned_word = palloc(sizeof(char) * strlen(word) +1);
if (!*phoned_word)
return META_ERROR;
} else {
}
else
{
*phoned_word = palloc(sizeof(char) * max_phonemes + 1);
if (!*phoned_word)
return META_ERROR;
@ -328,23 +336,28 @@ int _metaphone (
/*-- The first phoneme has to be processed specially. --*/
/* Find our first letter */
for( ; !isalpha(Curr_Letter); w_idx++ ) {
for (; !isalpha(Curr_Letter); w_idx++)
{
/* On the off chance we were given nothing but crap... */
if( Curr_Letter == '\0' ) {
if (Curr_Letter == '\0')
{
End_Phoned_Word
return META_SUCCESS; /* For testing */
}
}
switch (Curr_Letter) {
switch (Curr_Letter)
{
/* AE becomes E */
case 'A':
if( Next_Letter == 'E' ) {
if (Next_Letter == 'E')
{
Phonize('E');
w_idx += 2;
}
/* Remember, preserve vowels at the beginning */
else {
else
{
Phonize('A');
w_idx++;
}
@ -353,14 +366,16 @@ int _metaphone (
case 'G':
case 'K':
case 'P':
if( Next_Letter == 'N' ) {
if (Next_Letter == 'N')
{
Phonize('N');
w_idx += 2;
}
break;
/* WH becomes H,
WR becomes R
W if followed by a vowel */
/*
* WH becomes H, WR becomes R W if followed by a vowel
*/
case 'W':
if (Next_Letter == 'H' ||
Next_Letter == 'R')
@ -368,7 +383,8 @@ int _metaphone (
Phonize(Next_Letter);
w_idx += 2;
}
else if ( isvowel(Next_Letter) ) {
else if (isvowel(Next_Letter))
{
Phonize('W');
w_idx += 2;
}
@ -380,9 +396,9 @@ int _metaphone (
w_idx++;
break;
/* Vowels are kept */
/* We did A already
case 'A':
case 'a':
/*
* We did A already case 'A': case 'a':
*/
case 'E':
case 'I':
@ -401,17 +417,21 @@ int _metaphone (
/* On to the metaphoning */
for (; Curr_Letter != '\0' &&
(max_phonemes == 0 || Phone_Len < max_phonemes);
w_idx++) {
/* How many letters to skip because an eariler encoding handled
* multiple letters */
w_idx++)
{
/*
* How many letters to skip because an eariler encoding handled
* multiple letters
*/
unsigned short int skip_letter = 0;
/* THOUGHT: It would be nice if, rather than having things like...
* well, SCI. For SCI you encode the S, then have to remember
* to skip the C. So the phonome SCI invades both S and C. It would
* be better, IMHO, to skip the C from the S part of the encoding.
* Hell, I'm trying it.
/*
* THOUGHT: It would be nice if, rather than having things
* like... well, SCI. For SCI you encode the S, then have to
* remember to skip the C. So the phonome SCI invades both S and
* C. It would be better, IMHO, to skip the C from the S part of
* the encoding. Hell, I'm trying it.
*/
/* Ignore non-alphas */
@ -423,95 +443,104 @@ int _metaphone (
Curr_Letter != 'C')
continue;
switch (Curr_Letter) {
switch (Curr_Letter)
{
/* B -> B unless in MB */
case 'B':
if (Prev_Letter != 'M')
Phonize('B');
break;
/* 'sh' if -CIA- or -CH, but not SCH, except SCHW.
* (SCHW is handled in S)
* S if -CI-, -CE- or -CY-
* dropped if -SCI-, SCE-, -SCY- (handed in S)
* else K
/*
* 'sh' if -CIA- or -CH, but not SCH, except SCHW. (SCHW
* is handled in S) S if -CI-, -CE- or -CY- dropped if
* -SCI-, SCE-, -SCY- (handed in S) else K
*/
case 'C':
if( MAKESOFT(Next_Letter) ) { /* C[IEY] */
if (MAKESOFT(Next_Letter))
{ /* C[IEY] */
if (After_Next_Letter == 'A' &&
Next_Letter == 'I' ) { /* CIA */
Next_Letter == 'I')
{ /* CIA */
Phonize(SH);
}
/* SC[IEY] */
else if ( Prev_Letter == 'S' ) {
else if (Prev_Letter == 'S')
{
/* Dropped */
}
else {
else
Phonize('S');
}
}
else if ( Next_Letter == 'H' ) {
else if (Next_Letter == 'H')
{
#ifndef USE_TRADITIONAL_METAPHONE
if (After_Next_Letter == 'R' ||
Prev_Letter == 'S' ) { /* Christ, School */
Prev_Letter == 'S')
{ /* Christ, School */
Phonize('K');
}
else {
else
Phonize(SH);
}
#else
Phonize(SH);
#endif
skip_letter++;
}
else {
else
Phonize('K');
}
break;
/* J if in -DGE-, -DGI- or -DGY-
* else T
/*
* J if in -DGE-, -DGI- or -DGY- else T
*/
case 'D':
if (Next_Letter == 'G' &&
MAKESOFT(After_Next_Letter) ) {
MAKESOFT(After_Next_Letter))
{
Phonize('J');
skip_letter++;
}
else
Phonize('T');
break;
/* F if in -GH and not B--GH, D--GH, -H--GH, -H---GH
* else dropped if -GNED, -GN,
* else dropped if -DGE-, -DGI- or -DGY- (handled in D)
* else J if in -GE-, -GI, -GY and not GG
* else K
/*
* F if in -GH and not B--GH, D--GH, -H--GH, -H---GH else
* dropped if -GNED, -GN, else dropped if -DGE-, -DGI- or
* -DGY- (handled in D) else J if in -GE-, -GI, -GY and
* not GG else K
*/
case 'G':
if( Next_Letter == 'H' ) {
if (Next_Letter == 'H')
{
if (!(NOGHTOF(Look_Back_Letter(3)) ||
Look_Back_Letter(4) == 'H' ) ) {
Look_Back_Letter(4) == 'H'))
{
Phonize('F');
skip_letter++;
}
else {
else
{
/* silent */
}
}
else if( Next_Letter == 'N' ) {
else if (Next_Letter == 'N')
{
if (Isbreak(After_Next_Letter) ||
(After_Next_Letter == 'E' &&
Look_Ahead_Letter(3) == 'D' ) ) {
Look_Ahead_Letter(3) == 'D'))
{
/* dropped */
}
else
Phonize('K');
}
else if (MAKESOFT(Next_Letter) &&
Prev_Letter != 'G' ) {
Prev_Letter != 'G')
Phonize('J');
}
else {
else
Phonize('K');
}
break;
/* H if before a vowel and not after C,G,P,S,T */
case 'H':
@ -519,71 +548,73 @@ int _metaphone (
!AFFECTH(Prev_Letter))
Phonize('H');
break;
/* dropped if after C
* else K
/*
* dropped if after C else K
*/
case 'K':
if (Prev_Letter != 'C')
Phonize('K');
break;
/* F if before H
* else P
/*
* F if before H else P
*/
case 'P':
if( Next_Letter == 'H' ) {
if (Next_Letter == 'H')
Phonize('F');
}
else {
else
Phonize('P');
}
break;
/* K
/*
* K
*/
case 'Q':
Phonize('K');
break;
/* 'sh' in -SH-, -SIO- or -SIA- or -SCHW-
* else S
/*
* 'sh' in -SH-, -SIO- or -SIA- or -SCHW- else S
*/
case 'S':
if (Next_Letter == 'I' &&
(After_Next_Letter == 'O' ||
After_Next_Letter == 'A' ) ) {
After_Next_Letter == 'A'))
Phonize(SH);
}
else if ( Next_Letter == 'H' ) {
else if (Next_Letter == 'H')
{
Phonize(SH);
skip_letter++;
}
#ifndef USE_TRADITIONAL_METAPHONE
else if (Next_Letter == 'C' &&
Look_Ahead_Letter(2) == 'H' &&
Look_Ahead_Letter(3) == 'W' ) {
Look_Ahead_Letter(3) == 'W')
{
Phonize(SH);
skip_letter += 2;
}
#endif
else {
else
Phonize('S');
}
break;
/* 'sh' in -TIA- or -TIO-
* else 'th' before H
* else T
/*
* 'sh' in -TIA- or -TIO- else 'th' before H else T
*/
case 'T':
if (Next_Letter == 'I' &&
(After_Next_Letter == 'O' ||
After_Next_Letter == 'A' ) ) {
After_Next_Letter == 'A'))
Phonize(SH);
}
else if ( Next_Letter == 'H' ) {
else if (Next_Letter == 'H')
{
Phonize(TH);
skip_letter++;
}
else {
else
Phonize('T');
}
break;
/* F */
case 'V':

4
contrib/fuzzystrmatch/fuzzystrmatch.h
View File

@ -133,7 +133,8 @@ static const char *soundex_table = "01230120022455012623010202";
#define TH '0'
char Lookahead(char *word, int how_far);
int _metaphone (
int
_metaphone(
/* IN */
char *word,
int max_phonemes,
@ -168,5 +169,4 @@ char _codes[26] = {
/* These prevent GH from becoming F */
#define NOGHTOF(c) (ENCODE(c) & 16) /* BDH */
#endif /* FUZZYSTRMATCH_H */

3
contrib/lo/lo.c
View File

@ -1,7 +1,7 @@
/*
* PostgreSQL type definitions for managed LargeObjects.
*
* $Header: /cvsroot/pgsql/contrib/lo/lo.c,v 1.8 2001/03/22 03:59:09 momjian Exp $
* $Header: /cvsroot/pgsql/contrib/lo/lo.c,v 1.9 2001/10/25 05:49:19 momjian Exp $
*
*/
@ -64,7 +64,6 @@ lo_in(char *str)
}
else
{
/*
* There is no Oid passed, so create a new one
*/

1
contrib/miscutil/misc_utils.h
View File

@ -6,5 +6,4 @@ int unlisten(char *relname);
int max(int x, int y);
int min(int x, int y);
int active_listeners(text *relname);
#endif

2
contrib/pg_controldata/pg_controldata.c
View File

@ -6,7 +6,7 @@
* copyright (c) Oliver Elphick <olly@lfix.co.uk>, 2001;
* licence: BSD
*
* $Header: /cvsroot/pgsql/contrib/pg_controldata/Attic/pg_controldata.c,v 1.4 2001/09/06 10:49:29 petere Exp $
* $Header: /cvsroot/pgsql/contrib/pg_controldata/Attic/pg_controldata.c,v 1.5 2001/10/25 05:49:19 momjian Exp $
*/
#include "postgres.h"

7
contrib/pg_dumplo/lo_export.c
View File

@ -1,7 +1,7 @@
/* -------------------------------------------------------------------------
* pg_dumplo
*
* $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/lo_export.c,v 1.7 2001/03/22 06:16:06 momjian Exp $
* $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/lo_export.c,v 1.8 2001/10/25 05:49:19 momjian Exp $
*
* Karel Zak 1999-2000
* -------------------------------------------------------------------------
@ -38,8 +38,8 @@ load_lolist(LODumpMaster * pgLO)
* NOTE: System tables including pg_largeobject will be ignored.
* Otherwise we'd end up dumping all LOs, referenced or not.
*
* 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.
*/
pgLO->res = PQexec(pgLO->conn,
"SELECT c.relname, a.attname "
@ -107,7 +107,6 @@ pglo_export(LODumpMaster * pgLO)
for (ll = pgLO->lolist; ll->lo_table != NULL; ll++)
{
/*
* Query: find the LOs referenced by this column
*/

2
contrib/pg_dumplo/lo_import.c
View File

@ -1,7 +1,7 @@
/* -------------------------------------------------------------------------
* pg_dumplo
*
* $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/lo_import.c,v 1.5 2001/03/22 06:16:06 momjian Exp $
* $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/lo_import.c,v 1.6 2001/10/25 05:49:19 momjian Exp $
*
* Karel Zak 1999-2000
* -------------------------------------------------------------------------

3
contrib/pg_dumplo/main.c
View File

@ -1,7 +1,7 @@
/* -------------------------------------------------------------------------
* pg_dumplo
*
* $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/main.c,v 1.8 2001/03/22 06:16:06 momjian Exp $
* $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/main.c,v 1.9 2001/10/25 05:49:19 momjian Exp $
*
* Karel Zak 1999-2000
* -------------------------------------------------------------------------
@ -304,7 +304,6 @@ usage()
"-q run quietly\n"
"-w not dump, but show all LO in DB\n"
); /* puts() */
#endif
puts(

3
contrib/pg_dumplo/pg_dumplo.h
View File

@ -1,7 +1,7 @@
/* -------------------------------------------------------------------------
* pg_dumplo
*
* $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/pg_dumplo.h,v 1.4 2001/03/22 03:59:10 momjian Exp $
* $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/pg_dumplo.h,v 1.5 2001/10/25 05:49:19 momjian Exp $
*
* Karel Zak 1999-2000
* -------------------------------------------------------------------------
@ -78,5 +78,4 @@ 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 */

5
contrib/pg_resetxlog/pg_resetxlog.c
View File

@ -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.7 2001/10/25 00:55:48 momjian Exp $
* $Header: /cvsroot/pgsql/contrib/pg_resetxlog/Attic/pg_resetxlog.c,v 1.8 2001/10/25 05:49:19 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -147,7 +147,6 @@ ReadControlFile(void)
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
@ -412,7 +411,6 @@ CheckControlVersion0(char *buffer, int len)
(char *) malloc(_INTL_MAXLOGRECSZ));
if (record == NULL)
{
/*
* We have to guess at the checkpoint contents.
*/
@ -617,7 +615,6 @@ GuessControlValues(void)
{
#ifdef USE_LOCALE
char *localeptr;
#endif
/*

15
contrib/pgbench/pgbench.c
View File

@ -1,5 +1,5 @@
/*
* $Header: /cvsroot/pgsql/contrib/pgbench/pgbench.c,v 1.11 2001/10/24 08:07:22 ishii Exp $
* $Header: /cvsroot/pgsql/contrib/pgbench/pgbench.c,v 1.12 2001/10/25 05:49:19 momjian Exp $
*
* pgbench: a simple TPC-B like benchmark program for PostgreSQL
* written by Tatsuo Ishii
@ -39,7 +39,6 @@
/* for getrlimit */
#include <sys/resource.h>
#endif /* WIN32 */
/********************************************************************
@ -67,7 +66,8 @@ int tps = 1;
int remains; /* number of remained clients */
int is_connect; /* establish connection for each transactoin */
int is_connect; /* establish connection for each
* transactoin */
char *pghost = "";
char *pgport = NULL;
@ -107,7 +107,8 @@ getrand(int min, int max)
}
/* set up a connection to the backend */
static PGconn *doConnect()
static PGconn *
doConnect()
{
PGconn *con;
@ -532,8 +533,8 @@ init()
if (j % 10000 == 0)
{
/*
* every 10000 tuples, we commit the copy command.
* this should avoid generating too much WAL logs
* every 10000 tuples, we commit the copy command. this should
* avoid generating too much WAL logs
*/
fprintf(stderr, "%d tuples done.\n", j);
if (PQputline(con, "\\.\n"))
@ -547,6 +548,7 @@ init()
fprintf(stderr, "PQendcopy failed\n");
exit(1);
}
/*
* do a checkpoint to purge the old WAL logs
*/
@ -634,7 +636,6 @@ main(int argc, char **argv)
#ifndef __CYGWIN__
struct rlimit rlim;
#endif
PGconn *con;

115
contrib/pgcrypto/blf.c
View File

@ -71,14 +71,22 @@ Blowfish_encipher(blf_ctx *c, uint32 *x)
Xr = x[1];
Xl ^= p[0];
BLFRND(s, p, Xr, Xl, 1); BLFRND(s, p, Xl, Xr, 2);
BLFRND(s, p, Xr, Xl, 3); BLFRND(s, p, Xl, Xr, 4);
BLFRND(s, p, Xr, Xl, 5); BLFRND(s, p, Xl, Xr, 6);
BLFRND(s, p, Xr, Xl, 7); BLFRND(s, p, Xl, Xr, 8);
BLFRND(s, p, Xr, Xl, 9); BLFRND(s, p, Xl, Xr, 10);
BLFRND(s, p, Xr, Xl, 11); BLFRND(s, p, Xl, Xr, 12);
BLFRND(s, p, Xr, Xl, 13); BLFRND(s, p, Xl, Xr, 14);
BLFRND(s, p, Xr, Xl, 15); BLFRND(s, p, Xl, Xr, 16);
BLFRND(s, p, Xr, Xl, 1);
BLFRND(s, p, Xl, Xr, 2);
BLFRND(s, p, Xr, Xl, 3);
BLFRND(s, p, Xl, Xr, 4);
BLFRND(s, p, Xr, Xl, 5);
BLFRND(s, p, Xl, Xr, 6);
BLFRND(s, p, Xr, Xl, 7);
BLFRND(s, p, Xl, Xr, 8);
BLFRND(s, p, Xr, Xl, 9);
BLFRND(s, p, Xl, Xr, 10);
BLFRND(s, p, Xr, Xl, 11);
BLFRND(s, p, Xl, Xr, 12);
BLFRND(s, p, Xr, Xl, 13);
BLFRND(s, p, Xl, Xr, 14);
BLFRND(s, p, Xr, Xl, 15);
BLFRND(s, p, Xl, Xr, 16);
x[0] = Xr ^ p[17];
x[1] = Xl;
@ -96,14 +104,22 @@ Blowfish_decipher(blf_ctx *c, uint32 *x)
Xr = x[1];
Xl ^= p[17];
BLFRND(s, p, Xr, Xl, 16); BLFRND(s, p, Xl, Xr, 15);
BLFRND(s, p, Xr, Xl, 14); BLFRND(s, p, Xl, Xr, 13);
BLFRND(s, p, Xr, Xl, 12); BLFRND(s, p, Xl, Xr, 11);
BLFRND(s, p, Xr, Xl, 10); BLFRND(s, p, Xl, Xr, 9);
BLFRND(s, p, Xr, Xl, 8); BLFRND(s, p, Xl, Xr, 7);
BLFRND(s, p, Xr, Xl, 6); BLFRND(s, p, Xl, Xr, 5);
BLFRND(s, p, Xr, Xl, 4); BLFRND(s, p, Xl, Xr, 3);
BLFRND(s, p, Xr, Xl, 2); BLFRND(s, p, Xl, Xr, 1);
BLFRND(s, p, Xr, Xl, 16);
BLFRND(s, p, Xl, Xr, 15);
BLFRND(s, p, Xr, Xl, 14);
BLFRND(s, p, Xl, Xr, 13);
BLFRND(s, p, Xr, Xl, 12);
BLFRND(s, p, Xl, Xr, 11);
BLFRND(s, p, Xr, Xl, 10);
BLFRND(s, p, Xl, Xr, 9);
BLFRND(s, p, Xr, Xl, 8);
BLFRND(s, p, Xl, Xr, 7);
BLFRND(s, p, Xr, Xl, 6);
BLFRND(s, p, Xl, Xr, 5);
BLFRND(s, p, Xr, Xl, 4);
BLFRND(s, p, Xl, Xr, 3);
BLFRND(s, p, Xr, Xl, 2);
BLFRND(s, p, Xl, Xr, 1);
x[0] = Xr ^ p[0];
x[1] = Xl;
@ -401,7 +417,8 @@ Blowfish_stream2word(const uint8 *data, uint16 databytes, uint16 *current)
temp = 0x00000000;
j = *current;
for (i = 0; i < 4; i++, j++) {
for (i = 0; i < 4; i++, j++)
{
if (j >= databytes)
j = 0;
temp = (temp << 8) | data[j];
@ -421,7 +438,8 @@ Blowfish_expand0state(blf_ctx *c, const uint8 *key, uint16 keybytes)
uint32 data[2];
j = 0;
for (i = 0; i < BLF_N + 2; i++) {
for (i = 0; i < BLF_N + 2; i++)
{
/* Extract 4 int8 to 1 int32 from keystream */
temp = Blowfish_stream2word(key, keybytes, &j);
c->P[i] = c->P[i] ^ temp;
@ -430,15 +448,18 @@ Blowfish_expand0state(blf_ctx *c, const uint8 *key, uint16 keybytes)
j = 0;
data[0] = 0x00000000;
data[1] = 0x00000000;
for (i = 0; i < BLF_N + 2; i += 2) {
for (i = 0; i < BLF_N + 2; i += 2)
{
Blowfish_encipher(c, data);
c->P[i] = data[0];
c->P[i + 1] = data[1];
}
for (i = 0; i < 4; i++) {
for (k = 0; k < 256; k += 2) {
for (i = 0; i < 4; i++)
{
for (k = 0; k < 256; k += 2)
{
Blowfish_encipher(c, data);
c->S[i][k] = data[0];
@ -459,7 +480,8 @@ Blowfish_expandstate(blf_ctx *c, const uint8 *data, uint16 databytes,
uint32 d[2];
j = 0;
for (i = 0; i < BLF_N + 2; i++) {
for (i = 0; i < BLF_N + 2; i++)
{
/* Extract 4 int8 to 1 int32 from keystream */
temp = Blowfish_stream2word(key, keybytes, &j);
c->P[i] = c->P[i] ^ temp;
@ -468,7 +490,8 @@ Blowfish_expandstate(blf_ctx *c, const uint8 *data, uint16 databytes,
j = 0;
d[0] = 0x00000000;
d[1] = 0x00000000;
for (i = 0; i < BLF_N + 2; i += 2) {
for (i = 0; i < BLF_N + 2; i += 2)
{
d[0] ^= Blowfish_stream2word(data, databytes, &j);
d[1] ^= Blowfish_stream2word(data, databytes, &j);
Blowfish_encipher(c, d);
@ -477,8 +500,10 @@ Blowfish_expandstate(blf_ctx *c, const uint8 *data, uint16 databytes,
c->P[i + 1] = d[1];
}
for (i = 0; i < 4; i++) {
for (k = 0; k < 256; k += 2) {
for (i = 0; i < 4; i++)
{
for (k = 0; k < 256; k += 2)
{
d[0] ^= Blowfish_stream2word(data, databytes, &j);
d[1] ^= Blowfish_stream2word(data, databytes, &j);
Blowfish_encipher(c, d);
@ -507,7 +532,8 @@ blf_enc(blf_ctx *c, uint32 *data, uint16 blocks)
uint16 i;
d = data;
for (i = 0; i < blocks; i++) {
for (i = 0; i < blocks; i++)
{
Blowfish_encipher(c, d);
d += 2;
}
@ -520,7 +546,8 @@ blf_dec(blf_ctx *c, uint32 *data, uint16 blocks)
uint16 i;
d = data;
for (i = 0; i < blocks; i++) {
for (i = 0; i < blocks; i++)
{
Blowfish_decipher(c, d);
d += 2;
}
@ -529,10 +556,13 @@ blf_dec(blf_ctx *c, uint32 *data, uint16 blocks)
void
blf_ecb_encrypt(blf_ctx * c, uint8 *data, uint32 len)
{
uint32 l, r, d[2];
uint32 l,
r,
d[2];
uint32 i;
for (i = 0; i < len; i += 8) {
for (i = 0; i < len; i += 8)
{
l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
d[0] = l;
@ -555,10 +585,13 @@ blf_ecb_encrypt(blf_ctx *c, uint8 *data, uint32 len)
void
blf_ecb_decrypt(blf_ctx * c, uint8 *data, uint32 len)
{
uint32 l, r, d[2];
uint32 l,
r,
d[2];
uint32 i;
for (i = 0; i < len; i += 8) {
for (i = 0; i < len; i += 8)
{
l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
d[0] = l;
@ -581,10 +614,14 @@ blf_ecb_decrypt(blf_ctx *c, uint8 *data, uint32 len)
void
blf_cbc_encrypt(blf_ctx * c, uint8 *iv, uint8 *data, uint32 len)
{
uint32 l, r, d[2];
uint32 i, j;
uint32 l,
r,
d[2];
uint32 i,
j;
for (i = 0; i < len; i += 8) {
for (i = 0; i < len; i += 8)
{
for (j = 0; j < 8; j++)
data[j] ^= iv[j];
l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
@ -610,13 +647,17 @@ blf_cbc_encrypt(blf_ctx *c, uint8 *iv, uint8 *data, uint32 len)
void
blf_cbc_decrypt(blf_ctx * c, uint8 *iva, uint8 *data, uint32 len)
{
uint32 l, r, d[2];
uint32 l,
r,
d[2];
uint8 *iv;
uint32 i, j;
uint32 i,
j;
iv = data + len - 16;
data = data + len - 8;
for (i = len - 8; i >= 8; i -= 8) {
for (i = len - 8; i >= 8; i -= 8)
{
l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
d[0] = l;

4
contrib/pgcrypto/blf.h
View File

@ -46,7 +46,8 @@
#define BLF_MAXKEYLEN ((BLF_N-2)*4) /* 448 bits */
/* Blowfish context */
typedef struct BlowfishContext {
typedef struct BlowfishContext
{
uint32 S[4][256]; /* S-Boxes */
uint32 P[BLF_N + 2]; /* Subkeys */
} blf_ctx;
@ -78,5 +79,4 @@ void blf_ecb_decrypt (blf_ctx *, uint8 *, uint32);
void blf_cbc_encrypt(blf_ctx *, uint8 *, uint8 *, uint32);
void blf_cbc_decrypt(blf_ctx *, uint8 *, uint8 *, uint32);
#endif

103
contrib/pgcrypto/crypt-blowfish.c
View File

@ -57,7 +57,8 @@ typedef unsigned int BF_word;
typedef BF_word BF_key[BF_N + 2];
typedef struct {
typedef struct
{
BF_word S[4][0x100];
BF_key P;
} BF_ctx;
@ -367,22 +368,30 @@ do { \
(dst) = tmp; \
} while (0)
static int BF_decode(BF_word *dst, const char *src, int size)
static int
BF_decode(BF_word * dst, const char *src, int size)
{
unsigned char *dptr = (unsigned char *) dst;
unsigned char *end = dptr + size;
unsigned char *sptr = (unsigned char *) src;
unsigned int tmp, c1, c2, c3, c4;
unsigned int tmp,
c1,
c2,
c3,
c4;
do {
do
{
BF_safe_atoi64(c1, *sptr++);
BF_safe_atoi64(c2, *sptr++);
*dptr++ = (c1 << 2) | ((c2 & 0x30) >> 4);
if (dptr >= end) break;
if (dptr >= end)
break;
BF_safe_atoi64(c3, *sptr++);
*dptr++ = ((c2 & 0x0F) << 4) | ((c3 & 0x3C) >> 2);
if (dptr >= end) break;
if (dptr >= end)
break;
BF_safe_atoi64(c4, *sptr++);
*dptr++ = ((c3 & 0x03) << 6) | c4;
@ -391,18 +400,22 @@ static int BF_decode(BF_word *dst, const char *src, int size)
return 0;
}
static void BF_encode(char *dst, const BF_word *src, int size)
static void
BF_encode(char *dst, const BF_word * src, int size)
{
unsigned char *sptr = (unsigned char *) src;
unsigned char *end = sptr + size;
unsigned char *dptr = (unsigned char *) dst;
unsigned int c1, c2;
unsigned int c1,
c2;
do {
do
{
c1 = *sptr++;
*dptr++ = BF_itoa64[c1 >> 2];
c1 = (c1 & 0x03) << 4;
if (sptr >= end) {
if (sptr >= end)
{
*dptr++ = BF_itoa64[c1];
break;
}
@ -411,7 +424,8 @@ static void BF_encode(char *dst, const BF_word *src, int size)
c1 |= c2 >> 4;
*dptr++ = BF_itoa64[c1];
c1 = (c2 & 0x0f) << 2;
if (sptr >= end) {
if (sptr >= end)
{
*dptr++ = BF_itoa64[c1];
break;
}
@ -423,14 +437,16 @@ static void BF_encode(char *dst, const BF_word *src, int size)
} while (sptr < end);
}
static void BF_swap(BF_word *x, int count)
static void
BF_swap(BF_word * x, int count)
{
static int endianness_check = 1;
char *is_little_endian = (char *) &endianness_check;
BF_word tmp;
if (*is_little_endian)
do {
do
{
tmp = *x;
tmp = (tmp << 16) | (tmp >> 16);
*x++ = ((tmp & 0x00FF00FF) << 8) | ((tmp >> 8) & 0x00FF00FF);
@ -505,6 +521,7 @@ static void BF_swap(BF_word *x, int count)
#if BF_ASM
extern void _BF_body_r(BF_ctx * ctx);
#define BF_body() \
_BF_body_r(&data.ctx);
@ -527,22 +544,28 @@ extern void _BF_body_r(BF_ctx *ctx);
*(ptr - 2) = L; \
*(ptr - 1) = R; \
} while (ptr < &data.ctx.S[3][0xFF]);
#endif
static void BF_set_key(const char *key, BF_key expanded, BF_key initial)
static void
BF_set_key(const char *key, BF_key expanded, BF_key initial)
{
const char *ptr = key;
int i, j;
int i,
j;
BF_word tmp;
for (i = 0; i < BF_N + 2; i++) {
for (i = 0; i < BF_N + 2; i++)
{
tmp = 0;
for (j = 0; j < 4; j++) {
for (j = 0; j < 4; j++)
{
tmp <<= 8;
tmp |= *ptr;
if (!*ptr) ptr = key; else ptr++;
if (!*ptr)
ptr = key;
else
ptr++;
}
expanded[i] = tmp;
@ -550,24 +573,32 @@ static void BF_set_key(const char *key, BF_key expanded, BF_key initial)
}
}
char *_crypt_blowfish_rn(const char *key, const char *setting,
char *
_crypt_blowfish_rn(const char *key, const char *setting,
char *output, int size)
{
struct {
struct
{
BF_ctx ctx;
BF_key expanded_key;
union {
union
{
BF_word salt[4];
BF_word output[6];
} binary;
} data;
BF_word L, R;
BF_word tmp1, tmp2, tmp3, tmp4;
BF_word L,
R;
BF_word tmp1,
tmp2,
tmp3,
tmp4;
BF_word *ptr;
BF_word count;
int i;
if (size < 7 + 22 + 31 + 1) {
if (size < 7 + 22 + 31 + 1)
{
__set_errno(ERANGE);
return NULL;
}
@ -578,13 +609,15 @@ char *_crypt_blowfish_rn(const char *key, const char *setting,
setting[3] != '$' ||
setting[4] < '0' || setting[4] > '3' ||
setting[5] < '0' || setting[5] > '9' ||
setting[6] != '$') {
setting[6] != '$')
{
__set_errno(EINVAL);
return NULL;
}
count = (BF_word) 1 << ((setting[4] - '0') * 10 + (setting[5] - '0'));
if (count < 16 || BF_decode(data.binary.salt, &setting[7], 16)) {
if (count < 16 || BF_decode(data.binary.salt, &setting[7], 16))
{
memset(data.binary.salt, 0, sizeof(data.binary.salt));
__set_errno(EINVAL);
return NULL;
@ -596,7 +629,8 @@ char *_crypt_blowfish_rn(const char *key, const char *setting,
memcpy(data.ctx.S, BF_init_state.S, sizeof(data.ctx.S));
L = R = 0;
for (i = 0; i < BF_N + 2; i += 2) {
for (i = 0; i < BF_N + 2; i += 2)
{
L ^= data.binary.salt[i & 2];
R ^= data.binary.salt[(i & 2) + 1];
BF_ENCRYPT;
@ -605,7 +639,8 @@ char *_crypt_blowfish_rn(const char *key, const char *setting,
}
ptr = data.ctx.S[0];
do {
do
{
ptr += 4;
L ^= data.binary.salt[(BF_N + 2) & 3];
R ^= data.binary.salt[(BF_N + 3) & 3];
@ -620,7 +655,8 @@ char *_crypt_blowfish_rn(const char *key, const char *setting,
*(ptr - 1) = R;
} while (ptr < &data.ctx.S[3][0xFF]);
do {
do
{
data.ctx.P[0] ^= data.expanded_key[0];
data.ctx.P[1] ^= data.expanded_key[1];
data.ctx.P[2] ^= data.expanded_key[2];
@ -668,12 +704,14 @@ char *_crypt_blowfish_rn(const char *key, const char *setting,
BF_body();
} while (--count);
for (i = 0; i < 6; i += 2) {
for (i = 0; i < 6; i += 2)
{
L = BF_magic_w[i];
R = BF_magic_w[i + 1];
count = 64;
do {
do
{
BF_ENCRYPT;
} while (--count);
@ -698,4 +736,3 @@ char *_crypt_blowfish_rn(const char *key, const char *setting,
return output;
}

57
contrib/pgcrypto/crypt-des.c
View File

@ -244,8 +244,8 @@ des_init()
}
/*
* Convert the inverted S-boxes into 4 arrays of 8 bits.
* Each will handle 12 bits of the S-box input.
* Convert the inverted S-boxes into 4 arrays of 8 bits. Each will
* handle 12 bits of the S-box input.
*/
for (b = 0; b < 4; b++)
for (i = 0; i < 64; i++)
@ -409,10 +409,9 @@ des_setkey(const char *key)
&& rawkey1 == old_rawkey1)
{
/*
* Already setup for this key.
* This optimisation fails on a zero key (which is weak and
* has bad parity anyway) in order to simplify the starting
* conditions.
* Already setup for this key. This optimisation fails on a zero
* key (which is weak and has bad parity anyway) in order to
* simplify the starting conditions.
*/
return (0);
}
@ -438,6 +437,7 @@ des_setkey(const char *key)
| key_perm_maskr[5][(rawkey1 >> 17) & 0x7f]
| key_perm_maskr[6][(rawkey1 >> 9) & 0x7f]
| key_perm_maskr[7][(rawkey1 >> 1) & 0x7f];
/*
* Rotate subkeys and do compression permutation.
*/
@ -556,21 +556,24 @@ do_des(uint32 l_in, uint32 r_in, uint32 * l_out, uint32 * r_out, int count)
| ((r & 0x000001f8) << 3)
| ((r & 0x0000001f) << 1)
| ((r & 0x80000000) >> 31);
/*
* Do salting for crypt() and friends, and
* XOR with the permuted key.
* Do salting for crypt() and friends, and XOR with the
* permuted key.
*/
f = (r48l ^ r48r) & saltbits;
r48l ^= f ^ *kl++;
r48r ^= f ^ *kr++;
/*
* Do sbox lookups (which shrink it back to 32 bits)
* and do the pbox permutation at the same time.
* Do sbox lookups (which shrink it back to 32 bits) and do
* the pbox permutation at the same time.
*/
f = psbox[0][m_sbox[0][r48l >> 12]]
| psbox[1][m_sbox[1][r48l & 0xfff]]
| psbox[2][m_sbox[2][r48r >> 12]]
| psbox[3][m_sbox[3][r48r & 0xfff]];
/*
* Now that we've permuted things, complete f().
*/
@ -581,6 +584,7 @@ do_des(uint32 l_in, uint32 r_in, uint32 * l_out, uint32 * r_out, int count)
r = l;
l = f;
}
/*
* Do final permutation (inverse of IP).
*/
@ -654,8 +658,8 @@ px_crypt_des(const char *key, const char *setting)
/*
* Copy the key, shifting each character up by one bit
* and padding with zeros.
* Copy the key, shifting each character up by one bit and padding
* with zeros.
*/
q = (uint8 *) keybuf;
while (q - (uint8 *) keybuf - 8)
@ -670,9 +674,8 @@ px_crypt_des(const char *key, const char *setting)
if (*setting == _PASSWORD_EFMT1)
{
/*
* "new"-style:
* setting - underscore, 4 bytes of count, 4 bytes of salt
* key - unlimited characters
* "new"-style: setting - underscore, 4 bytes of count, 4 bytes of
* salt key - unlimited characters
*/
for (i = 1, count = 0L; i < 5; i++)
count |= ascii_to_bin(setting[i]) << (i - 1) * 6;
@ -687,6 +690,7 @@ px_crypt_des(const char *key, const char *setting)
*/
if (des_cipher((uint8 *) keybuf, (uint8 *) keybuf, 0L, 1))
return (NULL);
/*
* And XOR with the next 8 characters of the key.
*/
@ -700,11 +704,10 @@ px_crypt_des(const char *key, const char *setting)
strncpy(output, setting, 9);
/*
* Double check that we weren't given a short setting.
* If we were, the above code will probably have created
* wierd values for count and salt, but we don't really care.
* Just make sure the output string doesn't have an extra
* NUL in it.
* Double check that we weren't given a short setting. If we were,
* the above code will probably have created wierd values for
* count and salt, but we don't really care. Just make sure the
* output string doesn't have an extra NUL in it.
*/
output[9] = '\0';
p = output + strlen(output);
@ -713,9 +716,7 @@ px_crypt_des(const char *key, const char *setting)
#endif /* !DISABLE_XDES */
{
/*
* "old"-style:
* setting - 2 bytes of salt
* key - up to 8 characters
* "old"-style: setting - 2 bytes of salt key - up to 8 characters
*/
count = 25;
@ -723,22 +724,24 @@ px_crypt_des(const char *key, const char *setting)
| ascii_to_bin(setting[0]);
output[0] = setting[0];
/*
* If the encrypted password that the salt was extracted from
* is only 1 character long, the salt will be corrupted. We
* need to ensure that the output string doesn't have an extra
* NUL in it!
* If the encrypted password that the salt was extracted from is
* only 1 character long, the salt will be corrupted. We need to
* ensure that the output string doesn't have an extra NUL in it!
*/
output[1] = setting[1] ? setting[1] : output[0];
p = output + 2;
}
setup_salt(salt);
/*
* Do it.
*/
if (do_des(0L, 0L, &r0, &r1, count))
return (NULL);
/*
* Now encode the result...
*/

61
contrib/pgcrypto/crypt-gensalt.c
View File

@ -24,11 +24,14 @@ typedef unsigned int BF_word;
unsigned char _crypt_itoa64[64 + 1] =
"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
char *_crypt_gensalt_traditional_rn(unsigned long count,
char *
_crypt_gensalt_traditional_rn(unsigned long count,
const char *input, int size, char *output, int output_size)
{
if (size < 2 || output_size < 2 + 1 || (count && count != 25)) {
if (output_size > 0) output[0] = '\0';
if (size < 2 || output_size < 2 + 1 || (count && count != 25))
{
if (output_size > 0)
output[0] = '\0';
__set_errno((output_size < 2 + 1) ? ERANGE : EINVAL);
return NULL;
}
@ -40,7 +43,8 @@ char *_crypt_gensalt_traditional_rn(unsigned long count,
return output;
}
char *_crypt_gensalt_extended_rn(unsigned long count,
char *
_crypt_gensalt_extended_rn(unsigned long count,
const char *input, int size, char *output, int output_size)
{
unsigned long value;
@ -48,13 +52,16 @@ char *_crypt_gensalt_extended_rn(unsigned long count,
/* Even iteration counts make it easier to detect weak DES keys from a look
* at the hash, so they should be avoided */
if (size < 3 || output_size < 1 + 4 + 4 + 1 ||
(count && (count > 0xffffff || !(count & 1)))) {
if (output_size > 0) output[0] = '\0';
(count && (count > 0xffffff || !(count & 1))))
{
if (output_size > 0)
output[0] = '\0';
__set_errno((output_size < 1 + 4 + 4 + 1) ? ERANGE : EINVAL);
return NULL;
}
if (!count) count = 725;
if (!count)
count = 725;
output[0] = '_';
output[1] = _crypt_itoa64[count & 0x3f];
@ -73,13 +80,16 @@ char *_crypt_gensalt_extended_rn(unsigned long count,
return output;
}
char *_crypt_gensalt_md5_rn(unsigned long count,
char *
_crypt_gensalt_md5_rn(unsigned long count,
const char *input, int size, char *output, int output_size)
{
unsigned long value;
if (size < 3 || output_size < 3 + 4 + 1 || (count && count != 1000)) {
if (output_size > 0) output[0] = '\0';
if (size < 3 || output_size < 3 + 4 + 1 || (count && count != 1000))
{
if (output_size > 0)
output[0] = '\0';
__set_errno((output_size < 3 + 4 + 1) ? ERANGE : EINVAL);
return NULL;
}
@ -96,7 +106,8 @@ char *_crypt_gensalt_md5_rn(unsigned long count,
output[6] = _crypt_itoa64[(value >> 18) & 0x3f];
output[7] = '\0';
if (size >= 6 && output_size >= 3 + 4 + 4 + 1) {
if (size >= 6 && output_size >= 3 + 4 + 4 + 1)
{
value = (unsigned long) input[3] |
((unsigned long) input[4] << 8) |
((unsigned long) input[5] << 16);
@ -115,18 +126,22 @@ char *_crypt_gensalt_md5_rn(unsigned long count,
static unsigned char BF_itoa64[64 + 1] =
"./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
static void BF_encode(char *dst, const BF_word *src, int size)
static void
BF_encode(char *dst, const BF_word * src, int size)
{
unsigned char *sptr = (unsigned char *) src;
unsigned char *end = sptr + size;
unsigned char *dptr = (unsigned char *) dst;
unsigned int c1, c2;
unsigned int c1,
c2;
do {
do
{
c1 = *sptr++;
*dptr++ = BF_itoa64[c1 >> 2];
c1 = (c1 & 0x03) << 4;
if (sptr >= end) {
if (sptr >= end)
{
*dptr++ = BF_itoa64[c1];
break;
}
@ -135,7 +150,8 @@ static void BF_encode(char *dst, const BF_word *src, int size)
c1 |= c2 >> 4;
*dptr++ = BF_itoa64[c1];
c1 = (c2 & 0x0f) << 2;
if (sptr >= end) {
if (sptr >= end)
{
*dptr++ = BF_itoa64[c1];
break;
}
@ -147,17 +163,21 @@ static void BF_encode(char *dst, const BF_word *src, int size)
} while (sptr < end);
}
char *_crypt_gensalt_blowfish_rn(unsigned long count,
char *
_crypt_gensalt_blowfish_rn(unsigned long count,
const char *input, int size, char *output, int output_size)
{
if (size < 16 || output_size < 7 + 22 + 1 ||
(count && (count < 4 || count > 31))) {
if (output_size > 0) output[0] = '\0';
(count && (count < 4 || count > 31)))
{
if (output_size > 0)
output[0] = '\0';
__set_errno((output_size < 7 + 22 + 1) ? ERANGE : EINVAL);
return NULL;
}
if (!count) count = 5;
if (!count)
count = 5;
output[0] = '$';
output[1] = '2';
@ -172,4 +192,3 @@ char *_crypt_gensalt_blowfish_rn(unsigned long count,
return output;
}

17
contrib/pgcrypto/crypt-md5.c
View File

@ -9,7 +9,7 @@
* $FreeBSD: src/lib/libcrypt/crypt-md5.c,v 1.5 1999/12/17 20:21:45 peter Exp $
*
*/
/* $Id: crypt-md5.c,v 1.1 2001/08/21 01:32:01 momjian Exp $ */
/* $Id: crypt-md5.c,v 1.2 2001/10/25 05:49:19 momjian Exp $ */
#include <postgres.h>
#include "px.h"
@ -23,12 +23,9 @@
char *
px_crypt_md5(const char *pw, const char *salt, char *passwd, unsigned dstlen)
{
static char *magic = "$1$"; /*
* This string is magic for
* this algorithm. Having
* it this way, we can get
* get better later on
*/
static char *magic = "$1$"; /* This string is magic for this
* algorithm. Having it this way, we can
* get get better later on */
static char *p;
static const char *sp,
*ep;
@ -99,9 +96,9 @@ px_crypt_md5(const char *pw, const char *salt, char *passwd, unsigned dstlen)
px_md_finish(ctx, final);
/*
* and now, just to make sure things don't run too fast
* On a 60 Mhz Pentium this takes 34 msec, so you would
* need 30 seconds to build a 1000 entry dictionary...
* and now, just to make sure things don't run too fast On a 60 Mhz
* Pentium this takes 34 msec, so you would need 30 seconds to build a
* 1000 entry dictionary...
*/
for (i = 0; i < 1000; i++)
{

138
contrib/pgcrypto/internal.c
View File

@ -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.5 2001/10/15 19:12:48 tgl Exp $
* $Id: internal.c,v 1.6 2001/10/25 05:49:19 momjian Exp $
*/
@ -62,10 +62,17 @@ static struct int_digest
char *name;
void (*init) (PX_MD * h);
} int_digest_list[] =
{
{ "md5", init_md5 },
{ "sha1", init_sha1 },
{ NULL, NULL }
{
"md5", init_md5
},
{
"sha1", init_sha1
},
{
NULL, NULL
}
};
/* MD5 */
@ -209,10 +216,12 @@ init_sha1(PX_MD * md)
#define INT_MAX_KEY (512/8)
#define INT_MAX_IV (128/8)
struct int_ctx {
struct int_ctx
{
uint8 keybuf[INT_MAX_KEY];
uint8 iv[INT_MAX_IV];
union {
union
{
blf_ctx bf;
rijndael_ctx rj;
} ctx;
@ -221,10 +230,13 @@ struct int_ctx {
int mode;
};
static void intctx_free(PX_Cipher *c)
static void
intctx_free(PX_Cipher * c)
{
struct int_ctx *cx = (struct int_ctx *) c->ptr;
if (cx) {
if (cx)
{
memset(cx, 0, sizeof *cx);
px_free(cx);
}
@ -238,22 +250,26 @@ static void intctx_free(PX_Cipher *c)
#define MODE_ECB 0
#define MODE_CBC 1
static uint rj_block_size(PX_Cipher *c)
static uint
rj_block_size(PX_Cipher * c)
{
return 128 / 8;
}
static uint rj_key_size(PX_Cipher *c)
static uint
rj_key_size(PX_Cipher * c)
{
return 256 / 8;
}
static uint rj_iv_size(PX_Cipher *c)
static uint
rj_iv_size(PX_Cipher * c)
{
return 128 / 8;
}
static int rj_init(PX_Cipher *c, const uint8 *key, uint klen, const uint8 *iv)
static int
rj_init(PX_Cipher * c, const uint8 *key, uint klen, const uint8 *iv)
{
struct int_ctx *cx = (struct int_ctx *) c->ptr;
@ -274,17 +290,20 @@ static int rj_init(PX_Cipher *c, const uint8 *key, uint klen, const uint8 *iv)
return 0;
}
static int rj_real_init(struct int_ctx *cx, int dir)
static int
rj_real_init(struct int_ctx * cx, int dir)
{
aes_set_key(&cx->ctx.rj, cx->keybuf, cx->keylen * 8, dir);
return 0;
}
static int rj_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
static int
rj_encrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res)
{
struct int_ctx *cx = (struct int_ctx *) c->ptr;
if (!cx->is_init) {
if (!cx->is_init)
{
if (rj_real_init(cx, 1))
return -1;
}
@ -297,16 +316,19 @@ static int rj_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
memcpy(res, data, dlen);
if (cx->mode == MODE_CBC) {
if (cx->mode == MODE_CBC)
{
aes_cbc_encrypt(&cx->ctx.rj, cx->iv, res, dlen);
memcpy(cx->iv, res + dlen - 16, 16);
} else
}
else
aes_ecb_encrypt(&cx->ctx.rj, res, dlen);
return 0;
}
static int rj_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
static int
rj_decrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res)
{
struct int_ctx *cx = (struct int_ctx *) c->ptr;
@ -322,10 +344,12 @@ static int rj_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
memcpy(res, data, dlen);
if (cx->mode == MODE_CBC) {
if (cx->mode == MODE_CBC)
{
aes_cbc_decrypt(&cx->ctx.rj, cx->iv, res, dlen);
memcpy(cx->iv, data + dlen - 16, 16);
} else
}
else
aes_ecb_decrypt(&cx->ctx.rj, res, dlen);
return 0;
@ -335,7 +359,8 @@ static int rj_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
* initializers
*/
static PX_Cipher * rj_load(int mode)
static PX_Cipher *
rj_load(int mode)
{
PX_Cipher *c;
struct int_ctx *cx;
@ -363,22 +388,26 @@ static PX_Cipher * rj_load(int mode)
* blowfish
*/
static uint bf_block_size(PX_Cipher *c)
static uint
bf_block_size(PX_Cipher * c)
{
return 8;
}
static uint bf_key_size(PX_Cipher *c)
static uint
bf_key_size(PX_Cipher * c)
{
return BLF_MAXKEYLEN;
}
static uint bf_iv_size(PX_Cipher *c)
static uint
bf_iv_size(PX_Cipher * c)
{
return 8;
}
static int bf_init(PX_Cipher *c, const uint8 *key, uint klen, const uint8 *iv)
static int
bf_init(PX_Cipher * c, const uint8 *key, uint klen, const uint8 *iv)
{
struct int_ctx *cx = (struct int_ctx *) c->ptr;
@ -389,7 +418,8 @@ static int bf_init(PX_Cipher *c, const uint8 *key, uint klen, const uint8 *iv)
return 0;
}
static int bf_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
static int
bf_encrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res)
{
struct int_ctx *cx = (struct int_ctx *) c->ptr;
@ -400,7 +430,8 @@ static int bf_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
return -1;
memcpy(res, data, dlen);
switch (cx->mode) {
switch (cx->mode)
{
case MODE_ECB:
blf_ecb_encrypt(&cx->ctx.bf, res, dlen);
break;
@ -411,7 +442,8 @@ static int bf_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
return 0;
}
static int bf_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
static int
bf_decrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res)
{
struct int_ctx *cx = (struct int_ctx *) c->ptr;
@ -422,7 +454,8 @@ static int bf_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
return -1;
memcpy(res, data, dlen);
switch (cx->mode) {
switch (cx->mode)
{
case MODE_ECB:
blf_ecb_decrypt(&cx->ctx.bf, res, dlen);
break;
@ -433,7 +466,8 @@ static int bf_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
return 0;
}
static PX_Cipher * bf_load(int mode)
static PX_Cipher *
bf_load(int mode)
{
PX_Cipher *c;
struct int_ctx *cx;
@ -458,35 +492,52 @@ static PX_Cipher * bf_load(int mode)
/* ciphers */
static PX_Cipher * rj_128_ecb()
static PX_Cipher *
rj_128_ecb()
{
return rj_load(MODE_ECB);
}
static PX_Cipher * rj_128_cbc()
static PX_Cipher *
rj_128_cbc()
{
return rj_load(MODE_CBC);
}
static PX_Cipher * bf_ecb_load()
static PX_Cipher *
bf_ecb_load()
{
return bf_load(MODE_ECB);
}
static PX_Cipher * bf_cbc_load()
static PX_Cipher *
bf_cbc_load()
{
return bf_load(MODE_CBC);
}
static struct {
static struct
{
char *name;
PX_Cipher *(*load) (void);
} int_ciphers [] = {
{ "bf-cbc", bf_cbc_load },
{ "bf-ecb", bf_ecb_load },
{ "aes-128-cbc", rj_128_cbc },
{ "aes-128-ecb", rj_128_ecb },
{ NULL, NULL }
} int_ciphers[] =
{
{
"bf-cbc", bf_cbc_load
},
{
"bf-ecb", bf_ecb_load
},
{
"aes-128-cbc", rj_128_cbc
},
{
"aes-128-ecb", rj_128_ecb
},
{
NULL, NULL
}
};
static PX_Alias int_aliases[] = {
@ -531,7 +582,8 @@ px_find_cipher(const char *name, PX_Cipher **res)
name = px_resolve_alias(int_aliases, name);
for (i = 0; int_ciphers[i].name; i++)
if (!strcmp(int_ciphers[i].name, name)) {
if (!strcmp(int_ciphers[i].name, name))
{
c = int_ciphers[i].load();
break;
}
@ -542,5 +594,3 @@ px_find_cipher(const char *name, PX_Cipher **res)
*res = c;
return 0;
}

2
contrib/pgcrypto/md5.c
View File

@ -1,4 +1,4 @@
/* $Id: md5.c,v 1.7 2001/10/25 01:29:37 momjian Exp $ */
/* $Id: md5.c,v 1.8 2001/10/25 05:49:19 momjian Exp $ */
/* $KAME: md5.c,v 1.3 2000/02/22 14:01:17 itojun Exp $ */
/*

25
contrib/pgcrypto/mhash.c
View File

@ -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.4 2001/08/21 00:42:41 momjian Exp $
* $Id: mhash.c,v 1.5 2001/10/25 05:49:19 momjian Exp $
*/
#include <postgres.h>
@ -114,6 +114,7 @@ static uint
cipher_block_size(PX_Cipher * c)
{
MCRYPT ctx = (MCRYPT) c->ptr;
return mcrypt_enc_get_block_size(ctx);
}
@ -121,6 +122,7 @@ static uint
cipher_key_size(PX_Cipher * c)
{
MCRYPT ctx = (MCRYPT) c->ptr;
return mcrypt_enc_get_key_size(ctx);
}
@ -128,6 +130,7 @@ static uint
cipher_iv_size(PX_Cipher * c)
{
MCRYPT ctx = (MCRYPT) c->ptr;
return mcrypt_enc_mode_has_iv(ctx)
? mcrypt_enc_get_iv_size(ctx) : 0;
}
@ -246,7 +249,8 @@ static PX_Alias mode_aliases[] = {
{NULL, NULL}
};
static int is_mode(char *s)
static int
is_mode(char *s)
{
char **p;
@ -301,8 +305,10 @@ px_find_cipher(const char *name, PX_Cipher **res)
strcpy(nbuf, name);
if ((p = strrchr(nbuf, '-')) != NULL) {
if (is_mode(p + 1)) {
if ((p = strrchr(nbuf, '-')) != NULL)
{
if (is_mode(p + 1))
{
mode = p + 1;
*p = 0;
}
@ -310,13 +316,13 @@ px_find_cipher(const char *name, PX_Cipher **res)
name = px_resolve_alias(aliases, nbuf);
if (!mode) {
if (!mode)
{
mode = "cbc";
/*
if (mcrypt_module_is_block_algorithm(name, NULL))
mode = "cbc";
else
mode = "stream";
* if (mcrypt_module_is_block_algorithm(name, NULL)) mode = "cbc";
* else mode = "stream";
*/
}
mode = px_resolve_alias(mode_aliases, mode);
@ -339,4 +345,3 @@ px_find_cipher(const char *name, PX_Cipher **res)
*res = c;
return 0;
}

98
contrib/pgcrypto/openssl.c
View File

@ -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.5 2001/09/23 04:12:44 momjian Exp $
* $Id: openssl.c,v 1.6 2001/10/25 05:49:19 momjian Exp $
*/
#include <postgres.h>
@ -94,9 +94,12 @@ digest_free(PX_MD * h)
*/
typedef struct {
union {
struct {
typedef struct
{
union
{
struct
{
BF_KEY key;
int num;
} bf;
@ -115,6 +118,7 @@ static uint
gen_evp_block_size(PX_Cipher * c)
{
ossldata *od = (ossldata *) c->ptr;
return EVP_CIPHER_block_size(od->evp_ciph);
}
@ -122,6 +126,7 @@ static uint
gen_evp_key_size(PX_Cipher * c)
{
ossldata *od = (ossldata *) c->ptr;
return EVP_CIPHER_key_length(od->evp_ciph);
}
@ -130,6 +135,7 @@ gen_evp_iv_size(PX_Cipher *c)
{
uint ivlen;
ossldata *od = (ossldata *) c->ptr;
ivlen = EVP_CIPHER_iv_length(od->evp_ciph);
return ivlen;
}
@ -138,6 +144,7 @@ static void
gen_evp_free(PX_Cipher * c)
{
ossldata *od = (ossldata *) c->ptr;
memset(od, 0, sizeof(*od));
pfree(od);
pfree(c);
@ -150,9 +157,10 @@ gen_evp_init(PX_Cipher *c, const uint8 *key, uint klen, const uint8 *iv)
{
ossldata *od = (ossldata *) c->ptr;
uint bs = gen_evp_block_size(c);
if (iv) {
if (iv)
memcpy(od->iv, iv, bs);
} else
else
memset(od->iv, 0, bs);
memcpy(od->key, key, klen);
od->klen = klen;
@ -174,6 +182,7 @@ static int
gen_evp_encrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res)
{
ossldata *od = c->ptr;
if (!od->init)
_gen_init(c, 1);
od->evp_ciph->do_cipher(&od->u.evp_ctx, res, data, dlen);
@ -184,6 +193,7 @@ static int
gen_evp_decrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res)
{
ossldata *od = c->ptr;
if (!od->init)
_gen_init(c, 0);
od->evp_ciph->do_cipher(&od->u.evp_ctx, res, data, dlen);
@ -196,10 +206,11 @@ static int
bf_init(PX_Cipher * c, const uint8 *key, uint klen, const uint8 *iv)
{
ossldata *od = c->ptr;
BF_set_key(&od->u.bf.key, klen, key);
if (iv) {
if (iv)
memcpy(od->iv, iv, BF_BLOCK);
} else
else
memset(od->iv, 0, BF_BLOCK);
od->u.bf.num = 0;
return 0;
@ -208,8 +219,10 @@ bf_init(PX_Cipher *c, const uint8 *key, uint klen, const uint8 *iv)
static int
bf_ecb_encrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res)
{
uint bs = gen_evp_block_size(c), i;
uint bs = gen_evp_block_size(c),
i;
ossldata *od = c->ptr;
for (i = 0; i < dlen / bs; i++)
BF_ecb_encrypt(data + i * bs, res + i * bs, &od->u.bf.key, BF_ENCRYPT);
return 0;
@ -218,8 +231,10 @@ bf_ecb_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
static int
bf_ecb_decrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res)
{
uint bs = gen_evp_block_size(c), i;
uint bs = gen_evp_block_size(c),
i;
ossldata *od = c->ptr;
for (i = 0; i < dlen / bs; i++)
BF_ecb_encrypt(data + i * bs, res + i * bs, &od->u.bf.key, BF_DECRYPT);
return 0;
@ -229,6 +244,7 @@ static int
bf_cbc_encrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res)
{
ossldata *od = c->ptr;
BF_cbc_encrypt(data, res, dlen, &od->u.bf.key, od->iv, BF_ENCRYPT);
return 0;
}
@ -237,6 +253,7 @@ static int
bf_cbc_decrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res)
{
ossldata *od = c->ptr;
BF_cbc_encrypt(data, res, dlen, &od->u.bf.key, od->iv, BF_DECRYPT);
return 0;
}
@ -245,6 +262,7 @@ static int
bf_cfb64_encrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res)
{
ossldata *od = c->ptr;
BF_cfb64_encrypt(data, res, dlen, &od->u.bf.key, od->iv,
&od->u.bf.num, BF_ENCRYPT);
return 0;
@ -254,6 +272,7 @@ static int
bf_cfb64_decrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res)
{
ossldata *od = c->ptr;
BF_cfb64_encrypt(data, res, dlen, &od->u.bf.key, od->iv,
&od->u.bf.num, BF_DECRYPT);
return 0;
@ -263,6 +282,7 @@ static int
bf_ofb64_encrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res)
{
ossldata *od = c->ptr;
BF_ofb64_encrypt(data, res, dlen, &od->u.bf.key, od->iv, &od->u.bf.num);
return 0;
}
@ -271,6 +291,7 @@ static int
bf_ofb64_decrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res)
{
ossldata *od = c->ptr;
BF_ofb64_encrypt(data, res, dlen, &od->u.bf.key, od->iv, &od->u.bf.num);
return 0;
}
@ -299,19 +320,44 @@ static PX_Alias ossl_mode_aliases [] = {
/*
* Special handlers
*/
struct {
struct
{
char *name;
PX_Cipher cf;
} spec_types [] = {
{ "bf-cbc", { gen_evp_block_size, gen_evp_key_size, gen_evp_iv_size,
bf_init, bf_cbc_encrypt, bf_cbc_decrypt, gen_evp_free}},
{ "bf-ecb", { gen_evp_block_size, gen_evp_key_size, gen_evp_iv_size,
bf_init, bf_ecb_encrypt, bf_ecb_decrypt, gen_evp_free}},
{ "bf-cfb", { gen_evp_block_size, gen_evp_key_size, gen_evp_iv_size,
bf_init, bf_cfb64_encrypt, bf_cfb64_decrypt, gen_evp_free}},
{ "bf-ofb", { gen_evp_block_size, gen_evp_key_size, gen_evp_iv_size,
bf_init, bf_ofb64_encrypt, bf_ofb64_decrypt, gen_evp_free}},
{ NULL }
} spec_types[] =
{
{
"bf-cbc",
{
gen_evp_block_size, gen_evp_key_size, gen_evp_iv_size,
bf_init, bf_cbc_encrypt, bf_cbc_decrypt, gen_evp_free
}
},
{
"bf-ecb",
{
gen_evp_block_size, gen_evp_key_size, gen_evp_iv_size,
bf_init, bf_ecb_encrypt, bf_ecb_decrypt, gen_evp_free
}
},
{
"bf-cfb",
{
gen_evp_block_size, gen_evp_key_size, gen_evp_iv_size,
bf_init, bf_cfb64_encrypt, bf_cfb64_decrypt, gen_evp_free
}
},
{
"bf-ofb",
{
gen_evp_block_size, gen_evp_key_size, gen_evp_iv_size,
bf_init, bf_ofb64_encrypt, bf_ofb64_decrypt, gen_evp_free
}
},
{
NULL
}
};
/*
@ -371,12 +417,14 @@ int
px_find_cipher(const char *name, PX_Cipher ** res)
{
uint i;
PX_Cipher *c = NULL, *csrc;
PX_Cipher *c = NULL,
*csrc;
ossldata *od;
const EVP_CIPHER *evp_c;
if (!px_openssl_initialized) {
if (!px_openssl_initialized)
{
px_openssl_initialized = 1;
/* CRYPTO_set_mem_functions(o_alloc, o_realloc, o_free); */
OpenSSL_add_all_algorithms();
@ -394,7 +442,8 @@ px_find_cipher(const char *name, PX_Cipher **res)
csrc = NULL;
for (i = 0; spec_types[i].name; i++)
if (!strcmp(name, spec_types[i].name)) {
if (!strcmp(name, spec_types[i].name))
{
csrc = &spec_types[i].cf;
break;
}
@ -409,4 +458,3 @@ px_find_cipher(const char *name, PX_Cipher **res)
*res = c;
return 0;
}

41
contrib/pgcrypto/pgcrypto.c
View File

@ -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.9 2001/09/23 04:12:44 momjian Exp $
* $Id: pgcrypto.c,v 1.10 2001/10/25 05:49:19 momjian Exp $
*/
#include <postgres.h>
@ -314,10 +314,14 @@ Datum
pg_encrypt(PG_FUNCTION_ARGS)
{
int err;
bytea *data, *key, *res;
bytea *data,
*key,
*res;
text *type;
PX_Combo *c;
uint dlen, klen, rlen;
uint dlen,
klen,
rlen;
if (PG_ARGISNULL(0) || PG_ARGISNULL(1) || PG_ARGISNULL(2))
PG_RETURN_NULL();
@ -342,7 +346,8 @@ pg_encrypt(PG_FUNCTION_ARGS)
PG_FREE_IF_COPY(key, 1);
PG_FREE_IF_COPY(type, 2);
if (err) {
if (err)
{
pfree(res);
elog(ERROR, "encrypt error: %d", err);
}
@ -358,10 +363,14 @@ Datum
pg_decrypt(PG_FUNCTION_ARGS)
{
int err;
bytea *data, *key, *res;
bytea *data,
*key,
*res;
text *type;
PX_Combo *c;
uint dlen, klen, rlen;
uint dlen,
klen,
rlen;
if (PG_ARGISNULL(0) || PG_ARGISNULL(1) || PG_ARGISNULL(2))
PG_RETURN_NULL();
@ -402,10 +411,16 @@ Datum
pg_encrypt_iv(PG_FUNCTION_ARGS)
{
int err;
bytea *data, *key, *iv, *res;
bytea *data,
*key,
*iv,
*res;
text *type;
PX_Combo *c;
uint dlen, klen, ivlen, rlen;
uint dlen,
klen,
ivlen,
rlen;
if (PG_ARGISNULL(0) || PG_ARGISNULL(1)
|| PG_ARGISNULL(2) || PG_ARGISNULL(3))
@ -450,10 +465,16 @@ Datum
pg_decrypt_iv(PG_FUNCTION_ARGS)
{
int err;
bytea *data, *key, *iv, *res;
bytea *data,
*key,
*iv,
*res;
text *type;
PX_Combo *c;
uint dlen, klen, rlen, ivlen;
uint dlen,
klen,
rlen,
ivlen;
if (PG_ARGISNULL(0) || PG_ARGISNULL(1)
|| PG_ARGISNULL(2) || PG_ARGISNULL(3))

4
contrib/pgcrypto/pgcrypto.h
View File

@ -26,7 +26,7 @@
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $Id: pgcrypto.h,v 1.5 2001/09/23 04:12:44 momjian Exp $
* $Id: pgcrypto.h,v 1.6 2001/10/25 05:49:20 momjian Exp $
*/
#ifndef _PG_CRYPTO_H
@ -45,6 +45,4 @@ Datum pg_decrypt(PG_FUNCTION_ARGS);
Datum pg_encrypt_iv(PG_FUNCTION_ARGS);
Datum pg_decrypt_iv(PG_FUNCTION_ARGS);
Datum pg_cipher_exists(PG_FUNCTION_ARGS);
#endif

41
contrib/pgcrypto/px-crypt.c
View File

@ -26,7 +26,7 @@
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $Id: px-crypt.c,v 1.2 2001/09/23 04:12:44 momjian Exp $
* $Id: px-crypt.c,v 1.3 2001/10/25 05:49:20 momjian Exp $
*/
#include <postgres.h>
@ -54,6 +54,7 @@ run_crypt_md5(const char *psw, const char *salt,
char *buf, unsigned len)
{
char *res;
res = px_crypt_md5(psw, salt, buf, len);
return res;
}
@ -63,6 +64,7 @@ run_crypt_bf(const char *psw, const char *salt,
char *buf, unsigned len)
{
char *res;
res = _crypt_blowfish_rn(psw, salt, buf, len);
return res;
}
@ -76,12 +78,24 @@ static struct
} px_crypt_list[] =
{
{ "$2a$", 4, run_crypt_bf },
{ "$2$", 3, NULL }, /* N/A */
{ "$1$", 3, run_crypt_md5 },
{ "_", 1, run_crypt_des },
{ "", 0, run_crypt_des },
{ NULL, 0, NULL }
{
"$2a$", 4, run_crypt_bf
},
{
"$2$", 3, NULL
}, /* N/A */
{
"$1$", 3, run_crypt_md5
},
{
"_", 1, run_crypt_des
},
{
"", 0, run_crypt_des
},
{
NULL, 0, NULL
}
};
char *
@ -125,7 +139,8 @@ px_crypt(const char *psw, const char *salt,
* salt generators
*/
struct generator {
struct generator
{
char *name;
char *(*gen) (unsigned long count, const char *input, int size,
char *output, int output_size);
@ -146,17 +161,20 @@ static struct generator gen_list [] = {
uint
px_gen_salt(const char *salt_type, char *buf, int rounds)
{
int i, res;
int i,
res;
struct generator *g;
char *p;
char rbuf[16];
for (i = 0; gen_list[i].name; i++) {
for (i = 0; gen_list[i].name; i++)
{
g = &gen_list[i];
if (strcasecmp(g->name, salt_type) != 0)
continue;
if (g->def_rounds) {
if (g->def_rounds)
{
if (rounds == 0)
rounds = g->def_rounds;
@ -176,4 +194,3 @@ px_gen_salt(const char *salt_type, char *buf, int rounds)
return 0;
}

4
contrib/pgcrypto/px-crypt.h
View File

@ -26,7 +26,7 @@
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $Id: px-crypt.h,v 1.2 2001/09/23 04:12:44 momjian Exp $
* $Id: px-crypt.h,v 1.3 2001/10/25 05:49:20 momjian Exp $
*/
#ifndef _PX_CRYPT_H
@ -58,6 +58,7 @@ unsigned px_gen_salt(const char *salt_type, char *dst, int rounds);
/* misc.c */
extern void px_crypt_to64(char *s, unsigned long v, int n);
extern char px_crypt_a64[];
/* avoid conflicts with system libs */
#define _crypt_to64 px_crypt_to64
#define _crypt_a64 px_crypt_a64
@ -87,6 +88,5 @@ char *px_crypt_des(const char *key, const char *setting);
/* crypt-md5.c */
char *px_crypt_md5(const char *pw, const char *salt,
char *dst, unsigned dstlen);
#endif /* !PX_SYSTEM_CRYPT */
#endif /* _PX_CRYPT_H */

2
contrib/pgcrypto/px-hmac.c
View File

@ -26,7 +26,7 @@
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $Id: px-hmac.c,v 1.1 2001/08/21 01:32:01 momjian Exp $
* $Id: px-hmac.c,v 1.2 2001/10/25 05:49:20 momjian Exp $
*/

88
contrib/pgcrypto/px.c
View File

@ -26,7 +26,7 @@
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $Id: px.c,v 1.2 2001/09/06 03:21:39 momjian Exp $
* $Id: px.c,v 1.3 2001/10/25 05:49:20 momjian Exp $
*/
#include <postgres.h>
@ -37,7 +37,8 @@
const char *
px_resolve_alias(const PX_Alias * list, const char *name)
{
while (list->name) {
while (list->name)
{
if (!strcasecmp(list->alias, name))
return list->name;
list++;
@ -66,7 +67,9 @@ combo_init(PX_Combo *cx, const uint8 *key, uint klen,
const uint8 *iv, uint ivlen)
{
int err;
uint bs, ks, ivs;
uint bs,
ks,
ivs;
PX_Cipher *c = cx->cipher;
uint8 *ivbuf = NULL;
uint8 *keybuf;
@ -75,7 +78,8 @@ combo_init(PX_Combo *cx, const uint8 *key, uint klen,
ks = px_cipher_key_size(c);
ivs = px_cipher_iv_size(c);
if (ivs > 0) {
if (ivs > 0)
{
ivbuf = px_alloc(ivs);
memset(ivbuf, 0, ivs);
if (ivlen > ivs)
@ -102,7 +106,11 @@ combo_encrypt(PX_Combo *cx, const uint8 *data, uint dlen,
{
int err = 0;
uint8 *bbuf;
uint bs, maxlen, bpos, i, pad;
uint bs,
maxlen,
bpos,
i,
pad;
PX_Cipher *c = cx->cipher;
@ -111,25 +119,30 @@ combo_encrypt(PX_Combo *cx, const uint8 *data, uint dlen,
bs = px_cipher_block_size(c);
/* encrypt */
if (bs > 1) {
if (bs > 1)
{
bbuf = px_alloc(bs * 4);
bpos = dlen % bs;
*rlen = dlen - bpos;
memcpy(bbuf, data + *rlen, bpos);
/* encrypt full-block data */
if (*rlen) {
if (*rlen)
{
err = px_cipher_encrypt(c, data, *rlen, res);
if (err)
goto out;
}
/* bbuf has now bpos bytes of stuff */
if (cx->padding) {
if (cx->padding)
{
pad = bs - (bpos % bs);
for (i = 0; i < pad; i++)
bbuf[bpos++] = pad;
} else if (bpos % bs) {
}
else if (bpos % bs)
{
/* ERROR? */
pad = bs - (bpos % bs);
for (i = 0; i < pad; i++)
@ -137,11 +150,14 @@ combo_encrypt(PX_Combo *cx, const uint8 *data, uint dlen,
}
/* encrypt the rest - pad */
if (bpos) {
if (bpos)
{
err = px_cipher_encrypt(c, bbuf, bpos, res + *rlen);
*rlen += bpos;
}
} else {
}
else
{
/* stream cipher/mode - no pad needed */
err = px_cipher_encrypt(c, data, dlen, res);
if (err)
@ -149,7 +165,8 @@ combo_encrypt(PX_Combo *cx, const uint8 *data, uint dlen,
*rlen = dlen;
}
out:
if (bbuf) px_free(bbuf);
if (bbuf)
px_free(bbuf);
return err;
}
@ -158,28 +175,32 @@ static int
combo_decrypt(PX_Combo * cx, const uint8 *data, uint dlen,
uint8 *res, uint *rlen)
{
uint bs, i, pad;
uint bs,
i,
pad;
uint pad_ok;
PX_Cipher *c = cx->cipher;
bs = px_cipher_block_size(c);
if (bs > 1 && (dlen % bs) != 0) {
if (bs > 1 && (dlen % bs) != 0)
goto block_error;
}
/* decrypt */
*rlen = dlen;
px_cipher_decrypt(c, data, dlen, res);
/* unpad */
if (bs > 1 && cx->padding) {
if (bs > 1 && cx->padding)
{
pad = res[*rlen - 1];
pad_ok = 0;
if (pad > 0 && pad <= bs && pad <= *rlen) {
if (pad > 0 && pad <= bs && pad <= *rlen)
{
pad_ok = 1;
for (i = *rlen - pad; i < *rlen; i++)
if (res[i] != pad) {
if (res[i] != pad)
{
pad_ok = 0;
break;
}
@ -211,29 +232,36 @@ combo_free(PX_Combo *cx)
static int
parse_cipher_name(char *full, char **cipher, char **pad)
{
char *p, *p2, *q;
char *p,
*p2,
*q;
*cipher = full;
*pad = NULL;
p = strchr(full, '/');
if (p != NULL)
*p++ = 0;
while (p != NULL) {
while (p != NULL)
{
if ((q = strchr(p, '/')) != NULL)
*q++ = 0;
if (!*p) {
if (!*p)
{
p = q;
continue;
}
p2 = strchr(p, ':');
if (p2 != NULL) {
if (p2 != NULL)
{
*p2++ = 0;
if (!strcmp(p, "pad"))
*pad = p2;
else
return -1;
} else
}
else
return -1;
p = q;
@ -247,7 +275,9 @@ int
px_find_combo(const char *name, PX_Combo ** res)
{
int err;
char *buf, *s_cipher, *s_pad;
char *buf,
*s_cipher,
*s_pad;
PX_Combo *cx;
@ -258,7 +288,8 @@ px_find_combo(const char *name, PX_Combo **res)
strcpy(buf, name);
err = parse_cipher_name(buf, &s_cipher, &s_pad);
if (err) {
if (err)
{
px_free(buf);
px_free(cx);
return err;
@ -268,14 +299,16 @@ px_find_combo(const char *name, PX_Combo **res)
if (err)
goto err1;
if (s_pad != NULL) {
if (s_pad != NULL)
{
if (!strcmp(s_pad, "pkcs"))
cx->padding = 1;
else if (!strcmp(s_pad, "none"))
cx->padding = 0;
else
goto err1;
} else
}
else
cx->padding = 1;
cx->init = combo_init;
@ -298,4 +331,3 @@ err1:
px_free(buf);
return -1;
}

26
contrib/pgcrypto/px.h
View File

@ -26,7 +26,7 @@
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $Id: px.h,v 1.2 2001/09/23 04:12:44 momjian Exp $
* $Id: px.h,v 1.3 2001/10/25 05:49:20 momjian Exp $
*/
#ifndef __PX_H
@ -47,7 +47,6 @@ void xfree(void *p);
#define px_alloc(s) xalloc(s)
#define px_realloc(p, s) xrealloc(p, s)
#define px_free(p) xfree(p)
#endif
/* max len of 'type' parms */
@ -63,7 +62,8 @@ typedef struct px_hmac PX_HMAC;
typedef struct px_cipher PX_Cipher;
typedef struct px_combo PX_Combo;
struct px_digest {
struct px_digest
{
uint (*result_size) (PX_MD * h);
uint (*block_size) (PX_MD * h);
void (*reset) (PX_MD * h);
@ -71,18 +71,21 @@ struct px_digest {
void (*finish) (PX_MD * h, uint8 *dst);
void (*free) (PX_MD * h);
/* private */
union {
union
{
uint code;
const void *ptr;
} p;
};
struct px_alias {
struct px_alias
{
char *alias;
char *name;
};
struct px_hmac {
struct px_hmac
{
uint (*result_size) (PX_HMAC * h);
uint (*block_size) (PX_HMAC * h);
void (*reset) (PX_HMAC * h);
@ -93,13 +96,15 @@ struct px_hmac {
PX_MD *md;
/* private */
struct {
struct
{
uint8 *ipad;
uint8 *opad;
} p;
};
struct px_cipher {
struct px_cipher
{
uint (*block_size) (PX_Cipher * c);
uint (*key_size) (PX_Cipher * c); /* max key len */
uint (*iv_size) (PX_Cipher * c);
@ -113,7 +118,8 @@ struct px_cipher {
int pstat; /* mcrypt uses it */
};
struct px_combo {
struct px_combo
{
int (*init) (PX_Combo * cx, const uint8 *key, uint klen,
const uint8 *iv, uint ivlen);
int (*encrypt) (PX_Combo * cx, const uint8 *data, uint dlen,
@ -174,6 +180,4 @@ const char *px_resolve_alias(const PX_Alias *aliases, const char *name);
(c)->decrypt(c, data, dlen, res, rlen)
#define px_combo_free(c) (c)->free(c)
#endif /* __PX_H */

32
contrib/pgcrypto/random.c
View File

@ -26,7 +26,7 @@
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $Id: random.c,v 1.2 2001/09/29 03:12:51 momjian Exp $
* $Id: random.c,v 1.3 2001/10/25 05:49:20 momjian Exp $
*/
@ -48,9 +48,11 @@ safe_read(int fd, void *buf, size_t count)
char *p = buf;
int res;
while (count) {
while (count)
{
res = read(fd, p, count);
if (res <= 0) {
if (res <= 0)
{
if (errno == EINTR)
continue;
return -1;
@ -75,20 +77,19 @@ px_get_random_bytes(uint8 *dst, unsigned count)
close(fd);
return res;
}
#endif /* RAND_DEV */
#ifdef RAND_SILLY
int px_get_random_bytes(uint8 *dst, unsigned count)
int
px_get_random_bytes(uint8 *dst, unsigned count)
{
int i;
for (i = 0; i < count; i++) {
for (i = 0; i < count; i++)
*dst++ = random();
}
return i;
}
#endif /* RAND_SILLY */
#ifdef RAND_OPENSSL
@ -100,20 +101,21 @@ int px_get_random_bytes(uint8 *dst, unsigned count)
static int openssl_random_init = 0;
int px_get_random_bytes(uint8 *dst, unsigned count)
int
px_get_random_bytes(uint8 *dst, unsigned count)
{
int res;
if (!openssl_random_init) {
if (RAND_get_rand_method() == NULL) {
if (!openssl_random_init)
{
if (RAND_get_rand_method() == NULL)
RAND_set_rand_method(RAND_SSLeay());
}
openssl_random_init = 1;
}
/*
* OpenSSL random should re-feeded occasionally.
* From /dev/urandom preferrably.
* OpenSSL random should re-feeded occasionally. From /dev/urandom
* preferrably.
*/
res = RAND_bytes(dst, count);
@ -122,6 +124,4 @@ int px_get_random_bytes(uint8 *dst, unsigned count)
return -1;
}
#endif /* RAND_OPENSSL */

255
contrib/pgcrypto/rijndael.c
View File

@ -152,29 +152,34 @@ static u4byte tab_gen = 0;
rotl(((u4byte)isb_tab[byte(bi[(n + 3) & 3],1)]), 8) ^ \
rotl(((u4byte)isb_tab[byte(bi[(n + 2) & 3],2)]), 16) ^ \
rotl(((u4byte)isb_tab[byte(bi[(n + 1) & 3],3)]), 24) ^ *(k + n)
#endif
static void
gen_tabs(void)
{
#ifndef PRE_CALC_TABLES
u4byte i, t;
u1byte p, q;
u4byte i,
t;
u1byte p,
q;
/* log and power tables for GF(2**8) finite field with */
/* 0x11b as modular polynomial - the simplest prmitive */
/* root is 0x11, used here to generate the tables */
for(i = 0,p = 1; i < 256; ++i) {
pow_tab[i] = (u1byte)p; log_tab[p] = (u1byte)i;
for (i = 0, p = 1; i < 256; ++i)
{
pow_tab[i] = (u1byte) p;
log_tab[p] = (u1byte) i;
p = p ^ (p << 1) ^ (p & 0x80 ? 0x01b : 0);
}
log_tab[1] = 0; p = 1;
log_tab[1] = 0;
p = 1;
for(i = 0; i < 10; ++i) {
for (i = 0; i < 10; ++i)
{
rco_tab[i] = p;
p = (p << 1) ^ (p & 0x80 ? 0x1b : 0);
@ -186,21 +191,30 @@ gen_tabs(void)
/* of the specification the bits are numbered from the */
/* least significant end of a byte. */
for(i = 0; i < 256; ++i) {
p = (i ? pow_tab[255 - log_tab[i]] : 0); q = p;
q = (q >> 7) | (q << 1); p ^= q;
q = (q >> 7) | (q << 1); p ^= q;
q = (q >> 7) | (q << 1); p ^= q;
q = (q >> 7) | (q << 1); p ^= q ^ 0x63;
sbx_tab[i] = (u1byte)p; isb_tab[p] = (u1byte)i;
for (i = 0; i < 256; ++i)
{
p = (i ? pow_tab[255 - log_tab[i]] : 0);
q = p;
q = (q >> 7) | (q << 1);
p ^= q;
q = (q >> 7) | (q << 1);
p ^= q;
q = (q >> 7) | (q << 1);
p ^= q;
q = (q >> 7) | (q << 1);
p ^= q ^ 0x63;
sbx_tab[i] = (u1byte) p;
isb_tab[p] = (u1byte) i;
}
for(i = 0; i < 256; ++i) {
for (i = 0; i < 256; ++i)
{
p = sbx_tab[i];
#ifdef LARGE_TABLES
t = p; fl_tab[0][i] = t;
t = p;
fl_tab[0][i] = t;
fl_tab[1][i] = rotl(t, 8);
fl_tab[2][i] = rotl(t, 16);
fl_tab[3][i] = rotl(t, 24);
@ -219,7 +233,8 @@ gen_tabs(void)
#ifdef LARGE_TABLES
t = p; il_tab[0][i] = t;
t = p;
il_tab[0][i] = t;
il_tab[1][i] = rotl(t, 8);
il_tab[2][i] = rotl(t, 16);
il_tab[3][i] = rotl(t, 24);
@ -289,7 +304,11 @@ rijndael_ctx *
rijndael_set_key(rijndael_ctx * ctx, const u4byte * in_key, const u4byte key_len,
int encrypt)
{
u4byte i, t, u, v, w;
u4byte i,
t,
u,
v,
w;
u4byte *e_key = ctx->e_key;
u4byte *d_key = ctx->d_key;
@ -300,35 +319,46 @@ rijndael_set_key(rijndael_ctx *ctx, const u4byte *in_key, const u4byte key_len,
ctx->k_len = (key_len + 31) / 32;
e_key[0] = io_swap(in_key[0]); e_key[1] = io_swap(in_key[1]);
e_key[2] = io_swap(in_key[2]); e_key[3] = io_swap(in_key[3]);
e_key[0] = io_swap(in_key[0]);
e_key[1] = io_swap(in_key[1]);
e_key[2] = io_swap(in_key[2]);
e_key[3] = io_swap(in_key[3]);
switch(ctx->k_len) {
case 4: t = e_key[3];
switch (ctx->k_len)
{
case 4:
t = e_key[3];
for (i = 0; i < 10; ++i)
loop4(i);
break;
case 6: e_key[4] = io_swap(in_key[4]); t = e_key[5] = io_swap(in_key[5]);
case 6:
e_key[4] = io_swap(in_key[4]);
t = e_key[5] = io_swap(in_key[5]);
for (i = 0; i < 8; ++i)
loop6(i);
break;
case 8: e_key[4] = io_swap(in_key[4]); e_key[5] = io_swap(in_key[5]);
e_key[6] = io_swap(in_key[6]); t = e_key[7] = io_swap(in_key[7]);
case 8:
e_key[4] = io_swap(in_key[4]);
e_key[5] = io_swap(in_key[5]);
e_key[6] = io_swap(in_key[6]);
t = e_key[7] = io_swap(in_key[7]);
for (i = 0; i < 7; ++i)
loop8(i);
break;
}
if (!encrypt) {
d_key[0] = e_key[0]; d_key[1] = e_key[1];
d_key[2] = e_key[2]; d_key[3] = e_key[3];
if (!encrypt)
{
d_key[0] = e_key[0];
d_key[1] = e_key[1];
d_key[2] = e_key[2];
d_key[3] = e_key[3];
for(i = 4; i < 4 * ctx->k_len + 24; ++i) {
for (i = 4; i < 4 * ctx->k_len + 24; ++i)
imix_col(d_key[i], e_key[i]);
}
}
return ctx;
}
@ -353,7 +383,9 @@ rijndael_encrypt(rijndael_ctx *ctx, const u4byte *in_blk, u4byte *out_blk)
{
u4byte k_len = ctx->k_len;
u4byte *e_key = ctx->e_key;
u4byte b0[4], b1[4], *kp;
u4byte b0[4],
b1[4],
*kp;
b0[0] = io_swap(in_blk[0]) ^ e_key[0];
b0[1] = io_swap(in_blk[1]) ^ e_key[1];
@ -362,22 +394,33 @@ rijndael_encrypt(rijndael_ctx *ctx, const u4byte *in_blk, u4byte *out_blk)
kp = e_key + 4;
if(k_len > 6) {
f_nround(b1, b0, kp); f_nround(b0, b1, kp);
if (k_len > 6)
{
f_nround(b1, b0, kp);
f_nround(b0, b1, kp);
}
if(k_len > 4) {
f_nround(b1, b0, kp); f_nround(b0, b1, kp);
if (k_len > 4)
{
f_nround(b1, b0, kp);
f_nround(b0, b1, kp);
}
f_nround(b1, b0, kp); f_nround(b0, b1, kp);
f_nround(b1, b0, kp); f_nround(b0, b1, kp);
f_nround(b1, b0, kp); f_nround(b0, b1, kp);
f_nround(b1, b0, kp); f_nround(b0, b1, kp);
f_nround(b1, b0, kp); f_lround(b0, b1, kp);
f_nround(b1, b0, kp);
f_nround(b0, b1, kp);
f_nround(b1, b0, kp);
f_nround(b0, b1, kp);
f_nround(b1, b0, kp);
f_nround(b0, b1, kp);
f_nround(b1, b0, kp);
f_nround(b0, b1, kp);
f_nround(b1, b0, kp);
f_lround(b0, b1, kp);
out_blk[0] = io_swap(b0[0]); out_blk[1] = io_swap(b0[1]);
out_blk[2] = io_swap(b0[2]); out_blk[3] = io_swap(b0[3]);
out_blk[0] = io_swap(b0[0]);
out_blk[1] = io_swap(b0[1]);
out_blk[2] = io_swap(b0[2]);
out_blk[3] = io_swap(b0[3]);
}
/* decrypt a block of text */
@ -398,7 +441,9 @@ rijndael_encrypt(rijndael_ctx *ctx, const u4byte *in_blk, u4byte *out_blk)
void
rijndael_decrypt(rijndael_ctx * ctx, const u4byte * in_blk, u4byte * out_blk)
{
u4byte b0[4], b1[4], *kp;
u4byte b0[4],
b1[4],
*kp;
u4byte k_len = ctx->k_len;
u4byte *e_key = ctx->e_key;
u4byte *d_key = ctx->d_key;
@ -410,22 +455,33 @@ rijndael_decrypt(rijndael_ctx *ctx, const u4byte *in_blk, u4byte *out_blk)
kp = d_key + 4 * (k_len + 5);
if(k_len > 6) {
i_nround(b1, b0, kp); i_nround(b0, b1, kp);
if (k_len > 6)
{
i_nround(b1, b0, kp);
i_nround(b0, b1, kp);
}
if(k_len > 4) {
i_nround(b1, b0, kp); i_nround(b0, b1, kp);
if (k_len > 4)
{
i_nround(b1, b0, kp);
i_nround(b0, b1, kp);
}
i_nround(b1, b0, kp); i_nround(b0, b1, kp);
i_nround(b1, b0, kp); i_nround(b0, b1, kp);
i_nround(b1, b0, kp); i_nround(b0, b1, kp);
i_nround(b1, b0, kp); i_nround(b0, b1, kp);
i_nround(b1, b0, kp); i_lround(b0, b1, kp);
i_nround(b1, b0, kp);
i_nround(b0, b1, kp);
i_nround(b1, b0, kp);
i_nround(b0, b1, kp);
i_nround(b1, b0, kp);
i_nround(b0, b1, kp);
i_nround(b1, b0, kp);
i_nround(b0, b1, kp);
i_nround(b1, b0, kp);
i_lround(b0, b1, kp);
out_blk[0] = io_swap(b0[0]); out_blk[1] = io_swap(b0[1]);
out_blk[2] = io_swap(b0[2]); out_blk[3] = io_swap(b0[3]);
out_blk[0] = io_swap(b0[0]);
out_blk[1] = io_swap(b0[1]);
out_blk[2] = io_swap(b0[2]);
out_blk[3] = io_swap(b0[3]);
}
/*
@ -435,18 +491,23 @@ rijndael_decrypt(rijndael_ctx *ctx, const u4byte *in_blk, u4byte *out_blk)
* should be true for PX. -marko
*/
void aes_set_key(rijndael_ctx * ctx, const uint8 *key, uint keybits, int enc)
void
aes_set_key(rijndael_ctx * ctx, const uint8 *key, uint keybits, int enc)
{
uint32 *k;
k = (uint32 *) key;
rijndael_set_key(ctx, k, keybits, enc);
}
void aes_ecb_encrypt(rijndael_ctx *ctx, uint8 *data, unsigned len)
void
aes_ecb_encrypt(rijndael_ctx * ctx, uint8 *data, unsigned len)
{
unsigned bs = 16;
uint32 *d;
while (len >= bs) {
while (len >= bs)
{
d = (uint32 *) data;
rijndael_encrypt(ctx, d, d);
@ -455,11 +516,14 @@ void aes_ecb_encrypt(rijndael_ctx *ctx, uint8 *data, unsigned len)
}
}
void aes_ecb_decrypt(rijndael_ctx *ctx, uint8 *data, unsigned len)
void
aes_ecb_decrypt(rijndael_ctx * ctx, uint8 *data, unsigned len)
{
unsigned bs = 16;
uint32 *d;
while (len >= bs) {
while (len >= bs)
{
d = (uint32 *) data;
rijndael_decrypt(ctx, d, d);
@ -468,15 +532,19 @@ void aes_ecb_decrypt(rijndael_ctx *ctx, uint8 *data, unsigned len)
}
}
void aes_cbc_encrypt(rijndael_ctx *ctx, uint8 *iva, uint8 *data, unsigned len)
void
aes_cbc_encrypt(rijndael_ctx * ctx, uint8 *iva, uint8 *data, unsigned len)
{
uint32 *iv = (uint32 *) iva;
uint32 *d = (uint32 *) data;
unsigned bs = 16;
while (len >= bs) {
d[0] ^= iv[0]; d[1] ^= iv[1];
d[2] ^= iv[2]; d[3] ^= iv[3];
while (len >= bs)
{
d[0] ^= iv[0];
d[1] ^= iv[1];
d[2] ^= iv[2];
d[3] ^= iv[3];
rijndael_encrypt(ctx, d, d);
@ -486,24 +554,33 @@ void aes_cbc_encrypt(rijndael_ctx *ctx, uint8 *iva, uint8 *data, unsigned len)
}
}
void aes_cbc_decrypt(rijndael_ctx *ctx, uint8 *iva, uint8 *data, unsigned len)
void
aes_cbc_decrypt(rijndael_ctx * ctx, uint8 *iva, uint8 *data, unsigned len)
{
uint32 *d = (uint32 *) data;
unsigned bs = 16;
uint32 buf[4], iv[4];
uint32 buf[4],
iv[4];
memcpy(iv, iva, bs);
while (len >= bs) {
buf[0] = d[0]; buf[1] = d[1];
buf[2] = d[2]; buf[3] = d[3];
while (len >= bs)
{
buf[0] = d[0];
buf[1] = d[1];
buf[2] = d[2];
buf[3] = d[3];
rijndael_decrypt(ctx, buf, d);
d[0] ^= iv[0]; d[1] ^= iv[1];
d[2] ^= iv[2]; d[3] ^= iv[3];
d[0] ^= iv[0];
d[1] ^= iv[1];
d[2] ^= iv[2];
d[3] ^= iv[3];
iv[0] = buf[0]; iv[1] = buf[1];
iv[2] = buf[2]; iv[3] = buf[3];
iv[0] = buf[0];
iv[1] = buf[1];
iv[2] = buf[2];
iv[3] = buf[3];
d += 4;
len -= bs;
}
@ -518,11 +595,14 @@ void aes_cbc_decrypt(rijndael_ctx *ctx, uint8 *iva, uint8 *data, unsigned len)
*/
#ifdef PRINT_TABS
static void show256u8(char *name, uint8 *data)
static void
show256u8(char *name, uint8 *data)
{
int i;
printf("static const u1byte %s[256] = {\n ", name);
for (i = 0; i < 256; ) {
for (i = 0; i < 256;)
{
printf("%u", pow_tab[i++]);
if (i < 256)
printf(i % 16 ? ", " : ",\n ");
@ -531,12 +611,17 @@ static void show256u8(char *name, uint8 *data)
}
static void show4x256u32(char *name, uint32 data[4][256])
static void
show4x256u32(char *name, uint32 data[4][256])
{
int i, j;
int i,
j;
printf("static const u4byte %s[4][256] = {\n{\n ", name);
for (i = 0; i < 4; i++) {
for (j = 0; j < 256; ) {
for (i = 0; i < 4; i++)
{
for (j = 0; j < 256;)
{
printf("0x%08x", data[i][j]);
j++;
if (j < 256)
@ -547,7 +632,8 @@ static void show4x256u32(char *name, uint32 data[4][256])
printf("};\n\n");
}
int main()
int
main()
{
int i;
char *hdr = "/* Generated by rijndael.c */\n\n";
@ -567,14 +653,15 @@ int main()
show4x256u32("il_tab", il_tab);
#endif
printf("static const u4byte rco_tab[10] = {\n ");
for (i = 0; i < 10; i++) {
for (i = 0; i < 10; i++)
{
printf("0x%08x", rco_tab[i]);
if (i < 9) printf(", ");
if (i == 4) printf("\n ");
if (i < 9)
printf(", ");
if (i == 4)
printf("\n ");
}
printf("\n};\n\n");
return 0;
}
#endif

4
contrib/pgcrypto/rijndael.h
View File

@ -27,7 +27,8 @@ typedef int8 s1byte; /* an 8 bit signed character type */
typedef int16 s2byte; /* a 16 bit signed integer type */
typedef int32 s4byte; /* a 32 bit signed integer type */
typedef struct _rijndael_ctx {
typedef struct _rijndael_ctx
{
u4byte k_len;
int decrypt;
u4byte e_key[64];
@ -53,5 +54,4 @@ void aes_ecb_decrypt(rijndael_ctx *ctx, uint8 *data, unsigned len);
void aes_cbc_encrypt(rijndael_ctx * ctx, uint8 *iva, uint8 *data, unsigned len);
void aes_cbc_decrypt(rijndael_ctx * ctx, uint8 *iva, uint8 *data, unsigned len);
#endif /* _RIJNDAEL_H_ */

2
contrib/pgcrypto/sha1.c
View File

@ -1,4 +1,4 @@
/* $Id: sha1.c,v 1.7 2001/10/25 01:29:37 momjian Exp $ */
/* $Id: sha1.c,v 1.8 2001/10/25 05:49:20 momjian Exp $ */
/* $KAME: sha1.c,v 1.3 2000/02/22 14:01:18 itojun Exp $ */
/*

3
contrib/pgcrypto/sha1.h
View File

@ -1,4 +1,4 @@
/* $Id: sha1.h,v 1.5 2001/08/21 00:42:41 momjian Exp $ */
/* $Id: sha1.h,v 1.6 2001/10/25 05:49:20 momjian Exp $ */
/* $KAME: sha1.h,v 1.4 2000/02/22 14:01:18 itojun Exp $ */
/*
@ -71,5 +71,4 @@ typedef struct sha1_ctxt SHA1_CTX;
#define SHA1Final(x, y) sha1_result((y), (x))
#define SHA1_RESULTLEN (160/8)
#endif /* _NETINET6_SHA1_H_ */

5
contrib/pgstattuple/pgstattuple.c
View File

@ -1,5 +1,5 @@
/*
* $Header: /cvsroot/pgsql/contrib/pgstattuple/pgstattuple.c,v 1.1 2001/10/01 01:52:38 ishii Exp $
* $Header: /cvsroot/pgsql/contrib/pgstattuple/pgstattuple.c,v 1.2 2001/10/25 05:49:20 momjian Exp $
*
* Copyright (c) 2001 Tatsuo Ishii
*
@ -117,7 +117,8 @@ pgstattuple(PG_FUNCTION_ARGS)
(double) dead_tuple_len / 1024 / 1024, /* dead tuples in MB */
dead_tuple_percent, /* dead tuples in % */
(double)free_space/1024/1024, /* free/available space in MB */
(double) free_space / 1024 / 1024, /* free/available space in
* MB */
free_percent, /* free/available space in % */

4
contrib/rserv/rserv.c
View File

@ -24,7 +24,6 @@ Datum _rserv_debug_(PG_FUNCTION_ARGS);
HeapTuple _rserv_log_(void);
int32 _rserv_sync_(int32);
int32 _rserv_debug_(int32);
#endif
static int debug = 0;
@ -88,6 +87,7 @@ _rserv_log_()
newtuple = CurrentTriggerData->tg_newtuple;
#ifndef PG_FUNCTION_INFO_V1
/*
* Setting CurrentTriggerData to NULL prevents direct calls to trigger
* functions in queries. Normally, trigger functions have to be called
@ -207,7 +207,6 @@ _rserv_sync_(int32 server)
{
#ifdef PG_FUNCTION_INFO_V1
int32 server = PG_GETARG_INT32(0);
#endif
char sql[8192];
char buf[8192];
@ -253,7 +252,6 @@ _rserv_debug_(int32 newval)
{
#ifdef PG_FUNCTION_INFO_V1
int32 newval = PG_GETARG_INT32(0);
#endif
int32 oldval = debug;

139
contrib/rtree_gist/rtree_gist.c
View File

@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/contrib/rtree_gist/Attic/rtree_gist.c,v 1.3 2001/10/01 17:53:11 tgl Exp $
* $Header: /cvsroot/pgsql/contrib/rtree_gist/Attic/rtree_gist.c,v 1.4 2001/10/25 05:49:20 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -80,8 +80,8 @@ gbox_consistent(PG_FUNCTION_ARGS)
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
/*
** if entry is not leaf, use gbox_internal_consistent,
** else use gbox_leaf_consistent
* * if entry is not leaf, use gbox_internal_consistent, * else use
* gbox_leaf_consistent
*/
if (!(DatumGetPointer(entry->key) != NULL && query))
PG_RETURN_BOOL(FALSE);
@ -102,15 +102,18 @@ gbox_union(PG_FUNCTION_ARGS)
{
bytea *entryvec = (bytea *) PG_GETARG_POINTER(0);
int *sizep = (int *) PG_GETARG_POINTER(1);
int numranges, i;
BOX *cur, *pageunion;
int numranges,
i;
BOX *cur,
*pageunion;
numranges = (VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY);
pageunion = (BOX *) palloc(sizeof(BOX));
cur = DatumGetBoxP(((GISTENTRY *) VARDATA(entryvec))[0].key);
memcpy((void *) pageunion, (void *) cur, sizeof(BOX));
for (i = 1; i < numranges; i++) {
for (i = 1; i < numranges; i++)
{
cur = DatumGetBoxP(((GISTENTRY *) VARDATA(entryvec))[i].key);
if (pageunion->high.x < cur->high.x)
pageunion->high.x = cur->high.x;
@ -151,7 +154,8 @@ gbox_penalty(PG_FUNCTION_ARGS)
ud = DirectFunctionCall2(rt_box_union, origentry->key, newentry->key);
tmp1 = size_box(ud);
if (DatumGetPointer(ud) != NULL) pfree(DatumGetPointer(ud));
if (DatumGetPointer(ud) != NULL)
pfree(DatumGetPointer(ud));
*result = tmp1 - size_box(origentry->key);
PG_RETURN_POINTER(result);
@ -168,9 +172,18 @@ gbox_picksplit(PG_FUNCTION_ARGS)
bytea *entryvec = (bytea *) PG_GETARG_POINTER(0);
GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1);
OffsetNumber i;
OffsetNumber *listL, *listR, *listB, *listT;
BOX *unionL,*unionR,*unionB,*unionT;
int posL, posR, posB, posT;
OffsetNumber *listL,
*listR,
*listB,
*listT;
BOX *unionL,
*unionR,
*unionB,
*unionT;
int posL,
posR,
posB,
posT;
BOX pageunion;
BOX *cur;
char direction = ' ';
@ -185,16 +198,29 @@ gbox_picksplit(PG_FUNCTION_ARGS)
memcpy((void *) &pageunion, (void *) cur, sizeof(BOX));
/* find MBR */
for (i = OffsetNumberNext(FirstOffsetNumber); i <= maxoff; i = OffsetNumberNext(i)) {
for (i = OffsetNumberNext(FirstOffsetNumber); i <= maxoff; i = OffsetNumberNext(i))
{
cur = DatumGetBoxP(((GISTENTRY *) VARDATA(entryvec))[i].key);
if (pageunion.high.x < cur->high.x)
{ allisequal=false; pageunion.high.x = cur->high.x; }
{
allisequal = false;
pageunion.high.x = cur->high.x;
}
if (pageunion.low.x > cur->low.x)
{ allisequal=false; pageunion.low.x = cur->low.x; }
{
allisequal = false;
pageunion.low.x = cur->low.x;
}
if (pageunion.high.y < cur->high.y)
{ allisequal=false; pageunion.high.y = cur->high.y; }
{
allisequal = false;
pageunion.high.y = cur->high.y;
}
if (pageunion.low.y > cur->low.y)
{ allisequal=false; pageunion.low.y = cur->low.y; }
{
allisequal = false;
pageunion.low.y = cur->low.y;
}
}
nbytes = (maxoff + 2) * sizeof(OffsetNumber);
@ -202,20 +228,26 @@ gbox_picksplit(PG_FUNCTION_ARGS)
listR = (OffsetNumber *) palloc(nbytes);
unionL = (BOX *) palloc(sizeof(BOX));
unionR = (BOX *) palloc(sizeof(BOX));
if ( allisequal ) {
if (allisequal)
{
cur = DatumGetBoxP(((GISTENTRY *) VARDATA(entryvec))[OffsetNumberNext(FirstOffsetNumber)].key);
if ( memcmp( (void*)cur, (void*)&pageunion, sizeof( BOX ) ) == 0 ) {
if (memcmp((void *) cur, (void *) &pageunion, sizeof(BOX)) == 0)
{
v->spl_left = listL;
v->spl_right = listR;
v->spl_nleft = v->spl_nright = 0;
memcpy((void *) unionL, (void *) &pageunion, sizeof(BOX));
memcpy((void *) unionR, (void *) &pageunion, sizeof(BOX));
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) {
if (i <= (maxoff - FirstOffsetNumber + 1)/2) {
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
{
if (i <= (maxoff - FirstOffsetNumber + 1) / 2)
{
v->spl_left[v->spl_nleft] = i;
v->spl_nleft++;
} else {
}
else
{
v->spl_right[v->spl_nright] = i;
v->spl_nright++;
}
@ -245,7 +277,8 @@ gbox_picksplit(PG_FUNCTION_ARGS)
(pos)++; \
} while(0)
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) {
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
{
cur = DatumGetBoxP(((GISTENTRY *) VARDATA(entryvec))[i].key);
if (cur->low.x - pageunion.low.x < pageunion.high.x - cur->high.x)
ADDLIST(listL, unionL, posL);
@ -259,18 +292,20 @@ gbox_picksplit(PG_FUNCTION_ARGS)
/* which split more optimal? */
if ( Max( posL, posR ) < Max( posB, posT ) ) {
if (Max(posL, posR) < Max(posB, posT))
direction = 'x';
} else if ( Max( posL, posR ) > Max( posB, posT ) ) {
else if (Max(posL, posR) > Max(posB, posT))
direction = 'y';
} else {
else
{
Datum interLR = DirectFunctionCall2(rt_box_inter,
BoxPGetDatum(unionL),
BoxPGetDatum(unionR));
Datum interBT = DirectFunctionCall2(rt_box_inter,
BoxPGetDatum(unionB),
BoxPGetDatum(unionT));
float sizeLR, sizeBT;
float sizeLR,
sizeBT;
sizeLR = size_box(interLR);
sizeBT = size_box(interBT);
@ -281,9 +316,12 @@ gbox_picksplit(PG_FUNCTION_ARGS)
direction = 'y';
}
if ( direction == 'x' ) {
pfree( unionB ); pfree( listB );
pfree( unionT ); pfree( listT );
if (direction == 'x')
{
pfree(unionB);
pfree(listB);
pfree(unionT);
pfree(listT);
v->spl_left = listL;
v->spl_right = listR;
@ -291,9 +329,13 @@ gbox_picksplit(PG_FUNCTION_ARGS)
v->spl_nright = posR;
v->spl_ldatum = BoxPGetDatum(unionL);
v->spl_rdatum = BoxPGetDatum(unionR);
} else {
pfree( unionR ); pfree( listR );
pfree( unionL ); pfree( listL );
}
else
{
pfree(unionR);
pfree(listR);
pfree(unionL);
pfree(listL);
v->spl_left = listB;
v->spl_right = listT;
@ -315,6 +357,7 @@ gbox_same(PG_FUNCTION_ARGS)
BOX *b1 = (BOX *) PG_GETARG_POINTER(0);
BOX *b2 = (BOX *) PG_GETARG_POINTER(1);
bool *result = (bool *) PG_GETARG_POINTER(2);
if (b1 && b2)
*result = DatumGetBool(DirectFunctionCall2(box_same, PointerGetDatum(b1), PointerGetDatum(b2)));
else
@ -332,7 +375,8 @@ gbox_leaf_consistent(BOX *key,
{
bool retval;
switch(strategy) {
switch (strategy)
{
case RTLeftStrategyNumber:
retval = DatumGetBool(DirectFunctionCall2(box_left, PointerGetDatum(key), PointerGetDatum(query)));
break;
@ -364,14 +408,17 @@ gbox_leaf_consistent(BOX *key,
}
static float
size_box( Datum box ) {
if ( DatumGetPointer(box) != NULL ) {
size_box(Datum box)
{
if (DatumGetPointer(box) != NULL)
{
float size;
DirectFunctionCall2(rt_box_size,
box, PointerGetDatum(&size));
return size;
} else
}
else
return 0.0;
}
@ -385,11 +432,14 @@ gpoly_compress(PG_FUNCTION_ARGS)
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
GISTENTRY *retval;
if ( entry->leafkey) {
if (entry->leafkey)
{
retval = palloc(sizeof(GISTENTRY));
if ( DatumGetPointer(entry->key) != NULL ) {
if (DatumGetPointer(entry->key) != NULL)
{
POLYGON *in;
BOX *r;
in = (POLYGON *) PG_DETOAST_DATUM(entry->key);
r = (BOX *) palloc(sizeof(BOX));
memcpy((void *) r, (void *) &(in->boundbox), sizeof(BOX));
@ -400,14 +450,16 @@ gpoly_compress(PG_FUNCTION_ARGS)
entry->rel, entry->page,
entry->offset, sizeof(BOX), FALSE);
} else {
}
else
{
gistentryinit(*retval, (Datum) 0,
entry->rel, entry->page,
entry->offset, 0, FALSE);
}
} else {
retval = entry;
}
else
retval = entry;
PG_RETURN_POINTER(retval);
}
@ -420,8 +472,8 @@ gpoly_consistent(PG_FUNCTION_ARGS)
bool result;
/*
** if entry is not leaf, use gbox_internal_consistent,
** else use gbox_leaf_consistent
* * if entry is not leaf, use gbox_internal_consistent, * else use
* gbox_leaf_consistent
*/
if (!(DatumGetPointer(entry->key) != NULL && query))
PG_RETURN_BOOL(FALSE);
@ -444,7 +496,8 @@ rtree_internal_consistent(BOX *key,
{
bool retval;
switch(strategy) {
switch (strategy)
{
case RTLeftStrategyNumber:
case RTOverLeftStrategyNumber:
retval = DatumGetBool(DirectFunctionCall2(box_overleft, PointerGetDatum(key), PointerGetDatum(query)));

6
contrib/seg/seg.c
View File

@ -138,7 +138,6 @@ seg_out(SEG * seg)
if (seg->lower == seg->upper && seg->l_ext == seg->u_ext)
{
/*
* indicates that this interval was built by seg_in off a single
* point
@ -219,7 +218,6 @@ gseg_consistent(GISTENTRY *entry,
SEG * query,
StrategyNumber strategy)
{
/*
* * if entry is not leaf, use gseg_internal_consistent, * else use
* gseg_leaf_consistent
@ -415,7 +413,6 @@ gseg_picksplit(bytea *entryvec,
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
@ -757,7 +754,6 @@ seg_size(SEG * a)
int32
seg_cmp(SEG * a, SEG * b)
{
/*
* First compare on lower boundary position
*/
@ -968,7 +964,6 @@ restore(char *result, float val, int n)
{
if (abs(exp) <= 4)
{
/*
* remove the decimal point from the mantyssa and write the
* digits to the buf array
@ -989,7 +984,6 @@ restore(char *result, float val, int n)
{
if (dp - 10 + exp >= n)
{
/*
* the decimal point is behind the last significant
* digit; the digits in between must be converted to

1
contrib/spi/refint.c
View File

@ -537,7 +537,6 @@ check_foreign_key(PG_FUNCTION_ARGS)
*/
for (r = 0; r < nrefs; r++)
{
/*
* For 'R'estrict we may to execute plan for one tuple only, for
* other actions - for all tuples.

1
contrib/string/string_io.c
View File

@ -359,7 +359,6 @@ c_charin(unsigned char *str)
{
return (string_input(str, 1, 0, NULL));
}
#endif
/* end of file */

1
contrib/string/string_io.h
View File

@ -13,7 +13,6 @@ struct varlena *c_textin(unsigned char *str);
int32 *
c_charin(unsigned char *str)
#endif
#endif
/*

10
contrib/tsearch/crc32.c
View File

@ -87,15 +87,17 @@ static const unsigned int crc32tab[256] = {
0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d,
};
unsigned int crc32_sz(char * buf, int size){
unsigned int
crc32_sz(char *buf, int size)
{
unsigned int crc = ~0;
char *p;
int len, nr;
int len,
nr;
len = 0;
nr = size;
for (len += nr, p = buf; nr--; ++p) {
for (len += nr, p = buf; nr--; ++p)
_CRC32_(crc, *p);
}
return ~crc;
}

1
contrib/tsearch/crc32.h
View File

@ -6,5 +6,4 @@ extern unsigned int crc32_sz(char * buf, int size);
/* Returns crc32 of null-terminated string */
#define crc32(buf) crc32_sz((buf),strlen(buf))
#endif

2
contrib/tsearch/deflex.h
View File

@ -25,6 +25,4 @@
#define FILEPATH 19
extern const char *descr[];
#endif

7
contrib/tsearch/gistidx.h
View File

@ -9,7 +9,8 @@
* signature defines
*/
#define BITBYTE 8
#define SIGLENINT 64 /* >121 => key will toast, so it will not work !!! */
#define SIGLENINT 64 /* >121 => key will toast, so it will not
* work !!! */
#define SIGLEN ( sizeof(int4)*SIGLENINT )
#define SIGLENBIT (SIGLEN*BITBYTE)
@ -40,7 +41,8 @@ typedef char *BITVECP;
/*
* type of index key
*/
typedef struct {
typedef struct
{
int4 len;
int4 flag;
char data[1];
@ -61,4 +63,3 @@ typedef struct {
#define GETARR(x) ( (int4*)( (char*)x+GTHDRSIZE ) )
#define ARRNELEM(x) ( ( ((GISTTYPE*)x)->len - GTHDRSIZE )/sizeof(int4) )
#endif

66
contrib/tsearch/morph.c
View File

@ -23,7 +23,8 @@
* Return value of init must be malloced in other case
* it will be free in end of transaction!
*/
typedef struct {
typedef struct
{
char localename[LOCALE_NAME_BUFLEN];
/* init dictionary */
void *(*init) (void);
@ -48,10 +49,12 @@ DICT dicts[] = {
}
#include "dict.h"
};
#undef DICT_TABLE
/* array for storing dictinary's objects (if needed) */
void* dictobjs[ lengthof(dicts) ];
void *dictobjs[
lengthof(dicts)];
#define STOPLEXEM -2
#define BYLOCALE -1
@ -60,6 +63,7 @@ void* dictobjs[ lengthof(dicts) ];
#define MAXNDICT 2
typedef int2 MAPDICT[MAXNDICT];
#define GETDICT(x,i) *( ((int2*)(x)) + (i) )
/* map dictionaries for lexem type */
@ -88,38 +92,48 @@ static MAPDICT mapdict[] = {
static bool inited = false;
void initmorph(void) {
int i,j,k;
void
initmorph(void)
{
int i,
j,
k;
MAPDICT *md;
bool needinit[lengthof(dicts)];
#ifdef USE_LOCALE
PG_LocaleCategories lc;
int bylocaledict = NODICT;
#endif
if ( inited ) return;
if (inited)
return;
for (i = 1; i < lengthof(dicts); i++)
needinit[i] = false;
#ifdef USE_LOCALE
PGLC_current(&lc);
for (i = 1; i < lengthof(dicts); i++)
if (strcmp( dicts[i].localename, lc.lang ) == 0) {
if (strcmp(dicts[i].localename, lc.lang) == 0)
{
bylocaledict = i;
break;
}
PGLC_free_categories(&lc);
#endif
for(i=1; i<lengthof(mapdict);i++) {
for (i = 1; i < lengthof(mapdict); i++)
{
k = 0;
md = &mapdict[i];
for(j=0;j<MAXNDICT;j++) {
for (j = 0; j < MAXNDICT; j++)
{
GETDICT(md, k) = GETDICT(md, j);
if ( GETDICT(md,k) == NODICT ) {
if (GETDICT(md, k) == NODICT)
break;
} else if ( GETDICT(md,k) == BYLOCALE ) {
else if (GETDICT(md, k) == BYLOCALE)
{
#ifdef USE_LOCALE
if (bylocaledict == NODICT)
continue;
@ -146,30 +160,42 @@ void initmorph(void) {
return;
}
char* lemmatize( char* word, int *len, int type ) {
char *
lemmatize(char *word, int *len, int type)
{
int2 nd;
int i;
DICT *dict;
for(i=0;i<MAXNDICT;i++) {
for (i = 0; i < MAXNDICT; i++)
{
nd = GETDICT(&mapdict[type], i);
if ( nd == NODICT ) {
if (nd == NODICT)
{
/* there is no dictionary */
return word;
} else if ( nd == STOPLEXEM ) {
}
else if (nd == STOPLEXEM)
{
/* word is stopword */
return NULL;
} else {
}
else
{
dict = &dicts[nd];
if (dict->is_stoplemm && (*(dict->is_stoplemm)) (dictobjs[nd], word, *len))
return NULL;
if ( dict->lemmatize ) {
if (dict->lemmatize)
{
int oldlen = *len;
char *newword = (*(dict->lemmatize)) (dictobjs[nd], word, len);
/* word is recognized by distionary */
if ( newword != word || *len != oldlen ) {
if (newword != word || *len != oldlen)
{
if (dict->is_stemstoplemm &&
(*(dict->is_stemstoplemm))(dictobjs[nd], word, *len) ) {
(*(dict->is_stemstoplemm)) (dictobjs[nd], word, *len))
{
if (newword != word && newword)
pfree(newword);
return NULL;
@ -183,6 +209,8 @@ char* lemmatize( char* word, int *len, int type ) {
return word;
}
bool is_stoptype(int type) {
bool
is_stoptype(int type)
{
return (GETDICT(&mapdict[type], 0) == STOPLEXEM) ? true : false;
}

1
contrib/tsearch/parser.h
View File

@ -7,5 +7,4 @@ int tsearch_yylex(void);
void start_parse_str(char *, int);
void start_parse_fh(FILE *, int);
void end_parse(void);
#endif

256
contrib/tsearch/query.c
View File

@ -32,13 +32,16 @@
PG_FUNCTION_INFO_V1(mqtxt_in);
Datum mqtxt_in(PG_FUNCTION_ARGS);
PG_FUNCTION_INFO_V1(qtxt_in);
Datum qtxt_in(PG_FUNCTION_ARGS);
PG_FUNCTION_INFO_V1(qtxt_out);
Datum qtxt_out(PG_FUNCTION_ARGS);
PG_FUNCTION_INFO_V1(execqtxt);
Datum execqtxt(PG_FUNCTION_ARGS);
PG_FUNCTION_INFO_V1(rexecqtxt);
Datum rexecqtxt(PG_FUNCTION_ARGS);
@ -62,7 +65,8 @@ Datum querytree(PG_FUNCTION_ARGS);
* node of query tree, also used
* for storing polish notation in parser
*/
typedef struct NODE {
typedef struct NODE
{
int4 type;
int4 val;
int2 distance;
@ -70,7 +74,8 @@ typedef struct NODE {
struct NODE *next;
} NODE;
typedef struct {
typedef struct
{
char *buf;
int4 state;
int4 count;
@ -93,43 +98,57 @@ typedef struct {
* get token from query string
*/
static int4
gettoken_query( QPRS_STATE* state, int4* val, int4* lenval, char** strval ) {
while(1) {
switch(state->state) {
gettoken_query(QPRS_STATE * state, int4 *val, int4 *lenval, char **strval)
{
while (1)
{
switch (state->state)
{
case WAITOPERAND:
if ( *(state->buf) == '!' ) {
if (*(state->buf) == '!')
{
(state->buf)++;
*val = (int4) '!';
return OPR;
} else if ( *(state->buf) == '(' ) {
}
else if (*(state->buf) == '(')
{
state->count++;
(state->buf)++;
return OPEN;
} else if ( *(state->buf) != ' ' ) {
}
else if (*(state->buf) != ' ')
{
state->valstate.prsbuf = state->buf;
state->state = WAITOPERATOR;
if ( gettoken_txtidx( &(state->valstate) ) ) {
if (gettoken_txtidx(&(state->valstate)))
{
*strval = state->valstate.word;
*lenval = state->valstate.curpos - state->valstate.word;
state->buf = state->valstate.prsbuf;
return VAL;
} else
}
else
elog(ERROR, "No operand");
}
break;
case WAITOPERATOR:
if ( *(state->buf) == '&' || *(state->buf) == '|' ) {
if (*(state->buf) == '&' || *(state->buf) == '|')
{
state->state = WAITOPERAND;
*val = (int4) *(state->buf);
(state->buf)++;
return OPR;
} else if ( *(state->buf) == ')' ) {
}
else if (*(state->buf) == ')')
{
(state->buf)++;
state->count--;
return (state->count < 0) ? ERR : CLOSE;
} else if ( *(state->buf) == '\0' ) {
}
else if (*(state->buf) == '\0')
return (state->count) ? ERR : END;
} else if ( *(state->buf) != ' ' )
else if (*(state->buf) != ' ')
return ERR;
break;
default:
@ -145,8 +164,10 @@ gettoken_query( QPRS_STATE* state, int4* val, int4* lenval, char** strval ) {
* push new one in polish notation reverse view
*/
static void
pushquery( QPRS_STATE *state, int4 type, int4 val, int4 distance, int4 lenval) {
pushquery(QPRS_STATE * state, int4 type, int4 val, int4 distance, int4 lenval)
{
NODE *tmp = (NODE *) palloc(sizeof(NODE));
tmp->type = type;
tmp->val = val;
if (distance > 0xffff)
@ -164,15 +185,18 @@ pushquery( QPRS_STATE *state, int4 type, int4 val, int4 distance, int4 lenval) {
* This function is used for query_txt parsing
*/
static void
pushval_asis(QPRS_STATE *state, int type, char* strval, int lenval) {
pushval_asis(QPRS_STATE * state, int type, char *strval, int lenval)
{
if (lenval > 0xffff)
elog(ERROR, "Word is too long");
pushquery(state, type, crc32_sz((uint8 *) strval, lenval),
state->curop - state->op, lenval);
while ( state->curop - state->op + lenval + 1 >= state->lenop ) {
while (state->curop - state->op + lenval + 1 >= state->lenop)
{
int4 tmp = state->curop - state->op;
state->lenop *= 2;
state->op = (char *) repalloc((void *) state->op, state->lenop);
state->curop = state->op + tmp;
@ -189,25 +213,31 @@ pushval_asis(QPRS_STATE *state, int type, char* strval, int lenval) {
* This function is used for mquery_txt parsing
*/
static void
pushval_morph(QPRS_STATE *state, int typeval, char* strval, int lenval) {
int4 type, lenlemm;
pushval_morph(QPRS_STATE * state, int typeval, char *strval, int lenval)
{
int4 type,
lenlemm;
int4 count = 0;
char *lemm;
start_parse_str(strval, lenval);
while( (type=tsearch_yylex()) != 0 ) {
if ( tokenlen>0xffff ) {
while ((type = tsearch_yylex()) != 0)
{
if (tokenlen > 0xffff)
{
end_parse();
elog(ERROR, "Word is too long");
}
lenlemm = tokenlen;
lemm = lemmatize(token, &lenlemm, type);
if ( lemm ) {
if (lemm)
{
pushval_asis(state, VAL, lemm, lenlemm);
if ( lemm != token ) pfree(lemm);
} else {
pushval_asis(state,VALTRUE,0,0);
if (lemm != token)
pfree(lemm);
}
else
pushval_asis(state, VALTRUE, 0, 0);
if (count)
pushquery(state, OPR, (int4) '&', 0, 0);
count++;
@ -220,27 +250,33 @@ pushval_morph(QPRS_STATE *state, int typeval, char* strval, int lenval) {
* make polish notaion of query
*/
static int4
makepol(QPRS_STATE *state, void (*pushval)(QPRS_STATE*,int,char*,int)) {
int4 val,type;
makepol(QPRS_STATE * state, void (*pushval) (QPRS_STATE *, int, char *, int))
{
int4 val,
type;
int4 lenval;
char *strval;
int4 stack[STACKDEPTH];
int4 lenstack = 0;
while( (type=gettoken_query(state, &val, &lenval, &strval))!=END ) {
switch(type) {
while ((type = gettoken_query(state, &val, &lenval, &strval)) != END)
{
switch (type)
{
case VAL:
(*pushval) (state, VAL, strval, lenval);
while (lenstack && (stack[lenstack - 1] == (int4) '&' ||
stack[ lenstack-1 ] == (int4)'!') ) {
stack[lenstack - 1] == (int4) '!'))
{
lenstack--;
pushquery(state, OPR, stack[lenstack], 0, 0);
}
break;
case OPR:
if ( lenstack && val == (int4) '|' ) {
if (lenstack && val == (int4) '|')
pushquery(state, OPR, val, 0, 0);
} else {
else
{
if (lenstack == STACKDEPTH)
elog(ERROR, "Stack too short");
stack[lenstack] = val;
@ -248,15 +284,18 @@ makepol(QPRS_STATE *state, void (*pushval)(QPRS_STATE*,int,char*,int)) {
}
break;
case OPEN:
if ( makepol( state, pushval ) == ERR ) return ERR;
if (makepol(state, pushval) == ERR)
return ERR;
if (lenstack && (stack[lenstack - 1] == (int4) '&' ||
stack[ lenstack-1 ] == (int4)'!') ) {
stack[lenstack - 1] == (int4) '!'))
{
lenstack--;
pushquery(state, OPR, stack[lenstack], 0, 0);
}
break;
case CLOSE:
while ( lenstack ) {
while (lenstack)
{
lenstack--;
pushquery(state, OPR, stack[lenstack], 0, 0);
};
@ -269,14 +308,16 @@ makepol(QPRS_STATE *state, void (*pushval)(QPRS_STATE*,int,char*,int)) {
}
}
while (lenstack) {
while (lenstack)
{
lenstack--;
pushquery(state, OPR, stack[lenstack], 0, 0);
};
return END;
}
typedef struct {
typedef struct
{
WordEntry *arrb;
WordEntry *arre;
char *values;
@ -287,7 +328,8 @@ typedef struct {
* compare 2 string values
*/
static int4
ValCompare( CHKVAL *chkval, WordEntry *ptr, ITEM *item ) {
ValCompare(CHKVAL * chkval, WordEntry * ptr, ITEM * item)
{
if (ptr->len == item->length)
return strncmp(
&(chkval->values[ptr->pos]),
@ -301,7 +343,8 @@ ValCompare( CHKVAL *chkval, WordEntry *ptr, ITEM *item ) {
* is there value 'val' in array or not ?
*/
static bool
checkcondition_str( void *checkval, ITEM* val ) {
checkcondition_str(void *checkval, ITEM * val)
{
WordEntry *StopLow = ((CHKVAL *) checkval)->arrb;
WordEntry *StopHigh = ((CHKVAL *) checkval)->arre;
WordEntry *StopMiddle;
@ -309,7 +352,8 @@ checkcondition_str( void *checkval, ITEM* val ) {
/* Loop invariant: StopLow <= val < StopHigh */
while (StopLow < StopHigh) {
while (StopLow < StopHigh)
{
StopMiddle = StopLow + (StopHigh - StopLow) / 2;
difference = ValCompare((CHKVAL *) checkval, StopMiddle, val);
if (difference == 0)
@ -327,19 +371,25 @@ checkcondition_str( void *checkval, ITEM* val ) {
* check for boolean condition
*/
bool
execute( ITEM* curitem, void *checkval, bool calcnot, bool (*chkcond)(void *checkval, ITEM *val )) {
if ( curitem->type == VAL ) {
execute(ITEM * curitem, void *checkval, bool calcnot, bool (*chkcond) (void *checkval, ITEM * val))
{
if (curitem->type == VAL)
return (*chkcond) (checkval, curitem);
} else if ( curitem->val == (int4)'!' ) {
else if (curitem->val == (int4) '!')
{
return (calcnot) ?
((execute(curitem + 1, checkval, calcnot, chkcond)) ? false : true)
: true;
} else if ( curitem->val == (int4)'&' ) {
}
else if (curitem->val == (int4) '&')
{
if (execute(curitem + curitem->left, checkval, calcnot, chkcond))
return execute(curitem + 1, checkval, calcnot, chkcond);
else
return false;
} else { /* |-operator */
}
else
{ /* |-operator */
if (execute(curitem + curitem->left, checkval, calcnot, chkcond))
return true;
else
@ -352,7 +402,8 @@ execute( ITEM* curitem, void *checkval, bool calcnot, bool (*chkcond)(void *chec
* boolean operations
*/
Datum
rexecqtxt(PG_FUNCTION_ARGS) {
rexecqtxt(PG_FUNCTION_ARGS)
{
return DirectFunctionCall2(
execqtxt,
PG_GETARG_DATUM(1),
@ -361,13 +412,15 @@ rexecqtxt(PG_FUNCTION_ARGS) {
}
Datum
execqtxt(PG_FUNCTION_ARGS) {
execqtxt(PG_FUNCTION_ARGS)
{
txtidx *val = (txtidx *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0)));
QUERYTYPE *query = (QUERYTYPE *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(1)));
CHKVAL chkval;
bool result;
if ( ! val->size ) {
if (!val->size)
{
PG_FREE_IF_COPY(val, 0);
PG_FREE_IF_COPY(query, 1);
PG_RETURN_BOOL(false);
@ -393,21 +446,28 @@ execqtxt(PG_FUNCTION_ARGS) {
* find left operand in polish notation view
*/
static void
findoprnd( ITEM *ptr, int4 *pos ) {
findoprnd(ITEM * ptr, int4 *pos)
{
#ifdef BS_DEBUG
elog(NOTICE, (ptr[*pos].type == OPR) ?
"%d %c" : "%d %d ", *pos, ptr[*pos].val);
#endif
if ( ptr[*pos].type == VAL || ptr[*pos].type == VALTRUE ) {
if (ptr[*pos].type == VAL || ptr[*pos].type == VALTRUE)
{
ptr[*pos].left = 0;
(*pos)++;
} else if ( ptr[*pos].val == (int4)'!' ) {
}
else if (ptr[*pos].val == (int4) '!')
{
ptr[*pos].left = 1;
(*pos)++;
findoprnd(ptr, pos);
} else {
}
else
{
ITEM *curitem = &ptr[*pos];
int4 tmp = *pos;
(*pos)++;
findoprnd(ptr, pos);
curitem->left = *pos - tmp;
@ -419,7 +479,9 @@ findoprnd( ITEM *ptr, int4 *pos ) {
/*
* input
*/
static QUERYTYPE *queryin(char *buf, void (*pushval)(QPRS_STATE*,int,char*,int) ) {
static QUERYTYPE *
queryin(char *buf, void (*pushval) (QPRS_STATE *, int, char *, int))
{
QPRS_STATE state;
int4 i;
QUERYTYPE *query;
@ -427,8 +489,10 @@ static QUERYTYPE *queryin(char *buf, void (*pushval)(QPRS_STATE*,int,char*,int)
ITEM *ptr;
NODE *tmp;
int4 pos = 0;
#ifdef BS_DEBUG
char pbuf[16384],*cur;
char pbuf[16384],
*cur;
#endif
/* init state */
@ -463,7 +527,8 @@ static QUERYTYPE *queryin(char *buf, void (*pushval)(QPRS_STATE*,int,char*,int)
ptr = GETQUERY(query);
/* set item in polish notation */
for(i=0; i<state.num; i++ ) {
for (i = 0; i < state.num; i++)
{
ptr[i].type = state.str->type;
ptr[i].val = state.str->val;
ptr[i].distance = state.str->distance;
@ -484,7 +549,8 @@ static QUERYTYPE *queryin(char *buf, void (*pushval)(QPRS_STATE*,int,char*,int)
#ifdef BS_DEBUG
cur = pbuf;
*cur = '\0';
for( i=0;i<query->size;i++ ) {
for (i = 0; i < query->size; i++)
{
if (ptr[i].type == OPR)
sprintf(cur, "%c(%d) ", ptr[i].val, ptr[i].left);
else
@ -501,7 +567,8 @@ static QUERYTYPE *queryin(char *buf, void (*pushval)(QPRS_STATE*,int,char*,int)
* in without morphology
*/
Datum
qtxt_in(PG_FUNCTION_ARGS) {
qtxt_in(PG_FUNCTION_ARGS)
{
PG_RETURN_POINTER(queryin((char *) PG_GETARG_POINTER(0), pushval_asis));
}
@ -509,19 +576,23 @@ qtxt_in(PG_FUNCTION_ARGS) {
* in with morphology
*/
Datum
mqtxt_in(PG_FUNCTION_ARGS) {
mqtxt_in(PG_FUNCTION_ARGS)
{
QUERYTYPE *query;
ITEM *res;
int4 len;
#ifdef BS_DEBUG
ITEM *ptr;
int4 i;
char pbuf[16384],*cur;
char pbuf[16384],
*cur;
#endif
initmorph();
query = queryin((char *) PG_GETARG_POINTER(0), pushval_morph);
res = clean_fakeval(GETQUERY(query), &len);
if ( ! res ) {
if (!res)
{
pfree(query);
PG_RETURN_NULL();
}
@ -530,7 +601,8 @@ mqtxt_in(PG_FUNCTION_ARGS) {
cur = pbuf;
*cur = '\0';
ptr = GETQUERY(query);
for( i=0;i<len;i++ ) {
for (i = 0; i < len; i++)
{
if (ptr[i].type == OPR)
sprintf(cur, "%c(%d) ", ptr[i].val, ptr[i].left);
else
@ -547,7 +619,8 @@ mqtxt_in(PG_FUNCTION_ARGS) {
/*
* out function
*/
typedef struct {
typedef struct
{
ITEM *curpol;
char *buf;
char *cur;
@ -569,46 +642,63 @@ while( ( inf->cur - inf->buf ) + addsize + 1 >= inf->buflen ) \
* infix (human-readable) view
*/
static void
infix(INFIX *in, bool first) {
if ( in->curpol->type == VAL ) {
infix(INFIX * in, bool first)
{
if (in->curpol->type == VAL)
{
char *op = in->op + in->curpol->distance;
RESIZEBUF(in, in->curpol->length * 2 + 2);
*(in->cur) = '\''; in->cur++;
while( *op ) {
if ( *op == '\'' ) {
*(in->cur) = '\\'; in->cur++;
*(in->cur) = '\'';
in->cur++;
while (*op)
{
if (*op == '\'')
{
*(in->cur) = '\\';
in->cur++;
}
*(in->cur) = *op;
op++; in->cur++;
op++;
in->cur++;
}
*(in->cur) = '\''; in->cur++;
*(in->cur) = '\'';
in->cur++;
*(in->cur) = '\0';
in->curpol++;
} else if ( in->curpol->val == (int4)'!' ) {
}
else if (in->curpol->val == (int4) '!')
{
bool isopr = false;
RESIZEBUF(in, 1);
*(in->cur) = '!';
in->cur++;
*(in->cur) = '\0';
in->curpol++;
if ( in->curpol->type == OPR ) {
if (in->curpol->type == OPR)
{
isopr = true;
RESIZEBUF(in, 2);
sprintf(in->cur, "( ");
in->cur = strchr(in->cur, '\0');
}
infix(in, isopr);
if ( isopr ) {
if (isopr)
{
RESIZEBUF(in, 2);
sprintf(in->cur, " )");
in->cur = strchr(in->cur, '\0');
}
} else {
}
else
{
int4 op = in->curpol->val;
INFIX nrm;
in->curpol++;
if ( op == (int4)'|' && ! first) {
if (op == (int4) '|' && !first)
{
RESIZEBUF(in, 2);
sprintf(in->cur, "( ");
in->cur = strchr(in->cur, '\0');
@ -632,7 +722,8 @@ infix(INFIX *in, bool first) {
in->cur = strchr(in->cur, '\0');
pfree(nrm.buf);
if ( op == (int4)'|' && ! first) {
if (op == (int4) '|' && !first)
{
RESIZEBUF(in, 2);
sprintf(in->cur, " )");
in->cur = strchr(in->cur, '\0');
@ -642,7 +733,8 @@ infix(INFIX *in, bool first) {
Datum
qtxt_out(PG_FUNCTION_ARGS) {
qtxt_out(PG_FUNCTION_ARGS)
{
QUERYTYPE *query = (QUERYTYPE *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0)));
INFIX nrm;
@ -664,7 +756,8 @@ qtxt_out(PG_FUNCTION_ARGS) {
* which will be executed in non-leaf pages in index
*/
Datum
querytree(PG_FUNCTION_ARGS) {
querytree(PG_FUNCTION_ARGS)
{
QUERYTYPE *query = (QUERYTYPE *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0)));
INFIX nrm;
text *res;
@ -677,11 +770,14 @@ querytree(PG_FUNCTION_ARGS) {
q = clean_NOT(GETQUERY(query), &len);
if ( ! q ) {
if (!q)
{
res = (text *) palloc(1 + VARHDRSZ);
VARATT_SIZEP(res) = 1 + VARHDRSZ;
*((char *) VARDATA(res)) = 'T';
} else {
}
else
{
nrm.curpol = q;
nrm.buflen = 32;
nrm.cur = nrm.buf = (char *) palloc(sizeof(char) * nrm.buflen);

6
contrib/tsearch/query.h
View File

@ -9,7 +9,8 @@
* item in polish notation with back link
* to left operand
*/
typedef struct ITEM {
typedef struct ITEM
{
int2 type;
int2 left;
int4 val;
@ -22,7 +23,8 @@ typedef struct ITEM {
*Storage:
* (len)(size)(array of ITEM)(array of operand in user-friendly form)
*/
typedef struct {
typedef struct
{
int4 len;
int4 size;
char data[1];

148
contrib/tsearch/rewrite.c
View File

@ -19,7 +19,8 @@
#include "query.h"
#include "rewrite.h"
typedef struct NODE {
typedef struct NODE
{
struct NODE *left;
struct NODE *right;
ITEM *valnode;
@ -29,11 +30,14 @@ typedef struct NODE {
* make query tree from plain view of query
*/
static NODE *
maketree(ITEM *in) {
maketree(ITEM * in)
{
NODE *node = (NODE *) palloc(sizeof(NODE));
node->valnode = in;
node->right = node->left = NULL;
if ( in->type == OPR ) {
if (in->type == OPR)
{
node->right = maketree(in + 1);
if (in->val != (int4) '!')
node->left = maketree(in + in->left);
@ -41,27 +45,34 @@ maketree(ITEM *in) {
return node;
}
typedef struct {
typedef struct
{
ITEM *ptr;
int4 len;
int4 cur;
} PLAINTREE;
static void
plainnode(PLAINTREE *state, NODE* node) {
if ( state->cur == state->len ) {
plainnode(PLAINTREE * state, NODE * node)
{
if (state->cur == state->len)
{
state->len *= 2;
state->ptr = (ITEM *) repalloc((void *) state->ptr, state->len * sizeof(ITEM));
}
memcpy((void *) &(state->ptr[state->cur]), (void *) node->valnode, sizeof(ITEM));
if ( node->valnode->type == VAL ) {
if (node->valnode->type == VAL)
state->cur++;
} else if ( node->valnode->val == (int4)'!' ) {
else if (node->valnode->val == (int4) '!')
{
state->ptr[state->cur].left = 1;
state->cur++;
plainnode(state, node->right);
} else {
}
else
{
int4 cur = state->cur;
state->cur++;
plainnode(state, node->right);
state->ptr[cur].left = state->cur - cur;
@ -74,25 +85,32 @@ plainnode(PLAINTREE *state, NODE* node) {
* make plain view of tree from 'normal' view of tree
*/
static ITEM *
plaintree(NODE *root, int4 *len) {
plaintree(NODE * root, int4 *len)
{
PLAINTREE pl;
pl.cur = 0;
pl.len = 16;
if ( root && (root->valnode->type == VAL || root->valnode->type == OPR) ) {
if (root && (root->valnode->type == VAL || root->valnode->type == OPR))
{
pl.ptr = (ITEM *) palloc(pl.len * sizeof(ITEM));
plainnode(&pl, root);
} else {
pl.ptr = NULL;
}
else
pl.ptr = NULL;
*len = pl.cur;
return pl.ptr;
}
static void
freetree(NODE *node) {
if ( !node ) return;
if ( node->left ) freetree(node->left);
if ( node->right ) freetree(node->right);
freetree(NODE * node)
{
if (!node)
return;
if (node->left)
freetree(node->left);
if (node->right)
freetree(node->right);
pfree(node);
}
@ -103,33 +121,45 @@ freetree(NODE *node) {
* Operator ! always return TRUE
*/
static NODE *
clean_NOT_intree( NODE* node ) {
clean_NOT_intree(NODE * node)
{
if (node->valnode->type == VAL)
return node;
if ( node->valnode->val == (int4)'!' ) {
if (node->valnode->val == (int4) '!')
{
freetree(node);
return NULL;
}
/* operator & or | */
if ( node->valnode->val == (int4)'|' ) {
if (node->valnode->val == (int4) '|')
{
if ((node->left = clean_NOT_intree(node->left)) == NULL ||
(node->right=clean_NOT_intree(node->right)) == NULL ) {
(node->right = clean_NOT_intree(node->right)) == NULL)
{
freetree(node);
return NULL;
}
} else {
}
else
{
NODE *res = node;
node->left = clean_NOT_intree(node->left);
node->right = clean_NOT_intree(node->right);
if ( node->left == NULL && node->right == NULL ) {
if (node->left == NULL && node->right == NULL)
{
pfree(node);
res = NULL;
} else if ( node->left == NULL ) {
}
else if (node->left == NULL)
{
res = node->right;
pfree(node);
} else if ( node->right == NULL ) {
}
else if (node->right == NULL)
{
res = node->left;
pfree(node);
}
@ -139,8 +169,10 @@ clean_NOT_intree( NODE* node ) {
}
ITEM *
clean_NOT(ITEM* ptr, int4 *len) {
clean_NOT(ITEM * ptr, int4 *len)
{
NODE *root = maketree(ptr);
return plaintree(clean_NOT_intree(root), len);
}
@ -153,60 +185,86 @@ clean_NOT(ITEM* ptr, int4 *len) {
* text (stopword)
*/
static NODE *
clean_fakeval_intree( NODE* node, char *result ) {
char lresult = V_UNKNOWN, rresult = V_UNKNOWN;
clean_fakeval_intree(NODE * node, char *result)
{
char lresult = V_UNKNOWN,
rresult = V_UNKNOWN;
if (node->valnode->type == VAL)
return node;
else if ( node->valnode->type == VALTRUE ) {
else if (node->valnode->type == VALTRUE)
{
pfree(node);
*result = V_TRUE;
return NULL;
}
if ( node->valnode->val == (int4)'!' ) {
if (node->valnode->val == (int4) '!')
{
node->right = clean_fakeval_intree(node->right, &rresult);
if ( ! node->right ) {
if (!node->right)
{
*result = (rresult == V_TRUE) ? V_FALSE : V_TRUE;
freetree(node);
return NULL;
}
} else if ( node->valnode->val == (int4)'|' ) {
}
else if (node->valnode->val == (int4) '|')
{
NODE *res = node;
node->left = clean_fakeval_intree(node->left, &lresult);
node->right = clean_fakeval_intree(node->right, &rresult);
if ( lresult == V_TRUE || rresult == V_TRUE ) {
if (lresult == V_TRUE || rresult == V_TRUE)
{
freetree(node);
*result = V_TRUE;
return NULL;
} else if ( lresult == V_FALSE && rresult == V_FALSE ) {
}
else if (lresult == V_FALSE && rresult == V_FALSE)
{
freetree(node);
*result = V_FALSE;
return NULL;
} else if ( lresult == V_FALSE ) {
}
else if (lresult == V_FALSE)
{
res = node->right;
pfree(node);
} else if ( rresult == V_FALSE ) {
}
else if (rresult == V_FALSE)
{
res = node->left;
pfree(node);
}
return res;
} else {
}
else
{
NODE *res = node;
node->left = clean_fakeval_intree(node->left, &lresult);
node->right = clean_fakeval_intree(node->right, &rresult);
if ( lresult == V_FALSE || rresult == V_FALSE ) {
if (lresult == V_FALSE || rresult == V_FALSE)
{
freetree(node);
*result = V_FALSE;
return NULL;
} else if ( lresult == V_TRUE && rresult == V_TRUE ) {
}
else if (lresult == V_TRUE && rresult == V_TRUE)
{
freetree(node);
*result = V_TRUE;
return NULL;
} else if ( lresult == V_TRUE ) {
}
else if (lresult == V_TRUE)
{
res = node->right;
pfree(node);
} else if ( rresult == V_TRUE ) {
}
else if (rresult == V_TRUE)
{
res = node->left;
pfree(node);
}
@ -216,13 +274,15 @@ clean_fakeval_intree( NODE* node, char *result ) {
}
ITEM *
clean_fakeval(ITEM* ptr, int4 *len) {
clean_fakeval(ITEM * ptr, int4 *len)
{
NODE *root = maketree(ptr);
char result = V_UNKNOWN;
NODE *resroot;
resroot = clean_fakeval_intree(root, &result);
if ( result != V_UNKNOWN ) {
if (result != V_UNKNOWN)
{
elog(ERROR, "Your query contained only stopword(s), ignored");
*len = 0;
return NULL;
@ -230,5 +290,3 @@ clean_fakeval(ITEM* ptr, int4 *len) {
return plaintree(resroot, len);
}

1
contrib/tsearch/rewrite.h
View File

@ -3,5 +3,4 @@
ITEM *clean_NOT(ITEM * ptr, int4 *len);
ITEM *clean_fakeval(ITEM * ptr, int4 *len);
#endif

237
contrib/tsearch/txtidx.c
View File

@ -28,6 +28,7 @@
PG_FUNCTION_INFO_V1(txtidx_in);
Datum txtidx_in(PG_FUNCTION_ARGS);
PG_FUNCTION_INFO_V1(txtidx_out);
Datum txtidx_out(PG_FUNCTION_ARGS);
@ -45,8 +46,10 @@ Datum txtidxsize(PG_FUNCTION_ARGS);
*/
static char *BufferStr;
static int
compareentry( const void * a, const void * b ) {
if ( ((WordEntry*)a)->len == ((WordEntry*)b)->len ) {
compareentry(const void *a, const void *b)
{
if (((WordEntry *) a)->len == ((WordEntry *) b)->len)
{
return strncmp(
&BufferStr[((WordEntry *) a)->pos],
&BufferStr[((WordEntry *) b)->pos],
@ -56,8 +59,10 @@ compareentry( const void * a, const void * b ) {
}
static int
uniqueentry( WordEntry* a, int4 l, char *buf, int4 *outbuflen ) {
WordEntry *ptr, *res;
uniqueentry(WordEntry * a, int4 l, char *buf, int4 *outbuflen)
{
WordEntry *ptr,
*res;
res = a;
*outbuflen = res->len;
@ -69,9 +74,11 @@ uniqueentry( WordEntry* a, int4 l, char *buf, int4 *outbuflen ) {
qsort((void *) a, l, sizeof(int4), compareentry);
*outbuflen = res->len;
while (ptr - a < l) {
while (ptr - a < l)
{
if (!(ptr->len == res->len &&
strncmp(&buf[ ptr->pos ], &buf[ res->pos ],res->len) == 0 ) ) {
strncmp(&buf[ptr->pos], &buf[res->pos], res->len) == 0))
{
res++;
res->len = ptr->len;
res->pos = ptr->pos;
@ -100,73 +107,97 @@ do { \
} while (0)
int4
gettoken_txtidx( TI_IN_STATE *state ) {
gettoken_txtidx(TI_IN_STATE * state)
{
int4 oldstate = 0;
state->curpos = state->word;
state->state = WAITWORD;
while( 1 ) {
if ( state->state == WAITWORD ) {
if ( *(state->prsbuf) == '\0' ) {
while (1)
{
if (state->state == WAITWORD)
{
if (*(state->prsbuf) == '\0')
return 0;
} else if ( *(state->prsbuf) == '\'' ) {
else if (*(state->prsbuf) == '\'')
state->state = WAITENDCMPLX;
} else if ( *(state->prsbuf) == '\\' ) {
else if (*(state->prsbuf) == '\\')
{
state->state = WAITNEXTCHAR;
oldstate = WAITENDWORD;
} else if ( state->oprisdelim && ISOPERATOR( *(state->prsbuf) ) ) {
}
else if (state->oprisdelim && ISOPERATOR(*(state->prsbuf)))
elog(ERROR, "Syntax error");
} else if ( *(state->prsbuf) != ' ' ) {
else if (*(state->prsbuf) != ' ')
{
*(state->curpos) = *(state->prsbuf);
state->curpos++;
state->state = WAITENDWORD;
}
} else if ( state->state == WAITNEXTCHAR ) {
if ( *(state->prsbuf) == '\0' ) {
}
else if (state->state == WAITNEXTCHAR)
{
if (*(state->prsbuf) == '\0')
elog(ERROR, "There is no escaped character");
} else {
else
{
RESIZEPRSBUF;
*(state->curpos) = *(state->prsbuf);
state->curpos++;
state->state = oldstate;
}
} else if ( state->state == WAITENDWORD ) {
if ( *(state->prsbuf) == '\\' ) {
}
else if (state->state == WAITENDWORD)
{
if (*(state->prsbuf) == '\\')
{
state->state = WAITNEXTCHAR;
oldstate = WAITENDWORD;
} else if ( *(state->prsbuf) == ' ' || *(state->prsbuf) == '\0' ||
( state->oprisdelim && ISOPERATOR( *(state->prsbuf) ) ) ) {
}
else if (*(state->prsbuf) == ' ' || *(state->prsbuf) == '\0' ||
(state->oprisdelim && ISOPERATOR(*(state->prsbuf))))
{
RESIZEPRSBUF;
if (state->curpos == state->word)
elog(ERROR, "Syntax error");
*(state->curpos) = '\0';
return 1;
} else {
}
else
{
RESIZEPRSBUF;
*(state->curpos) = *(state->prsbuf);
state->curpos++;
}
} else if ( state->state == WAITENDCMPLX ) {
if ( *(state->prsbuf) == '\'' ) {
}
else if (state->state == WAITENDCMPLX)
{
if (*(state->prsbuf) == '\'')
{
RESIZEPRSBUF;
*(state->curpos) = '\0';
if (state->curpos == state->word)
elog(ERROR, "Syntax error");
state->prsbuf++;
return 1;
} else if ( *(state->prsbuf) == '\\' ) {
}
else if (*(state->prsbuf) == '\\')
{
state->state = WAITNEXTCHAR;
oldstate = WAITENDCMPLX;
} else if ( *(state->prsbuf) == '\0' ) {
}
else if (*(state->prsbuf) == '\0')
elog(ERROR, "Syntax error");
} else {
else
{
RESIZEPRSBUF;
*(state->curpos) = *(state->prsbuf);
state->curpos++;
}
} else {
elog(ERROR, "Inner bug :(");
}
else
elog(ERROR, "Inner bug :(");
state->prsbuf++;
}
@ -174,14 +205,18 @@ gettoken_txtidx( TI_IN_STATE *state ) {
}
Datum
txtidx_in(PG_FUNCTION_ARGS) {
txtidx_in(PG_FUNCTION_ARGS)
{
char *buf = (char *) PG_GETARG_POINTER(0);
TI_IN_STATE state;
WordEntry *arr;
int4 len=0, totallen = 64;
int4 len = 0,
totallen = 64;
txtidx *in;
char *tmpbuf, *cur;
int4 i,buflen = 256;
char *tmpbuf,
*cur;
int4 i,
buflen = 256;
state.prsbuf = buf;
state.len = 32;
@ -190,13 +225,17 @@ txtidx_in(PG_FUNCTION_ARGS) {
arr = (WordEntry *) palloc(sizeof(WordEntry) * totallen);
cur = tmpbuf = (char *) palloc(buflen);
while( gettoken_txtidx( &state ) ) {
if ( len == totallen ) {
while (gettoken_txtidx(&state))
{
if (len == totallen)
{
totallen *= 2;
arr = (WordEntry *) repalloc((void *) arr, sizeof(int4) * totallen);
}
while ( cur-tmpbuf + state.curpos - state.word >= buflen ) {
while (cur - tmpbuf + state.curpos - state.word >= buflen)
{
int4 dist = cur - tmpbuf;
buflen *= 2;
tmpbuf = (char *) repalloc((void *) tmpbuf, buflen);
cur = tmpbuf + dist;
@ -222,7 +261,8 @@ txtidx_in(PG_FUNCTION_ARGS) {
in->len = totallen;
in->size = len;
cur = STRPTR(in);
for(i=0;i<len;i++) {
for (i = 0; i < len; i++)
{
memcpy((void *) cur, (void *) &tmpbuf[arr[i].pos], arr[i].len);
arr[i].pos = cur - STRPTR(in);
cur += arr[i].len;
@ -234,31 +274,41 @@ txtidx_in(PG_FUNCTION_ARGS) {
}
Datum
txtidxsize(PG_FUNCTION_ARGS) {
txtidxsize(PG_FUNCTION_ARGS)
{
txtidx *in = (txtidx *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0)));
int4 ret = in->size;
PG_FREE_IF_COPY(in, 0);
PG_RETURN_INT32(ret);
}
Datum
txtidx_out(PG_FUNCTION_ARGS) {
txtidx_out(PG_FUNCTION_ARGS)
{
txtidx *out = (txtidx *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0)));
char *outbuf;
int4 i,j,lenbuf = STRSIZE(out) + 1 /* \0 */ + out->size*2 /* '' */ + out->size - 1 /* space */;
int4 i,
j,
lenbuf = STRSIZE(out) + 1 /* \0 */ + out->size * 2 /* '' */ + out->size - 1 /* space */ ;
WordEntry *ptr = ARRPTR(out);
char *curin, *curout;
char *curin,
*curout;
curout = outbuf = (char *) palloc(lenbuf);
for(i=0;i<out->size;i++) {
for (i = 0; i < out->size; i++)
{
curin = STRPTR(out) + ptr->pos;
if (i != 0)
*curout++ = ' ';
*curout++ = '\'';
j = ptr->len;
while( j-- ) {
if ( *curin == '\'' ) {
while (j--)
{
if (*curin == '\'')
{
int4 pos = curout - outbuf;
outbuf = (char *) repalloc((void *) outbuf, ++lenbuf);
curout = outbuf + pos;
*curout++ = '\\';
@ -273,12 +323,14 @@ txtidx_out(PG_FUNCTION_ARGS) {
PG_RETURN_POINTER(outbuf);
}
typedef struct {
typedef struct
{
uint16 len;
char *word;
} WORD;
typedef struct {
typedef struct
{
WORD *words;
int4 lenwords;
int4 curwords;
@ -288,18 +340,24 @@ typedef struct {
* Parse text to lexems
*/
static void
parsetext( PRSTEXT *prs, char *buf, int4 buflen ) {
int type,lenlemm;
char *ptr,*ptrw;
parsetext(PRSTEXT * prs, char *buf, int4 buflen)
{
int type,
lenlemm;
char *ptr,
*ptrw;
char *lemm;
start_parse_str(buf, buflen);
while( (type=tsearch_yylex()) != 0 ) {
if ( prs->curwords == prs->lenwords ) {
while ((type = tsearch_yylex()) != 0)
{
if (prs->curwords == prs->lenwords)
{
prs->lenwords *= 2;
prs->words = (WORD *) repalloc((void *) prs->words, prs->lenwords * sizeof(WORD));
}
if ( tokenlen>0xffff ) {
if (tokenlen > 0xffff)
{
end_parse();
elog(ERROR, "Word is too long");
}
@ -310,16 +368,21 @@ parsetext( PRSTEXT *prs, char *buf, int4 buflen ) {
if (!lemm)
continue;
if ( lemm != token ) {
if (lemm != token)
{
prs->words[prs->curwords].len = lenlemm;
prs->words[prs->curwords].word = lemm;
} else {
}
else
{
prs->words[prs->curwords].len = lenlemm;
ptrw = prs->words[prs->curwords].word = (char *) palloc(lenlemm);
ptr = token;
while( ptr-token < lenlemm ) {
while (ptr - token < lenlemm)
{
*ptrw = tolower((unsigned char) *ptr);
ptr++; ptrw++;
ptr++;
ptrw++;
}
}
prs->curwords++;
@ -328,7 +391,8 @@ parsetext( PRSTEXT *prs, char *buf, int4 buflen ) {
}
static int
compareWORD( const void * a, const void * b ) {
compareWORD(const void *a, const void *b)
{
if (((WORD *) a)->len == ((WORD *) b)->len)
return strncmp(
((WORD *) a)->word,
@ -338,8 +402,10 @@ compareWORD( const void * a, const void * b ) {
}
static int
uniqueWORD( WORD* a, int4 l ) {
WORD *ptr, *res;
uniqueWORD(WORD * a, int4 l)
{
WORD *ptr,
*res;
if (l == 1)
return l;
@ -349,15 +415,17 @@ uniqueWORD( WORD* a, int4 l ) {
qsort((void *) a, l, sizeof(WORD), compareWORD);
while (ptr - a < l) {
while (ptr - a < l)
{
if (!(ptr->len == res->len &&
strncmp(ptr->word, res->word ,res->len) == 0 ) ) {
strncmp(ptr->word, res->word, res->len) == 0))
{
res++;
res->len = ptr->len;
res->word = ptr->word;
} else {
pfree(ptr->word);
}
else
pfree(ptr->word);
ptr++;
}
@ -368,11 +436,15 @@ uniqueWORD( WORD* a, int4 l ) {
* make value of txtidx
*/
static txtidx *
makevalue( PRSTEXT *prs ) {
int4 i, lenstr=0, totallen;
makevalue(PRSTEXT * prs)
{
int4 i,
lenstr = 0,
totallen;
txtidx *in;
WordEntry *ptr;
char *str,*cur;
char *str,
*cur;
prs->curwords = uniqueWORD(prs->words, prs->curwords);
for (i = 0; i < prs->curwords; i++)
@ -385,7 +457,8 @@ makevalue( PRSTEXT *prs ) {
ptr = ARRPTR(in);
cur = str = STRPTR(in);
for(i=0;i<prs->curwords;i++) {
for (i = 0; i < prs->curwords; i++)
{
ptr->len = prs->words[i].len;
if (cur - str > 0xffff)
elog(ERROR, "Value is too big");
@ -400,7 +473,8 @@ makevalue( PRSTEXT *prs ) {
}
Datum
txt2txtidx(PG_FUNCTION_ARGS) {
txt2txtidx(PG_FUNCTION_ARGS)
{
text *in = (text *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0)));
PRSTEXT prs;
txtidx *out = NULL;
@ -413,7 +487,8 @@ txt2txtidx(PG_FUNCTION_ARGS) {
parsetext(&prs, VARDATA(in), VARSIZE(in) - VARHDRSZ);
PG_FREE_IF_COPY(in, 0);
if ( prs.curwords ) {
if (prs.curwords)
{
out = makevalue(&prs);
PG_RETURN_POINTER(out);
}
@ -425,12 +500,14 @@ txt2txtidx(PG_FUNCTION_ARGS) {
* Trigger
*/
Datum
tsearch(PG_FUNCTION_ARGS) {
tsearch(PG_FUNCTION_ARGS)
{
TriggerData *trigdata;
Trigger *trigger;
Relation rel;
HeapTuple rettuple = NULL;
int numidxattr,i;
int numidxattr,
i;
PRSTEXT prs;
Datum datum = (Datum) 0;
@ -467,15 +544,18 @@ tsearch(PG_FUNCTION_ARGS) {
initmorph();
/* find all words in indexable column */
for(i=1; i<trigger->tgnargs; i++) {
for (i = 1; i < trigger->tgnargs; i++)
{
int4 numattr;
text *txt_toasted, *txt;
text *txt_toasted,
*txt;
bool isnull;
Oid oidtype;
numattr = SPI_fnumber(rel->rd_att, trigger->tgargs[i]);
oidtype = SPI_gettypeid(rel->rd_att, numattr);
if ( numattr<0 || ( ! ( oidtype==TEXTOID || oidtype==VARCHAROID ) ) ) {
if (numattr < 0 || (!(oidtype == TEXTOID || oidtype == VARCHAROID)))
{
elog(NOTICE, "TSearch: can not find field '%s'", trigger->tgargs[i]);
continue;
}
@ -490,13 +570,17 @@ tsearch(PG_FUNCTION_ARGS) {
}
/* make txtidx value */
if (prs.curwords) {
if (prs.curwords)
{
datum = PointerGetDatum(makevalue(&prs));
rettuple = SPI_modifytuple(rel, rettuple, 1, &numidxattr,
&datum, NULL);
pfree(DatumGetPointer(datum));
} else {
}
else
{
char nulls = 'n';
pfree(prs.words);
rettuple = SPI_modifytuple(rel, rettuple, 1, &numidxattr,
&datum, &nulls);
@ -507,4 +591,3 @@ tsearch(PG_FUNCTION_ARGS) {
return PointerGetDatum(rettuple);
}

11
contrib/tsearch/txtidx.h
View File

@ -14,12 +14,14 @@
#include "utils/builtins.h"
#include "storage/bufpage.h"
typedef struct {
typedef struct
{
uint16 len;
uint16 pos;
} WordEntry;
typedef struct {
typedef struct
{
int4 len;
int4 size;
char data[1];
@ -31,7 +33,8 @@ typedef struct {
#define STRPTR(x) ( (char*)x + DATAHDRSIZE + ( sizeof(WordEntry) * ((txtidx*)x)->size ) )
#define STRSIZE(x) ( ((txtidx*)x)->len - DATAHDRSIZE - ( sizeof(WordEntry) * ((txtidx*)x)->size ) )
typedef struct {
typedef struct
{
char *prsbuf;
char *word;
char *curpos;
@ -41,6 +44,4 @@ typedef struct {
} TI_IN_STATE;
int4 gettoken_txtidx(TI_IN_STATE * state);
#endif

1
contrib/userlock/user_locks.h
View File

@ -8,7 +8,6 @@ int user_write_unlock(unsigned int id1, unsigned int id2);
int user_write_lock_oid(Oid oid);
int user_write_unlock_oid(Oid oid);
int user_unlock_all(void);
#endif
/*

159
contrib/xml/pgxml.c
View File

@ -14,32 +14,39 @@ XML_Memory_Handling_Suite mhs;
/* passthrough functions (palloc is a macro) */
static void *pgxml_palloc(size_t size)
static void *
pgxml_palloc(size_t size)
{
return palloc(size);
}
static void *pgxml_repalloc(void *ptr, size_t size)
static void *
pgxml_repalloc(void *ptr, size_t size)
{
return repalloc(ptr, size);
}
static void pgxml_pfree(void *ptr)
static void
pgxml_pfree(void *ptr)
{
return pfree(ptr);
}
static void pgxml_mhs_init()
static void
pgxml_mhs_init()
{
mhs.malloc_fcn = pgxml_palloc;
mhs.realloc_fcn = pgxml_repalloc;
mhs.free_fcn = pgxml_pfree;
}
static void pgxml_handler_init()
static void
pgxml_handler_init()
{
/* This code should set up the relevant handlers from user-supplied
settings. Quite how these settings are made is another matter :) */
/*
* This code should set up the relevant handlers from user-supplied
* settings. Quite how these settings are made is another matter :)
*/
}
/* Returns true if document is well-formed */
@ -59,15 +66,19 @@ pgxml_parse(PG_FUNCTION_ARGS)
pgxml_handler_init();
p = XML_ParserCreate_MM(NULL, &mhs, NULL);
if (! p) {
if (!p)
{
elog(ERROR, "pgxml: Could not create expat parser");
PG_RETURN_NULL(); /* seems appropriate if we couldn't parse */
}
if (! XML_Parse(p, (char *)VARDATA(t) , docsize, 1)) {
/* elog(NOTICE, "Parse error at line %d:%s",
XML_GetCurrentLineNumber(p),
XML_ErrorString(XML_GetErrorCode(p))); */
if (!XML_Parse(p, (char *) VARDATA(t), docsize, 1))
{
/*
* elog(NOTICE, "Parse error at line %d:%s",
* XML_GetCurrentLineNumber(p),
* XML_ErrorString(XML_GetErrorCode(p)));
*/
XML_ParserFree(p);
PG_RETURN_BOOL(false);
}
@ -86,7 +97,8 @@ pgxml_parse(PG_FUNCTION_ARGS)
in various ways.
*/
static XPath_Results *build_xpath_results(text *doc, text *pathstr)
static XPath_Results *
build_xpath_results(text *doc, text *pathstr)
{
XPath_Results *xpr;
char *res;
@ -127,7 +139,8 @@ static XPath_Results *build_xpath_results(text *doc, text *pathstr)
pgxml_mhs_init();
p = XML_ParserCreate_MM(NULL, &mhs, NULL);
if (! p) {
if (!p)
{
elog(ERROR, "pgxml: Could not create expat parser");
pfree(xpr);
pfree(udata->path);
@ -142,10 +155,13 @@ static XPath_Results *build_xpath_results(text *doc, text *pathstr)
XML_SetElementHandler(p, pgxml_starthandler, pgxml_endhandler);
XML_SetCharacterDataHandler(p, pgxml_charhandler);
if (! XML_Parse(p, (char *)VARDATA(doc) , docsize, 1)) {
/* elog(NOTICE, "Parse error at line %d:%s",
XML_GetCurrentLineNumber(p),
XML_ErrorString(XML_GetErrorCode(p))); */
if (!XML_Parse(p, (char *) VARDATA(doc), docsize, 1))
{
/*
* elog(NOTICE, "Parse error at line %d:%s",
* XML_GetCurrentLineNumber(p),
* XML_ErrorString(XML_GetErrorCode(p)));
*/
XML_ParserFree(p);
pfree(xpr);
pfree(udata->path);
@ -177,18 +193,16 @@ pgxml_xpath(PG_FUNCTION_ARGS)
xpresults = build_xpath_results(t, t2);
/* This needs to be changed depending on the mechanism for returning
our set of results. */
/*
* This needs to be changed depending on the mechanism for returning
* our set of results.
*/
if (xpresults == NULL) /* parse error (not WF or parser failure) */
{
PG_RETURN_NULL();
}
if (ind >= (xpresults->rescount))
{
PG_RETURN_NULL();
}
restext = (text *) palloc(xpresults->reslens[ind] + VARHDRSZ);
memcpy(VARDATA(restext), xpresults->results[ind], xpresults->reslens[ind]);
@ -202,99 +216,123 @@ pgxml_xpath(PG_FUNCTION_ARGS)
}
static void pgxml_pathcompare(void *userData)
static void
pgxml_pathcompare(void *userData)
{
char *matchpos;
matchpos = strstr(UD->currentpath, UD->path);
if (matchpos == NULL) { /* Should we have more logic here ? */
if (UD->textgrab) {
if (matchpos == NULL)
{ /* Should we have more logic here ? */
if (UD->textgrab)
{
UD->textgrab = 0;
pgxml_finalisegrabbedtext(userData);
}
return;
}
/* OK, we have a match of some sort. Now we need to check that
our match is anchored to the *end* of the string AND
that it is immediately preceded by a '/'*/
/* This test wouldn't work if strlen (UD->path) overran the length
of the currentpath, but that's not possible because we got a match! */
/*
* OK, we have a match of some sort. Now we need to check that our
* match is anchored to the *end* of the string AND that it is
* immediately preceded by a '/'
*/
/*
* This test wouldn't work if strlen (UD->path) overran the length of
* the currentpath, but that's not possible because we got a match!
*/
if ((matchpos + strlen(UD->path))[0] == '\0')
{
if ((UD->path)[0]=='/') {
if (matchpos == UD->currentpath) {
if ((UD->path)[0] == '/')
{
if (matchpos == UD->currentpath)
UD->textgrab = 1;
}
} else {
if ((matchpos-1)[0]=='/') {
else
{
if ((matchpos - 1)[0] == '/')
UD->textgrab = 1;
}
}
}
}
static void pgxml_starthandler(void *userData, const XML_Char *name,
static void
pgxml_starthandler(void *userData, const XML_Char * name,
const XML_Char ** atts)
{
char sepstr[] = "/";
if ((strlen(name)+strlen(UD->currentpath))>MAXPATHLENGTH-2) {
if ((strlen(name) + strlen(UD->currentpath)) > MAXPATHLENGTH - 2)
elog(NOTICE, "Path too long");
} else {
else
{
strncat(UD->currentpath, sepstr, 1);
strcat(UD->currentpath, name);
}
if (UD->textgrab)
{
/* Depending on user preference, should we "reconstitute"
the element into the result text?
/*
* Depending on user preference, should we "reconstitute" the
* element into the result text?
*/
} else {
}
else
pgxml_pathcompare(userData);
}
}
static void pgxml_endhandler(void *userData, const XML_Char *name)
static void
pgxml_endhandler(void *userData, const XML_Char * name)
{
/* Start by removing the current element off the end of the
currentpath */
/*
* Start by removing the current element off the end of the
* currentpath
*/
char *sepptr;
sepptr = strrchr(UD->currentpath, '/');
if (sepptr==NULL) {
if (sepptr == NULL)
{
elog(ERROR, "There's a problem...");
sepptr = UD->currentpath;
}
if (strcmp(name, sepptr+1) !=0) {
if (strcmp(name, sepptr + 1) != 0)
{
elog(NOTICE, "Wanted [%s], got [%s]", sepptr, name);
/* unmatched entry, so do nothing */
} else {
}
else
{
sepptr[0] = '\0'; /* Chop that element off the end */
}
if (UD->textgrab) {
if (UD->textgrab)
pgxml_pathcompare(userData);
}
}
static void pgxml_charhandler(void *userData, const XML_Char *s, int len)
static void
pgxml_charhandler(void *userData, const XML_Char * s, int len)
{
if (UD->textgrab)
{
if (len > 0)
{
if (UD->textgrab) {
if (len>0) {
memcpy(UD->resptr, s, len);
UD->resptr += len;
UD->reslen += len;
}
}
}
/* Should I be using PG list types here? */
static void pgxml_finalisegrabbedtext(void *userData)
static void
pgxml_finalisegrabbedtext(void *userData)
{
/* In res/reslen, we have a single result. */
UD->xpres->results[UD->xpres->rescount] = UD->resptr - UD->reslen;
@ -302,9 +340,8 @@ static void pgxml_finalisegrabbedtext(void *userData)
UD->reslen = 0;
UD->xpres->rescount++;
/* This effectively concatenates all the results together but we
do know where one ends and the next begins */
/*
* This effectively concatenates all the results together but we do
* know where one ends and the next begins
*/
}

26
contrib/xml/pgxml.h
View File

@ -18,7 +18,8 @@ static void pgxml_finalisegrabbedtext(void *userData);
#define MAXRESULTS 100
typedef struct {
typedef struct
{
int rescount;
char *results[MAXRESULTS];
int32 reslens[MAXRESULTS];
@ -27,7 +28,8 @@ typedef struct {
typedef struct {
typedef struct
{
char currentpath[MAXPATHLENGTH];
char *path;
int textgrab;
@ -38,23 +40,3 @@ typedef struct {
#define UD ((pgxml_udata *) userData)

86
contrib/xml/pgxml_dom.c
View File

@ -32,30 +32,37 @@ Datum pgxml_xpath(PG_FUNCTION_ARGS);
/* memory handling passthrough functions (e.g. palloc, pstrdup are
currently macros, and the others might become so...) */
static void *pgxml_palloc(size_t size)
static void *
pgxml_palloc(size_t size)
{
return palloc(size);
}
static void *pgxml_repalloc(void *ptr, size_t size)
static void *
pgxml_repalloc(void *ptr, size_t size)
{
return repalloc(ptr, size);
}
static void pgxml_pfree(void *ptr)
static void
pgxml_pfree(void *ptr)
{
return pfree(ptr);
}
static char *pgxml_pstrdup(const char *string)
static char *
pgxml_pstrdup(const char *string)
{
return pstrdup(string);
}
static void pgxml_parser_init()
static void
pgxml_parser_init()
{
/* This code should also set parser settings from user-supplied
info. Quite how these settings are made is another matter :) */
/*
* This code should also set parser settings from user-supplied info.
* Quite how these settings are made is another matter :)
*/
xmlMemSetup(pgxml_pfree, pgxml_palloc, pgxml_repalloc, pgxml_pstrdup);
xmlInitParser();
@ -78,7 +85,8 @@ pgxml_parse(PG_FUNCTION_ARGS)
pgxml_parser_init();
doctree = xmlParseMemory((char *) VARDATA(t), docsize);
if (doctree == NULL) {
if (doctree == NULL)
{
/* xmlCleanupParser(); */
PG_RETURN_BOOL(false); /* i.e. not well-formed */
}
@ -88,15 +96,19 @@ pgxml_parse(PG_FUNCTION_ARGS)
}
static xmlChar
*pgxmlNodeSetToText(xmlNodeSetPtr nodeset,
*
pgxmlNodeSetToText(xmlNodeSetPtr nodeset,
xmlDocPtr doc,
xmlChar * toptagname,
xmlChar * septagname,
int format)
{
/* Function translates a nodeset into a text representation */
/* iterates over each node in the set and calls xmlNodeDump to write
it to an xmlBuffer -from which an xmlChar * string is returned. */
/*
* iterates over each node in the set and calls xmlNodeDump to write
* it to an xmlBuffer -from which an xmlChar * string is returned.
*/
/* each representation is surrounded by <tagname> ... </tagname> */
/* if format==0, add a newline between nodes?? */
@ -106,32 +118,37 @@ static xmlChar
buf = xmlBufferCreate();
if ((toptagname != NULL) && (xmlStrlen(toptagname)>0)) {
if ((toptagname != NULL) && (xmlStrlen(toptagname) > 0))
{
xmlBufferWriteChar(buf, "<");
xmlBufferWriteCHAR(buf, toptagname);
xmlBufferWriteChar(buf, ">");
}
if (nodeset != NULL) {
for (i=0; i < nodeset->nodeNr; i++) {
if ((septagname != NULL) && (xmlStrlen(septagname)>0)) {
if (nodeset != NULL)
{
for (i = 0; i < nodeset->nodeNr; i++)
{
if ((septagname != NULL) && (xmlStrlen(septagname) > 0))
{
xmlBufferWriteChar(buf, "<");
xmlBufferWriteCHAR(buf, septagname);
xmlBufferWriteChar(buf, ">");
}
xmlNodeDump(buf, doc, nodeset->nodeTab[i], 1, (format == 2));
if ((septagname != NULL) && (xmlStrlen(septagname)>0)) {
if ((septagname != NULL) && (xmlStrlen(septagname) > 0))
{
xmlBufferWriteChar(buf, "</");
xmlBufferWriteCHAR(buf, septagname);
xmlBufferWriteChar(buf, ">");
}
if (format) {
if (format)
xmlBufferWriteChar(buf, "\n");
}
}
}
if ((toptagname != NULL) && (xmlStrlen(toptagname)>0)) {
if ((toptagname != NULL) && (xmlStrlen(toptagname) > 0))
{
xmlBufferWriteChar(buf, "</");
xmlBufferWriteCHAR(buf, toptagname);
xmlBufferWriteChar(buf, ">");
@ -141,7 +158,9 @@ static xmlChar
return result;
}
static xmlChar *pgxml_texttoxmlchar(text *textstring) {
static xmlChar *
pgxml_texttoxmlchar(text *textstring)
{
xmlChar *res;
int32 txsize;
@ -161,11 +180,16 @@ pgxml_xpath(PG_FUNCTION_ARGS)
xmlDocPtr doctree;
xmlXPathContextPtr ctxt;
xmlXPathObjectPtr res;
xmlChar *xpath, *xpresstr, *toptag, *septag;
xmlChar *xpath,
*xpresstr,
*toptag,
*septag;
xmlXPathCompExprPtr comppath;
int32 docsize,ressize;
text *t, *xpres;
int32 docsize,
ressize;
text *t,
*xpres;
t = PG_GETARG_TEXT_P(0); /* document buffer */
xpath = pgxml_texttoxmlchar(PG_GETARG_TEXT_P(1)); /* XPath expression */
@ -177,7 +201,8 @@ pgxml_xpath(PG_FUNCTION_ARGS)
pgxml_parser_init();
doctree = xmlParseMemory((char *) VARDATA(t), docsize);
if (doctree == NULL) { /* not well-formed */
if (doctree == NULL)
{ /* not well-formed */
PG_RETURN_NULL();
}
@ -186,7 +211,8 @@ pgxml_xpath(PG_FUNCTION_ARGS)
/* compile the path */
comppath = xmlXPathCompile(xpath);
if (comppath == NULL) {
if (comppath == NULL)
{
elog(NOTICE, "XPath syntax error");
xmlFreeDoc(doctree);
pfree((void *) xpath);
@ -197,14 +223,16 @@ pgxml_xpath(PG_FUNCTION_ARGS)
res = xmlXPathCompiledEval(comppath, ctxt);
xmlXPathFreeCompExpr(comppath);
if (res==NULL) {
if (res == NULL)
{
xmlFreeDoc(doctree);
pfree((void *) xpath);
PG_RETURN_NULL(); /* seems appropriate */
}
/* now we dump this node, ?surrounding by tags? */
/* To do this, we look first at the type */
switch(res->type) {
switch (res->type)
{
case XPATH_NODESET:
xpresstr = pgxmlNodeSetToText(res->nodesetval,
doctree,
@ -232,7 +260,3 @@ pgxml_xpath(PG_FUNCTION_ARGS)
PG_RETURN_TEXT_P(xpres);
}

5
src/backend/access/common/heaptuple.c
View File

@ -9,7 +9,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/common/heaptuple.c,v 1.73 2001/08/23 23:06:37 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/common/heaptuple.c,v 1.74 2001/10/25 05:49:20 momjian Exp $
*
* NOTES
* The old interface functions have been converted to macros
@ -241,7 +241,6 @@ nocachegetattr(HeapTuple tuple,
}
else
{
/*
* there's a null somewhere in the tuple
*/
@ -347,7 +346,6 @@ nocachegetattr(HeapTuple tuple,
(HeapTupleNoNulls(tuple) || !att_isnull(j, bp)) &&
(HeapTupleAllFixed(tuple) || att[j]->attlen > 0)); j++)
{
/*
* Fix me when going to a machine with more than a four-byte
* word!
@ -546,7 +544,6 @@ heap_deformtuple(HeapTuple tuple,
nulls[i] = ' ';
}
}
#endif
/* ----------------

4
src/backend/access/common/indextuple.c
View File

@ -9,7 +9,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/common/indextuple.c,v 1.54 2001/03/22 06:16:06 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/access/common/indextuple.c,v 1.55 2001/10/25 05:49:20 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -49,7 +49,6 @@ index_formtuple(TupleDesc tupleDescriptor,
#ifdef TOAST_INDEX_HACK
Datum untoasted_value[INDEX_MAX_KEYS];
bool untoasted_free[INDEX_MAX_KEYS];
#endif
if (numberOfAttributes > INDEX_MAX_KEYS)
@ -338,7 +337,6 @@ nocache_index_getattr(IndexTuple tup,
for (; j <= attnum; j++)
{
/*
* Fix me when going to a machine with more than a four-byte
* word!

5
src/backend/access/common/printtup.c
View File

@ -9,7 +9,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/common/printtup.c,v 1.59 2001/03/22 06:16:06 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/access/common/printtup.c,v 1.60 2001/10/25 05:49:20 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -197,7 +197,6 @@ 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.
@ -306,7 +305,6 @@ 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.
@ -401,7 +399,6 @@ 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.
*/

10
src/backend/access/common/tupdesc.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/common/tupdesc.c,v 1.75 2001/06/25 21:11:43 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/common/tupdesc.c,v 1.76 2001/10/25 05:49:20 momjian Exp $
*
* NOTES
* some of the executor utility code such as "ExecTypeFromTL" should be
@ -238,9 +238,9 @@ equalTupleDescs(TupleDesc tupdesc1, TupleDesc tupdesc2)
Form_pg_attribute attr2 = tupdesc2->attrs[i];
/*
* We do not need to check every single field here: we can disregard
* attrelid, attnum (it was used to place the row in the attrs array)
* and everything derived from the column datatype.
* We do not need to check every single field here: we can
* disregard attrelid, 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;
@ -399,7 +399,6 @@ TupleDescInitEntry(TupleDesc desc,
0, 0, 0);
if (!HeapTupleIsValid(tuple))
{
/*
* here type info does not exist yet so we just fill the attribute
* with dummy information and return false.
@ -585,7 +584,6 @@ BuildDescForRelation(List *schema, char *relname)
typenameTypeId(typename),
atttypmod, attdim, attisset))
{
/*
* if TupleDescInitEntry() fails, it means there is no type in
* the system catalogs. So now we check if the type name

349
src/backend/access/gist/gist.c
View File

@ -8,7 +8,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/gist/gist.c,v 1.84 2001/10/06 23:21:43 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/gist/gist.c,v 1.85 2001/10/25 05:49:20 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -124,6 +124,7 @@ static OffsetNumber gistchoose(Relation r, Page p,
IndexTuple it,
GISTSTATE *giststate);
static void gistdelete(Relation r, ItemPointer tid);
#ifdef GIST_PAGEADDITEM
static IndexTuple gist_tuple_replacekey(Relation r,
GISTENTRY entry, IndexTuple t);
@ -140,6 +141,7 @@ static void gistpenalty( GISTSTATE *giststate, int attno,
GISTENTRY *key1, bool isNull1,
GISTENTRY *key2, bool isNull2,
float *penalty);
#undef GISTDEBUG
#ifdef GISTDEBUG
@ -240,10 +242,13 @@ gistbuildCallback(Relation index,
/* immediately compress keys to normalize */
for (i = 0; i < buildstate->numindexattrs; i++)
{
if ( nulls[i]=='n' ) {
if (nulls[i] == 'n')
{
attdata[i] = (Datum) 0;
compvec[i] = FALSE;
} else {
}
else
{
gistcentryinit(&buildstate->giststate, i, &tmpcentry, attdata[i],
(Relation) NULL, (Page) NULL, (OffsetNumber) 0,
-1 /* size is currently bogus */ , TRUE, FALSE);
@ -262,10 +267,10 @@ gistbuildCallback(Relation index,
/*
* Since we already have the index relation locked, we call
* gistdoinsert directly. Normal access method calls dispatch
* through gistinsert, which locks the relation for write. This
* is the right thing to do if you're inserting single tups, but
* not when you're initializing the whole index at once.
* gistdoinsert directly. Normal access method calls dispatch through
* gistinsert, which locks the relation for write. This is the right
* thing to do if you're inserting single tups, but not when you're
* initializing the whole index at once.
*/
gistdoinsert(index, itup, NULL, &buildstate->giststate);
@ -291,6 +296,7 @@ gistinsert(PG_FUNCTION_ARGS)
Datum *datum = (Datum *) PG_GETARG_POINTER(1);
char *nulls = (char *) PG_GETARG_POINTER(2);
ItemPointer ht_ctid = (ItemPointer) PG_GETARG_POINTER(3);
#ifdef NOT_USED
Relation heapRel = (Relation) PG_GETARG_POINTER(4);
#endif
@ -308,7 +314,8 @@ gistinsert(PG_FUNCTION_ARGS)
*/
/* GiST cannot index tuples with leading NULLs */
if ( nulls[0] == 'n' ) {
if (nulls[0] == 'n')
{
res = NULL;
PG_RETURN_POINTER(res);
}
@ -318,10 +325,13 @@ gistinsert(PG_FUNCTION_ARGS)
/* immediately compress keys to normalize */
for (i = 0; i < r->rd_att->natts; i++)
{
if ( nulls[i]=='n' ) {
if (nulls[i] == 'n')
{
datum[i] = (Datum) 0;
compvec[i] = FALSE;
} else {
}
else
{
gistcentryinit(&giststate, i, &tmpentry, datum[i],
(Relation) NULL, (Page) NULL, (OffsetNumber) 0,
-1 /* size is currently bogus */ , TRUE, FALSE);
@ -471,6 +481,7 @@ gistlayerinsert(Relation r, BlockNumber blkno,
if (!(ret & SPLITED))
{
IndexTuple newtup = gistgetadjusted(r, oldtup, (*itup)[0], giststate);
if (!newtup)
{
/* not need to update key */
@ -492,8 +503,10 @@ gistlayerinsert(Relation r, BlockNumber blkno,
if (gistnospace(page, (*itup), *len))
{
/* no space for insertion */
IndexTuple *itvec, *newitup;
int tlen,oldlen;
IndexTuple *itvec,
*newitup;
int tlen,
oldlen;
ret |= SPLITED;
itvec = gistreadbuffer(r, buffer, &tlen);
@ -539,6 +552,7 @@ gistlayerinsert(Relation r, BlockNumber blkno,
* parent
*/
IndexTuple newtup = gistunion(r, (*itup), *len, giststate);
ItemPointerSet(&(newtup->t_tid), blkno, 1);
for (i = 0; i < *len; i++)
@ -560,6 +574,7 @@ gistwritebuffer(Relation r, Page page, IndexTuple *itup,
{
OffsetNumber l = InvalidOffsetNumber;
int i;
#ifdef GIST_PAGEADDITEM
GISTENTRY tmpdentry;
IndexTuple newtup;
@ -639,14 +654,16 @@ gistjoinvector(IndexTuple *itvec, int *len, IndexTuple *additvec, int addlen)
* return union of itup vector
*/
static IndexTuple
gistunion(Relation r, IndexTuple *itvec, int len, GISTSTATE *giststate) {
gistunion(Relation r, IndexTuple *itvec, int len, GISTSTATE *giststate)
{
Datum attr[INDEX_MAX_KEYS];
bool whatfree[INDEX_MAX_KEYS];
char isnull[INDEX_MAX_KEYS];
bytea *evec;
Datum datum;
int datumsize,
i,j;
i,
j;
GISTENTRY centry[INDEX_MAX_KEYS];
bool *needfree;
IndexTuple newtup;
@ -656,11 +673,14 @@ gistunion(Relation r, IndexTuple *itvec, int len, GISTSTATE *giststate) {
needfree = (bool *) palloc(((len == 1) ? 2 : len) * sizeof(bool));
evec = (bytea *) palloc(((len == 1) ? 2 : len) * sizeof(GISTENTRY) + VARHDRSZ);
for (j = 0; j < r->rd_att->natts; j++) {
for (j = 0; j < r->rd_att->natts; j++)
{
reallen = 0;
for (i = 0; i < len; i++) {
for (i = 0; i < len; i++)
{
datum = index_getattr(itvec[i], j + 1, giststate->tupdesc, &IsNull);
if ( IsNull ) continue;
if (IsNull)
continue;
gistdentryinit(giststate, j,
&((GISTENTRY *) VARDATA(evec))[reallen],
@ -675,20 +695,24 @@ gistunion(Relation r, IndexTuple *itvec, int len, GISTSTATE *giststate) {
reallen++;
}
if ( reallen == 0 ) {
if (reallen == 0)
{
attr[j] = (Datum) 0;
isnull[j] = 'n';
whatfree[j] = FALSE;
} else {
if ( reallen == 1 ) {
}
else
{
if (reallen == 1)
{
VARATT_SIZEP(evec) = 2 * sizeof(GISTENTRY) + VARHDRSZ;
gistentryinit(((GISTENTRY *) VARDATA(evec))[1],
((GISTENTRY *) VARDATA(evec))[0].key, r, (Page) NULL,
(OffsetNumber) 0, ((GISTENTRY *) VARDATA(evec))[0].bytes, FALSE);
} else {
VARATT_SIZEP(evec) = reallen * sizeof(GISTENTRY) + VARHDRSZ;
}
else
VARATT_SIZEP(evec) = reallen * sizeof(GISTENTRY) + VARHDRSZ;
datum = FunctionCall2(&giststate->unionFn[j],
PointerGetDatum(evec),
PointerGetDatum(&datumsize));
@ -702,11 +726,13 @@ gistunion(Relation r, IndexTuple *itvec, int len, GISTSTATE *giststate) {
datumsize, FALSE, FALSE);
isnull[j] = ' ';
attr[j] = centry[j].key;
if ( !isAttByVal( giststate, j ) ) {
if (!isAttByVal(giststate, j))
{
whatfree[j] = TRUE;
if (centry[j].key != datum)
pfree(DatumGetPointer(datum));
} else
}
else
whatfree[j] = FALSE;
}
}
@ -732,7 +758,8 @@ gistgetadjusted(Relation r, IndexTuple oldtup, IndexTuple addtup, GISTSTATE *gis
bytea *evec;
Datum datum;
int datumsize;
bool result, neednew = false;
bool result,
neednew = false;
char isnull[INDEX_MAX_KEYS],
whatfree[INDEX_MAX_KEYS];
Datum attr[INDEX_MAX_KEYS];
@ -761,12 +788,16 @@ gistgetadjusted(Relation r, IndexTuple oldtup, IndexTuple addtup, GISTSTATE *gis
(OffsetNumber) 0, addatt, adddec, addisnull);
for( j=0; j<r->rd_att->natts; j++ ) {
if ( oldisnull[j] && addisnull[j] ) {
for (j = 0; j < r->rd_att->natts; j++)
{
if (oldisnull[j] && addisnull[j])
{
isnull[j] = 'n';
attr[j] = (Datum) 0;
whatfree[j] = FALSE;
} else {
}
else
{
FILLEV(
oldisnull[j], oldatt[j].key, oldatt[j].bytes,
addisnull[j], addatt[j].key, addatt[j].bytes
@ -776,10 +807,13 @@ gistgetadjusted(Relation r, IndexTuple oldtup, IndexTuple addtup, GISTSTATE *gis
PointerGetDatum(evec),
PointerGetDatum(&datumsize));
if ( oldisnull[j] || addisnull[j] ) {
if (oldisnull[j] || addisnull[j])
{
if (oldisnull[j])
neednew = true;
} else {
}
else
{
FunctionCall3(&giststate->equalFn[j],
ev0p->key,
datum,
@ -789,8 +823,10 @@ gistgetadjusted(Relation r, IndexTuple oldtup, IndexTuple addtup, GISTSTATE *gis
neednew = true;
}
if ( olddec[j] ) pfree( DatumGetPointer(oldatt[j].key) );
if ( adddec[j] ) pfree( DatumGetPointer(addatt[j].key) );
if (olddec[j])
pfree(DatumGetPointer(oldatt[j].key));
if (adddec[j])
pfree(DatumGetPointer(addatt[j].key));
gistcentryinit(giststate, j, &centry[j], datum,
(Relation) NULL, (Page) NULL, (OffsetNumber) NULL,
@ -798,17 +834,20 @@ gistgetadjusted(Relation r, IndexTuple oldtup, IndexTuple addtup, GISTSTATE *gis
isnull[j] = ' ';
attr[j] = centry[j].key;
if ( (!isAttByVal( giststate, j ) ) ) {
if ((!isAttByVal(giststate, j)))
{
whatfree[j] = TRUE;
if (centry[j].key != datum)
pfree(DatumGetPointer(datum));
} else
}
else
whatfree[j] = FALSE;
}
}
pfree(evec);
if (neednew) {
if (neednew)
{
/* need to update key */
newtup = (IndexTuple) index_formtuple(giststate->tupdesc, attr, isnull);
newtup->t_tid = oldtup->t_tid;
@ -822,11 +861,16 @@ gistgetadjusted(Relation r, IndexTuple oldtup, IndexTuple addtup, GISTSTATE *gis
}
static void
gistunionsubkey( Relation r, GISTSTATE *giststate, IndexTuple *itvec, GIST_SPLITVEC * spl ) {
int i,j,lr;
gistunionsubkey(Relation r, GISTSTATE *giststate, IndexTuple *itvec, GIST_SPLITVEC *spl)
{
int i,
j,
lr;
Datum *attr;
bool *needfree, IsNull;
int len, *attrsize;
bool *needfree,
IsNull;
int len,
*attrsize;
OffsetNumber *entries;
bytea *evec;
Datum datum;
@ -834,14 +878,18 @@ gistunionsubkey( Relation r, GISTSTATE *giststate, IndexTuple *itvec, GIST_SPLIT
int reallen;
bool *isnull;
for(lr=0;lr<=1;lr++) {
if ( lr ) {
for (lr = 0; lr <= 1; lr++)
{
if (lr)
{
attrsize = spl->spl_lattrsize;
attr = spl->spl_lattr;
len = spl->spl_nleft;
entries = spl->spl_left;
isnull = spl->spl_lisnull;
} else {
}
else
{
attrsize = spl->spl_rattrsize;
attr = spl->spl_rattr;
len = spl->spl_nright;
@ -851,9 +899,11 @@ gistunionsubkey( Relation r, GISTSTATE *giststate, IndexTuple *itvec, GIST_SPLIT
needfree = (bool *) palloc(((len == 1) ? 2 : len) * sizeof(bool));
evec = (bytea *) palloc(((len == 1) ? 2 : len) * sizeof(GISTENTRY) + VARHDRSZ);
for (j = 1; j < r->rd_att->natts; j++) {
for (j = 1; j < r->rd_att->natts; j++)
{
reallen = 0;
for (i = 0; i < len; i++) {
for (i = 0; i < len; i++)
{
if (spl->spl_idgrp[entries[i]])
continue;
datum = index_getattr(itvec[entries[i] - 1], j + 1,
@ -879,17 +929,21 @@ gistunionsubkey( Relation r, GISTSTATE *giststate, IndexTuple *itvec, GIST_SPLIT
datum = (Datum) 0;
datumsize = 0;
isnull[j] = true;
} else {
}
else
{
/*
* ((GISTENTRY *) VARDATA(evec))[0].bytes may be not defined,
* so form union with itself
* ((GISTENTRY *) VARDATA(evec))[0].bytes may be not
* defined, so form union with itself
*/
if ( reallen == 1 ) {
if (reallen == 1)
{
VARATT_SIZEP(evec) = 2 * sizeof(GISTENTRY) + VARHDRSZ;
memcpy((void *) &((GISTENTRY *) VARDATA(evec))[1],
(void *) &((GISTENTRY *) VARDATA(evec))[0],
sizeof(GISTENTRY));
} else
}
else
VARATT_SIZEP(evec) = reallen * sizeof(GISTENTRY) + VARHDRSZ;
datum = FunctionCall2(&giststate->unionFn[j],
PointerGetDatum(evec),
@ -913,43 +967,55 @@ gistunionsubkey( Relation r, GISTSTATE *giststate, IndexTuple *itvec, GIST_SPLIT
* find group in vector with equial value
*/
static int
gistfindgroup( GISTSTATE *giststate, GISTENTRY *valvec, GIST_SPLITVEC * spl ) {
int i,j,len;
gistfindgroup(GISTSTATE *giststate, GISTENTRY *valvec, GIST_SPLITVEC *spl)
{
int i,
j,
len;
int curid = 1;
bool result;
/*
* first key is always not null (see gistinsert),
* so we may not check for nulls
* first key is always not null (see gistinsert), so we may not check
* for nulls
*/
for(i=0; i<spl->spl_nleft; i++) {
if ( spl->spl_idgrp[ spl->spl_left[i] ]) continue;
for (i = 0; i < spl->spl_nleft; i++)
{
if (spl->spl_idgrp[spl->spl_left[i]])
continue;
len = 0;
/* find all equal value in right part */
for(j=0; j < spl->spl_nright; j++) {
if ( spl->spl_idgrp[ spl->spl_right[j] ]) continue;
for (j = 0; j < spl->spl_nright; j++)
{
if (spl->spl_idgrp[spl->spl_right[j]])
continue;
FunctionCall3(&giststate->equalFn[0],
valvec[spl->spl_left[i]].key,
valvec[spl->spl_right[j]].key,
PointerGetDatum(&result));
if ( result ) {
if (result)
{
spl->spl_idgrp[spl->spl_right[j]] = curid;
len++;
}
}
/* find all other equal value in left part */
if ( len ) {
if (len)
{
/* add current val to list of equial values */
spl->spl_idgrp[spl->spl_left[i]] = curid;
/* searching .. */
for(j=i+1; j < spl->spl_nleft; j++) {
if ( spl->spl_idgrp[ spl->spl_left[j] ]) continue;
for (j = i + 1; j < spl->spl_nleft; j++)
{
if (spl->spl_idgrp[spl->spl_left[j]])
continue;
FunctionCall3(&giststate->equalFn[0],
valvec[spl->spl_left[i]].key,
valvec[spl->spl_left[j]].key,
PointerGetDatum(&result));
if ( result ) {
if (result)
{
spl->spl_idgrp[spl->spl_left[j]] = curid;
len++;
}
@ -972,36 +1038,46 @@ gistadjsubkey(Relation r,
int *len,
GIST_SPLITVEC *v,
GISTSTATE *giststate
) {
)
{
int curlen;
OffsetNumber *curwpos;
bool decfree[INDEX_MAX_KEYS];
GISTENTRY entry,identry[INDEX_MAX_KEYS], *ev0p, *ev1p;
float lpenalty, rpenalty;
GISTENTRY entry,
identry[INDEX_MAX_KEYS],
*ev0p,
*ev1p;
float lpenalty,
rpenalty;
bytea *evec;
int datumsize;
bool isnull[INDEX_MAX_KEYS];
int i,j;
int i,
j;
Datum datum;
/* clear vectors */
curlen = v->spl_nleft;
curwpos = v->spl_left;
for (i = 0; i < v->spl_nleft; i++)
if ( v->spl_idgrp[ v->spl_left[i] ] == 0 ) {
if (v->spl_idgrp[v->spl_left[i]] == 0)
{
*curwpos = v->spl_left[i];
curwpos++;
} else
}
else
curlen--;
v->spl_nleft = curlen;
curlen = v->spl_nright;
curwpos = v->spl_right;
for (i = 0; i < v->spl_nright; i++)
if ( v->spl_idgrp[ v->spl_right[i] ] == 0 ) {
if (v->spl_idgrp[v->spl_right[i]] == 0)
{
*curwpos = v->spl_right[i];
curwpos++;
} else
}
else
curlen--;
v->spl_nright = curlen;
@ -1011,7 +1087,8 @@ gistadjsubkey(Relation r,
ev1p = &((GISTENTRY *) VARDATA(evec))[1];
/* add equivalent tuple */
for(i = 0; i< *len; i++) {
for (i = 0; i < *len; i++)
{
if (v->spl_idgrp[i + 1] == 0) /* already inserted */
continue;
gistDeCompressAtt(giststate, r, itup[i], (Page) NULL, (OffsetNumber) 0,
@ -1019,14 +1096,18 @@ gistadjsubkey(Relation r,
v->spl_ngrp[v->spl_idgrp[i + 1]]--;
if (v->spl_ngrp[v->spl_idgrp[i + 1]] == 0 &&
(v->spl_grpflag[ v->spl_idgrp[ i+1 ] ] & BOTH_ADDED) != BOTH_ADDED ) {
(v->spl_grpflag[v->spl_idgrp[i + 1]] & BOTH_ADDED) != BOTH_ADDED)
{
/* force last in group */
rpenalty = 1.0;
lpenalty = (v->spl_grpflag[v->spl_idgrp[i + 1]] & LEFT_ADDED) ? 2.0 : 0.0;
} else {
}
else
{
/* where? */
for( j=1; j<r->rd_att->natts; j++ ) {
for (j = 1; j < r->rd_att->natts; j++)
{
gistentryinit(entry, v->spl_lattr[j], r, (Page) NULL,
(OffsetNumber) 0, v->spl_lattrsize[j], FALSE);
gistpenalty(giststate, j, &entry, v->spl_lisnull[j],
@ -1042,15 +1123,20 @@ gistadjsubkey(Relation r,
}
}
/* add */
if ( lpenalty < rpenalty ) {
if (lpenalty < rpenalty)
{
v->spl_grpflag[v->spl_idgrp[i + 1]] |= LEFT_ADDED;
v->spl_left[v->spl_nleft] = i + 1;
v->spl_nleft++;
for( j=1; j<r->rd_att->natts; j++ ) {
if ( isnull[j] && v->spl_lisnull[j] ) {
for (j = 1; j < r->rd_att->natts; j++)
{
if (isnull[j] && v->spl_lisnull[j])
{
v->spl_lattr[j] = (Datum) 0;
v->spl_lattrsize[j] = 0;
} else {
}
else
{
FILLEV(
v->spl_lisnull[j], v->spl_lattr[j], v->spl_lattrsize[j],
isnull[j], identry[j].key, identry[j].bytes
@ -1067,15 +1153,21 @@ gistadjsubkey(Relation r,
v->spl_lisnull[j] = false;
}
}
} else {
}
else
{
v->spl_grpflag[v->spl_idgrp[i + 1]] |= RIGHT_ADDED;
v->spl_right[v->spl_nright] = i + 1;
v->spl_nright++;
for( j=1; j<r->rd_att->natts; j++ ) {
if ( isnull[j] && v->spl_risnull[j] ) {
for (j = 1; j < r->rd_att->natts; j++)
{
if (isnull[j] && v->spl_risnull[j])
{
v->spl_rattr[j] = (Datum) 0;
v->spl_rattrsize[j] = 0;
} else {
}
else
{
FILLEV(
v->spl_risnull[j], v->spl_rattr[j], v->spl_rattrsize[j],
isnull[j], identry[j].key, identry[j].bytes
@ -1125,7 +1217,8 @@ gistSplit(Relation r,
GIST_SPLITVEC v;
bytea *entryvec;
bool *decompvec;
int i,j,
int i,
j,
nlen;
int MaxGrpId = 1;
Datum datum;
@ -1177,8 +1270,10 @@ gistSplit(Relation r,
decompvec[i] = FALSE;
}
/* now let the user-defined picksplit function set up the split vector;
in entryvec have no null value!! */
/*
* now let the user-defined picksplit function set up the split
* vector; in entryvec have no null value!!
*/
FunctionCall2(&giststate->picksplitFn[0],
PointerGetDatum(entryvec),
PointerGetDatum(&v));
@ -1194,10 +1289,12 @@ gistSplit(Relation r,
v.spl_lisnull[0] = false;
v.spl_risnull[0] = false;
/* if index is multikey, then we must to try get smaller
* bounding box for subkey(s)
/*
* if index is multikey, then we must to try get smaller bounding box
* for subkey(s)
*/
if ( r->rd_att->natts > 1 ) {
if (r->rd_att->natts > 1)
{
v.spl_idgrp = (int *) palloc(sizeof(int) * (*len + 1));
MemSet((void *) v.spl_idgrp, 0, sizeof(int) * (*len + 1));
v.spl_grpflag = (char *) palloc(sizeof(char) * (*len + 1));
@ -1209,8 +1306,9 @@ gistSplit(Relation r,
/* form union of sub keys for each page (l,p) */
gistunionsubkey(r, giststate, itup, &v);
/* if possible, we insert equivalent tuples
* with control by penalty for a subkey(s)
/*
* if possible, we insert equivalent tuples with control by
* penalty for a subkey(s)
*/
if (MaxGrpId > 1)
gistadjsubkey(r, itup, len, &v, giststate);
@ -1359,10 +1457,13 @@ gistchoose(Relation r, Page p, IndexTuple it, /* it has compressed entry */
Datum datum;
float usize;
OffsetNumber which;
float sum_grow, which_grow[INDEX_MAX_KEYS];
float sum_grow,
which_grow[INDEX_MAX_KEYS];
GISTENTRY entry,
identry[INDEX_MAX_KEYS];
bool IsNull, decompvec[INDEX_MAX_KEYS], isnull[INDEX_MAX_KEYS];
bool IsNull,
decompvec[INDEX_MAX_KEYS],
isnull[INDEX_MAX_KEYS];
int j;
maxoff = PageGetMaxOffsetNumber(p);
@ -1376,8 +1477,10 @@ gistchoose(Relation r, Page p, IndexTuple it, /* it has compressed entry */
for (i = FirstOffsetNumber; i <= maxoff && sum_grow; i = OffsetNumberNext(i))
{
IndexTuple itup = (IndexTuple) PageGetItem(p, PageGetItemId(p, i));
sum_grow = 0;
for (j=0; j<r->rd_att->natts; j++) {
for (j = 0; j < r->rd_att->natts; j++)
{
datum = index_getattr(itup, j + 1, giststate->tupdesc, &IsNull);
gistdentryinit(giststate, j, &entry, datum, r, p, i, ATTSIZE(datum, giststate->tupdesc, j + 1, IsNull), FALSE, IsNull);
gistpenalty(giststate, j, &entry, IsNull, &identry[j], isnull[j], &usize);
@ -1385,14 +1488,18 @@ gistchoose(Relation r, Page p, IndexTuple it, /* it has compressed entry */
if ((!isAttByVal(giststate, j)) && entry.key != datum)
pfree(DatumGetPointer(entry.key));
if ( which_grow[j]<0 || usize < which_grow[j] ) {
if (which_grow[j] < 0 || usize < which_grow[j])
{
which = i;
which_grow[j] = usize;
if ( j<r->rd_att->natts-1 && i==FirstOffsetNumber ) which_grow[j+1]=-1;
if (j < r->rd_att->natts - 1 && i == FirstOffsetNumber)
which_grow[j + 1] = -1;
sum_grow += which_grow[j];
} else if ( which_grow[j] == usize ) {
}
else if (which_grow[j] == usize)
sum_grow += usize;
} else {
else
{
sum_grow = 1;
break;
}
@ -1577,7 +1684,8 @@ initGISTstate(GISTSTATE *giststate, Relation index)
}
void
freeGISTstate(GISTSTATE *giststate) {
freeGISTstate(GISTSTATE *giststate)
{
/* no work */
}
@ -1597,8 +1705,9 @@ gist_tuple_replacekey(Relation r, GISTENTRY entry, IndexTuple t)
/*
* If new entry fits in index tuple, copy it in. To avoid worrying
* about null-value bitmask, pass it off to the general index_formtuple
* routine if either the previous or new value is NULL.
* about null-value bitmask, pass it off to the general
* index_formtuple routine if either the previous or new value is
* NULL.
*/
if (!IsNull && DatumGetPointer(entry.key) != NULL &&
(Size) entry.bytes <= ATTSIZE(datum, r, 1, IsNull))
@ -1655,10 +1764,8 @@ gistdentryinit(GISTSTATE *giststate, int nkey, GISTENTRY *e,
}
}
else
{
gistentryinit(*e, (Datum) 0, r, pg, o, 0, l);
}
}
/*
@ -1686,10 +1793,8 @@ gistcentryinit(GISTSTATE *giststate, int nkey,
}
}
else
{
gistentryinit(*e, (Datum) 0, r, pg, o, 0, l);
}
}
static IndexTuple
gistFormTuple(GISTSTATE *giststate, Relation r,
@ -1702,47 +1807,57 @@ gistFormTuple( GISTSTATE *giststate, Relation r,
Datum compatt[INDEX_MAX_KEYS];
int j;
for (j = 0; j < r->rd_att->natts; j++) {
if ( isnull[j] ) {
for (j = 0; j < r->rd_att->natts; j++)
{
if (isnull[j])
{
isnullchar[j] = 'n';
compatt[j] = (Datum) 0;
whatfree[j] = FALSE;
} else {
}
else
{
gistcentryinit(giststate, j, &centry[j], attdata[j],
(Relation) NULL, (Page) NULL, (OffsetNumber) NULL,
datumsize[j], FALSE, FALSE);
isnullchar[j] = ' ';
compatt[j] = centry[j].key;
if ( !isAttByVal(giststate,j) ) {
if (!isAttByVal(giststate, j))
{
whatfree[j] = TRUE;
if (centry[j].key != attdata[j])
pfree(DatumGetPointer(attdata[j]));
} else
}
else
whatfree[j] = FALSE;
}
}
tup = (IndexTuple) index_formtuple(giststate->tupdesc, compatt, isnullchar);
for (j = 0; j < r->rd_att->natts; j++)
if ( whatfree[j] ) pfree(DatumGetPointer(compatt[j]));
if (whatfree[j])
pfree(DatumGetPointer(compatt[j]));
return tup;
}
static void
gistDeCompressAtt(GISTSTATE *giststate, Relation r, IndexTuple tuple, Page p,
OffsetNumber o, GISTENTRY attdata[], bool decompvec[], bool isnull[] ) {
OffsetNumber o, GISTENTRY attdata[], bool decompvec[], bool isnull[])
{
int i;
Datum datum;
for(i=0; i < r->rd_att->natts; i++ ) {
for (i = 0; i < r->rd_att->natts; i++)
{
datum = index_getattr(tuple, i + 1, giststate->tupdesc, &isnull[i]);
gistdentryinit(giststate, i, &attdata[i],
datum, r, p, o,
ATTSIZE(datum, giststate->tupdesc, i + 1, isnull[i]), FALSE, isnull[i]);
if (isAttByVal(giststate, i))
decompvec[i] = FALSE;
else {
else
{
if (attdata[i].key == datum || isnull[i])
decompvec[i] = FALSE;
else
@ -1752,8 +1867,10 @@ gistDeCompressAtt( GISTSTATE *giststate, Relation r, IndexTuple tuple, Page p,
}
static void
gistFreeAtt( Relation r, GISTENTRY attdata[], bool decompvec[] ) {
gistFreeAtt(Relation r, GISTENTRY attdata[], bool decompvec[])
{
int i;
for (i = 0; i < r->rd_att->natts; i++)
if (decompvec[i])
pfree(DatumGetPointer(attdata[i].key));
@ -1762,7 +1879,8 @@ gistFreeAtt( Relation r, GISTENTRY attdata[], bool decompvec[] ) {
static void
gistpenalty(GISTSTATE *giststate, int attno,
GISTENTRY *key1, bool isNull1,
GISTENTRY *key2, bool isNull2, float *penalty ){
GISTENTRY *key2, bool isNull2, float *penalty)
{
if (giststate->penaltyFn[attno].fn_strict && (isNull1 || isNull2))
*penalty = 0.0;
else
@ -1816,7 +1934,6 @@ gist_dumptree(Relation r, int level, BlockNumber blk, OffsetNumber coff)
ReleaseBuffer(buffer);
pfree(pred);
}
#endif /* defined GISTDEBUG */
void

2
src/backend/access/gist/gistget.c
View File

@ -8,7 +8,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/gist/gistget.c,v 1.30 2001/08/22 18:24:26 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/gist/gistget.c,v 1.31 2001/10/25 05:49:20 momjian Exp $
*
*-------------------------------------------------------------------------
*/

3
src/backend/access/gist/gistscan.c
View File

@ -8,7 +8,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/gist/gistscan.c,v 1.39 2001/08/22 18:24:26 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/gist/gistscan.c,v 1.40 2001/10/25 05:49:20 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -383,7 +383,6 @@ adjustiptr(IndexScanDesc s,
}
else
{
/*
* remember that we're before the current
* tuple

3
src/backend/access/gist/giststrat.c
View File

@ -8,7 +8,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/gist/Attic/giststrat.c,v 1.17 2001/05/30 19:53:40 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/gist/Attic/giststrat.c,v 1.18 2001/10/25 05:49:20 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -121,5 +121,4 @@ RelationInvokeGISTStrategy(Relation r,
return (RelationInvokeStrategy(r, &GISTEvaluationData, attnum, s,
left, right));
}
#endif

19
src/backend/access/hash/hash.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/hash/hash.c,v 1.52 2001/07/15 22:48:15 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/hash/hash.c,v 1.53 2001/10/25 05:49:20 momjian Exp $
*
* NOTES
* This file contains only the public interface routines.
@ -164,6 +164,7 @@ hashinsert(PG_FUNCTION_ARGS)
Datum *datum = (Datum *) PG_GETARG_POINTER(1);
char *nulls = (char *) PG_GETARG_POINTER(2);
ItemPointer ht_ctid = (ItemPointer) PG_GETARG_POINTER(3);
#ifdef NOT_USED
Relation heapRel = (Relation) PG_GETARG_POINTER(4);
#endif
@ -176,14 +177,13 @@ hashinsert(PG_FUNCTION_ARGS)
itup->t_tid = *ht_ctid;
/*
* If the single index key is null, we don't insert it into the
* index. Hash tables support scans on '='. Relational algebra
* says that A = B returns null if either A or B is null. This
* means that no qualification used in an index scan could ever
* return true on a null attribute. It also means that indices
* can't be used by ISNULL or NOTNULL scans, but that's an
* artifact of the strategy map architecture chosen in 1986, not
* of the way nulls are handled here.
* If the single index key is null, we don't insert it into the index.
* Hash tables support scans on '='. Relational algebra says that A =
* B returns null if either A or B is null. This means that no
* qualification used in an index scan could ever return true on a
* null attribute. It also means that indices can't be used by ISNULL
* or NOTNULL scans, but that's an artifact of the strategy map
* architecture chosen in 1986, not of the way nulls are handled here.
*/
if (IndexTupleHasNulls(itup))
{
@ -262,7 +262,6 @@ hashrescan(PG_FUNCTION_ARGS)
#ifdef NOT_USED /* XXX surely it's wrong to ignore this? */
bool fromEnd = PG_GETARG_BOOL(1);
#endif
ScanKey scankey = (ScanKey) PG_GETARG_POINTER(2);
ItemPointer iptr;

6
src/backend/access/hash/hashinsert.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/hash/hashinsert.c,v 1.22 2001/03/07 21:20:26 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/hash/hashinsert.c,v 1.23 2001/10/25 05:49:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -133,13 +133,11 @@ _hash_insertonpg(Relation rel,
while (PageGetFreeSpace(page) < itemsz)
{
/*
* no space on this page; check for an overflow page
*/
if (BlockNumberIsValid(pageopaque->hasho_nextblkno))
{
/*
* ovfl page exists; go get it. if it doesn't have room,
* we'll find out next pass through the loop test above.
@ -152,7 +150,6 @@ _hash_insertonpg(Relation rel,
}
else
{
/*
* we're at the end of the bucket chain and we haven't found a
* page with enough room. allocate a new overflow page.
@ -184,7 +181,6 @@ _hash_insertonpg(Relation rel,
if (res != NULL)
{
/*
* Increment the number of keys in the table. We switch lock
* access type just for a moment to allow greater accessibility to

3
src/backend/access/hash/hashovfl.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/hash/hashovfl.c,v 1.30 2001/07/15 22:48:15 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/hash/hashovfl.c,v 1.31 2001/10/25 05:49:21 momjian Exp $
*
* NOTES
* Overflow pages look like ordinary relation pages.
@ -208,7 +208,6 @@ _hash_getovfladdr(Relation rel, Buffer *metabufp)
}
else
{
/*
* Free_bit addresses the last used bit. Bump it to address the
* first available bit.

8
src/backend/access/hash/hashpage.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/hash/hashpage.c,v 1.32 2001/07/15 22:48:15 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/hash/hashpage.c,v 1.33 2001/10/25 05:49:21 momjian Exp $
*
* NOTES
* Postgres hash pages look like ordinary relation pages. The opaque
@ -532,7 +532,6 @@ _hash_splitpage(Relation rel,
_hash_relbuf(rel, obuf, HASH_WRITE);
if (!BlockNumberIsValid(oblkno))
{
/*
* the old bucket is completely empty; of course, the new
* bucket will be as well, but since it's a base bucket page
@ -559,7 +558,6 @@ _hash_splitpage(Relation rel,
omaxoffnum = PageGetMaxOffsetNumber(opage);
for (;;)
{
/*
* at each iteration through this loop, each of these variables
* should be up-to-date: obuf opage oopaque ooffnum omaxoffnum
@ -572,7 +570,6 @@ _hash_splitpage(Relation rel,
oblkno = oopaque->hasho_nextblkno;
if (BlockNumberIsValid(oblkno))
{
/*
* we ran out of tuples on this particular page, but we
* have more overflow pages; re-init values.
@ -594,7 +591,6 @@ _hash_splitpage(Relation rel,
}
else
{
/*
* we're at the end of the bucket chain, so now we're
* really done with everything. before quitting, call
@ -618,7 +614,6 @@ _hash_splitpage(Relation rel,
if (bucket == nbucket)
{
/*
* insert the tuple into the new bucket. if it doesn't fit on
* the current page in the new bucket, we must allocate a new
@ -695,7 +690,6 @@ _hash_splitpage(Relation rel,
}
else
{
/*
* the tuple stays on this page. we didn't move anything, so
* we didn't delete anything and therefore we don't have to

3
src/backend/access/hash/hashsearch.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/hash/hashsearch.c,v 1.26 2001/03/23 04:49:51 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/access/hash/hashsearch.c,v 1.27 2001/10/25 05:49:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -36,7 +36,6 @@ _hash_search(Relation rel,
if (scankey == (ScanKey) NULL ||
(keyDatum = scankey[0].sk_argument) == (Datum) NULL)
{
/*
* If the scankey argument is NULL, all tuples will satisfy the
* scan so we start the scan at the first bucket (bucket 0).

5
src/backend/access/hash/hashstrat.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/hash/Attic/hashstrat.c,v 1.18 2001/05/30 19:53:40 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/hash/Attic/hashstrat.c,v 1.19 2001/10/25 05:49:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -46,7 +46,6 @@ static StrategyEvaluationData HTEvaluationData = {
(StrategyTransformMap) HTNegateCommute,
HTEvaluationExpressions
};
#endif
/* ----------------------------------------------------------------
@ -68,7 +67,6 @@ _hash_getstrat(Relation rel,
return strat;
}
#endif
#ifdef NOT_USED
@ -82,5 +80,4 @@ _hash_invokestrat(Relation rel,
return (RelationInvokeStrategy(rel, &HTEvaluationData, attno, strat,
left, right));
}
#endif

65
src/backend/access/heap/heapam.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/heap/heapam.c,v 1.125 2001/08/23 23:06:37 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/heap/heapam.c,v 1.126 2001/10/25 05:49:21 momjian Exp $
*
*
* INTERFACE ROUTINES
@ -431,7 +431,6 @@ fastgetattr(HeapTuple tup, int attnum, TupleDesc tupleDesc,
)
);
}
#endif /* defined(DISABLE_COMPLEX_MACRO) */
@ -1045,12 +1044,13 @@ heap_insert(Relation relation, HeapTuple tup)
if (relation->rd_rel->relhasoids)
{
/*
* If the object id of this tuple has already been assigned, trust the
* caller. There are a couple of ways this can happen. At initial db
* creation, the backend program sets oids for tuples. When we define
* an index, we set the oid. Finally, in the future, we may allow
* users to set their own object ids in order to support a persistent
* object store (objects need to contain pointers to one another).
* If the object id of this tuple has already been assigned, trust
* the caller. There are a couple of ways this can happen. At
* initial db creation, the backend program sets oids for tuples.
* When we define an index, we set the oid. Finally, in the
* future, we may allow users to set their own object ids in order
* to support a persistent object store (objects need to contain
* pointers to one another).
*/
if (!OidIsValid(tup->t_data->t_oid))
tup->t_data->t_oid = newoid();
@ -1478,21 +1478,22 @@ l2:
}
/*
* Now, do we need a new page for the tuple, or not? This is a bit
* tricky since someone else could have added tuples to the page
* while we weren't looking. We have to recheck the available space
* after reacquiring the buffer lock. But don't bother to do that
* if the former amount of free space is still not enough; it's
* unlikely there's more free now than before.
* Now, do we need a new page for the tuple, or not? This is a
* bit tricky since someone else could have added tuples to the
* page while we weren't looking. We have to recheck the
* available space after reacquiring the buffer lock. But don't
* bother to do that if the former amount of free space is still
* not enough; it's unlikely there's more free now than before.
*
* What's more, if we need to get a new page, we will need to acquire
* buffer locks on both old and new pages. To avoid deadlock against
* some other backend trying to get the same two locks in the other
* order, we must be consistent about the order we get the locks in.
* We use the rule "lock the lower-numbered page of the relation
* first". To implement this, we must do RelationGetBufferForTuple
* while not holding the lock on the old page, and we must rely on it
* to get the locks on both pages in the correct order.
* buffer locks on both old and new pages. To avoid deadlock
* against some other backend trying to get the same two locks in
* the other order, we must be consistent about the order we get
* the locks in. We use the rule "lock the lower-numbered page of
* the relation first". To implement this, we must do
* RelationGetBufferForTuple while not holding the lock on the old
* page, and we must rely on it to get the locks on both pages in
* the correct order.
*/
if (newtupsize > pagefree)
{
@ -1510,8 +1511,8 @@ l2:
{
/*
* Rats, it doesn't fit anymore. We must now unlock and
* relock to avoid deadlock. Fortunately, this path should
* seldom be taken.
* relock to avoid deadlock. Fortunately, this path
* should seldom be taken.
*/
LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
newbuf = RelationGetBufferForTuple(relation, newtup->t_len,
@ -1534,9 +1535,9 @@ l2:
pgstat_count_heap_update(&relation->pgstat_info);
/*
* At this point newbuf and buffer are both pinned and locked,
* and newbuf has enough space for the new tuple. If they are
* the same buffer, only one pin is held.
* At this point newbuf and buffer are both pinned and locked, and
* newbuf has enough space for the new tuple. If they are the same
* buffer, only one pin is held.
*/
/* NO ELOG(ERROR) from here till changes are logged */
@ -1865,9 +1866,11 @@ log_heap_update(Relation reln, Buffer oldbuf, ItemPointerData from,
* Note: xlhdr is declared to have adequate size and correct alignment
* for an xl_heap_header. However the two tids, if present at all,
* will be packed in with no wasted space after the xl_heap_header;
* they aren't necessarily aligned as implied by this struct declaration.
* they aren't necessarily aligned as implied by this struct
* declaration.
*/
struct {
struct
{
xl_heap_header hdr;
TransactionId tid1;
TransactionId tid2;
@ -2084,7 +2087,8 @@ heap_xlog_insert(bool redo, XLogRecPtr lsn, XLogRecord *record)
if (redo)
{
struct {
struct
{
HeapTupleHeaderData hdr;
char data[MaxTupleSize];
} tbuf;
@ -2251,7 +2255,8 @@ newsame:;
if (redo)
{
struct {
struct
{
HeapTupleHeaderData hdr;
char data[MaxTupleSize];
} tbuf;

53
src/backend/access/heap/hio.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Id: hio.c,v 1.42 2001/07/13 22:52:58 tgl Exp $
* $Id: hio.c,v 1.43 2001/10/25 05:49:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -115,7 +115,8 @@ RelationGetBufferForTuple(Relation relation, Size len,
if (otherBuffer != InvalidBuffer)
otherBlock = BufferGetBlockNumber(otherBuffer);
else
otherBlock = InvalidBlockNumber; /* just to keep compiler quiet */
otherBlock = InvalidBlockNumber; /* just to keep compiler
* quiet */
/*
* We first try to put the tuple on the same page we last inserted a
@ -123,9 +124,10 @@ RelationGetBufferForTuple(Relation relation, Size len,
* we ask the shared Free Space Map to locate a suitable page. Since
* the FSM's info might be out of date, we have to be prepared to loop
* around and retry multiple times. (To insure this isn't an infinite
* loop, we must update the FSM with the correct amount of free space on
* each page that proves not to be suitable.) If the FSM has no record of
* a page with enough free space, we give up and extend the relation.
* loop, we must update the FSM with the correct amount of free space
* on each page that proves not to be suitable.) If the FSM has no
* record of a page with enough free space, we give up and extend the
* relation.
*/
targetBlock = relation->rd_targblock;
@ -137,6 +139,7 @@ RelationGetBufferForTuple(Relation relation, Size len,
* target.
*/
targetBlock = GetPageWithFreeSpace(&relation->rd_node, len);
/*
* If the FSM knows nothing of the rel, try the last page before
* we give up and extend. This avoids one-tuple-per-page syndrome
@ -154,9 +157,9 @@ RelationGetBufferForTuple(Relation relation, Size len,
while (targetBlock != InvalidBlockNumber)
{
/*
* Read and exclusive-lock the target block, as well as the
* other block if one was given, taking suitable care with
* lock ordering and the possibility they are the same block.
* Read and exclusive-lock the target block, as well as the other
* block if one was given, taking suitable care with lock ordering
* and the possibility they are the same block.
*/
if (otherBuffer == InvalidBuffer)
{
@ -184,9 +187,10 @@ RelationGetBufferForTuple(Relation relation, Size len,
LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
LockBuffer(otherBuffer, BUFFER_LOCK_EXCLUSIVE);
}
/*
* Now we can check to see if there's enough free space here.
* If so, we're done.
* Now we can check to see if there's enough free space here. If
* so, we're done.
*/
pageHeader = (Page) BufferGetPage(buffer);
pageFreeSpace = PageGetFreeSpace(pageHeader);
@ -196,22 +200,22 @@ RelationGetBufferForTuple(Relation relation, Size len,
relation->rd_targblock = targetBlock;
return buffer;
}
/*
* Not enough space, so we must give up our page locks and
* pin (if any) and prepare to look elsewhere. We don't care
* which order we unlock the two buffers in, so this can be
* slightly simpler than the code above.
* Not enough space, so we must give up our page locks and pin (if
* any) and prepare to look elsewhere. We don't care which order
* we unlock the two buffers in, so this can be slightly simpler
* than the code above.
*/
LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
if (otherBuffer == InvalidBuffer)
{
ReleaseBuffer(buffer);
}
else if (otherBlock != targetBlock)
{
LockBuffer(otherBuffer, BUFFER_LOCK_UNLOCK);
ReleaseBuffer(buffer);
}
/*
* Update FSM as to condition of this page, and ask for another
* page to try.
@ -225,9 +229,9 @@ RelationGetBufferForTuple(Relation relation, Size len,
/*
* Have to extend the relation.
*
* We have to use a lock to ensure no one else is extending the
* rel at the same time, else we will both try to initialize the
* same new page.
* We have to use a lock to ensure no one else is extending the rel at
* the same time, else we will both try to initialize the same new
* page.
*/
if (!relation->rd_myxactonly)
LockPage(relation, 0, ExclusiveLock);
@ -236,20 +240,21 @@ RelationGetBufferForTuple(Relation relation, Size len,
* XXX This does an lseek - rather expensive - but at the moment it is
* the only way to accurately determine how many blocks are in a
* relation. Is it worth keeping an accurate file length in shared
* memory someplace, rather than relying on the kernel to do it for us?
* memory someplace, rather than relying on the kernel to do it for
* us?
*/
buffer = ReadBuffer(relation, P_NEW);
/*
* Release the file-extension lock; it's now OK for someone else
* to extend the relation some more.
* Release the file-extension lock; it's now OK for someone else to
* extend the relation some more.
*/
if (!relation->rd_myxactonly)
UnlockPage(relation, 0, ExclusiveLock);
/*
* We can be certain that locking the otherBuffer first is OK,
* since it must have a lower page number.
* We can be certain that locking the otherBuffer first is OK, since
* it must have a lower page number.
*/
if (otherBuffer != InvalidBuffer)
LockBuffer(otherBuffer, BUFFER_LOCK_EXCLUSIVE);

8
src/backend/access/heap/stats.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/heap/Attic/stats.c,v 1.24 2001/03/22 06:16:07 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/access/heap/Attic/stats.c,v 1.25 2001/10/25 05:49:21 momjian Exp $
*
* NOTES
* initam should be moved someplace else.
@ -164,7 +164,6 @@ ResetHeapAccessStatistics()
time(&stats->local_reset_timestamp);
time(&stats->last_request_timestamp);
}
#endif
#ifdef NOT_USED
@ -200,7 +199,6 @@ GetHeapAccessStatistics()
return stats;
}
#endif
#ifdef NOT_USED
@ -211,7 +209,6 @@ GetHeapAccessStatistics()
void
PrintHeapAccessStatistics(HeapAccessStatistics stats)
{
/*
* return nothing if stats aren't valid
*/
@ -302,7 +299,6 @@ PrintHeapAccessStatistics(HeapAccessStatistics stats)
printf("\n");
}
#endif
#ifdef NOT_USED
@ -317,7 +313,6 @@ PrintAndFreeHeapAccessStatistics(HeapAccessStatistics stats)
if (stats != NULL)
pfree(stats);
}
#endif
/* ----------------------------------------------------------------
@ -331,7 +326,6 @@ PrintAndFreeHeapAccessStatistics(HeapAccessStatistics stats)
void
initam(void)
{
/*
* initialize heap statistics.
*/

30
src/backend/access/heap/tuptoaster.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/heap/tuptoaster.c,v 1.24 2001/08/10 18:57:33 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/heap/tuptoaster.c,v 1.25 2001/10/25 05:49:21 momjian Exp $
*
*
* INTERFACE ROUTINES
@ -81,7 +81,6 @@ heap_tuple_fetch_attr(varattrib *attr)
if (VARATT_IS_EXTERNAL(attr))
{
/*
* This is an external stored plain value
*/
@ -89,7 +88,6 @@ heap_tuple_fetch_attr(varattrib *attr)
}
else
{
/*
* This is a plain value inside of the main tuple - why am I
* called?
@ -135,7 +133,6 @@ heap_tuple_untoast_attr(varattrib *attr)
}
else
{
/*
* This is an external stored plain value
*/
@ -144,7 +141,6 @@ heap_tuple_untoast_attr(varattrib *attr)
}
else if (VARATT_IS_COMPRESSED(attr))
{
/*
* This is a compressed value inside of the main tuple
*/
@ -181,8 +177,8 @@ toast_raw_datum_size(Datum value)
if (VARATT_IS_COMPRESSED(attr))
{
/*
* va_rawsize shows the original data size, whether the datum
* is external or not.
* va_rawsize shows the original data size, whether the datum is
* external or not.
*/
result = attr->va_content.va_compressed.va_rawsize + VARHDRSZ;
}
@ -301,7 +297,6 @@ toast_insert_or_update(Relation rel, HeapTuple newtup, HeapTuple oldtup)
if (oldtup != NULL)
{
/*
* For UPDATE get the old and new values of this attribute
*/
@ -324,7 +319,6 @@ toast_insert_or_update(Relation rel, HeapTuple newtup, HeapTuple oldtup)
old_value->va_content.va_external.va_toastrelid !=
new_value->va_content.va_external.va_toastrelid)
{
/*
* The old external store value isn't needed any more
* after the update
@ -334,7 +328,6 @@ toast_insert_or_update(Relation rel, HeapTuple newtup, HeapTuple oldtup)
}
else
{
/*
* This attribute isn't changed by this update so we
* reuse the original reference to the old value in
@ -348,7 +341,6 @@ toast_insert_or_update(Relation rel, HeapTuple newtup, HeapTuple oldtup)
}
else
{
/*
* For INSERT simply get the new value
*/
@ -372,7 +364,6 @@ toast_insert_or_update(Relation rel, HeapTuple newtup, HeapTuple oldtup)
*/
if (att[i]->attlen == -1)
{
/*
* If the table's attribute says PLAIN always, force it so.
*/
@ -400,7 +391,6 @@ toast_insert_or_update(Relation rel, HeapTuple newtup, HeapTuple oldtup)
}
else
{
/*
* Not a variable size attribute, plain storage always
*/
@ -475,7 +465,6 @@ toast_insert_or_update(Relation rel, HeapTuple newtup, HeapTuple oldtup)
}
else
{
/*
* incompressible data, ignore on subsequent compression
* passes
@ -588,7 +577,6 @@ toast_insert_or_update(Relation rel, HeapTuple newtup, HeapTuple oldtup)
}
else
{
/*
* incompressible data, ignore on subsequent compression
* passes
@ -776,7 +764,8 @@ toast_save_datum(Relation rel, Datum value)
Datum t_values[3];
char t_nulls[3];
varattrib *result;
struct {
struct
{
struct varlena hdr;
char data[TOAST_MAX_CHUNK_SIZE];
} chunk_data;
@ -855,8 +844,8 @@ toast_save_datum(Relation rel, Datum value)
* FormIndexDatum: this relies on the knowledge that the index
* columns are the same as the initial columns of the table.
*
* Note also that there had better not be any user-created index
* on the TOAST table, since we don't bother to update anything else.
* Note also that there had better not be any user-created index on
* the TOAST table, since we don't bother to update anything else.
*/
idxres = index_insert(toastidx, t_values, t_nulls,
&(toasttup->t_self),
@ -916,8 +905,8 @@ toast_delete_datum(Relation rel, Datum value)
toastidx = index_open(toastrel->rd_rel->reltoastidxid);
/*
* Setup a scan key to fetch from the index by va_valueid
* (we don't particularly care whether we see them in sequence or not)
* Setup a scan key to fetch from the index by va_valueid (we don't
* particularly care whether we see them in sequence or not)
*/
ScanKeyEntryInitialize(&toastkey,
(bits16) 0,
@ -1096,5 +1085,4 @@ toast_fetch_datum(varattrib *attr)
return result;
}
#endif /* TUPLE_TOASTER_ACTIVE */

3
src/backend/access/index/genam.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/index/genam.c,v 1.28 2001/06/22 19:16:21 wieck Exp $
* $Header: /cvsroot/pgsql/src/backend/access/index/genam.c,v 1.29 2001/10/25 05:49:21 momjian Exp $
*
* NOTES
* many of the old access method routines have been turned into
@ -240,5 +240,4 @@ IndexScanRestorePosition(IndexScanDesc scan)
scan->flags = 0x0; /* XXX should have a symbolic name */
}
#endif

12
src/backend/access/index/indexam.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/index/indexam.c,v 1.53 2001/10/06 23:21:43 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/index/indexam.c,v 1.54 2001/10/25 05:49:21 momjian Exp $
*
* INTERFACE ROUTINES
* index_open - open an index relation by relationId
@ -241,9 +241,9 @@ index_beginscan(Relation relation,
pgstat_initstats(&scan->xs_pgstat_info, relation);
/*
* We want to look up the amgettuple procedure just once per scan,
* not once per index_getnext call. So do it here and save
* the fmgr info result in the scan descriptor.
* We want to look up the amgettuple procedure just once per scan, not
* once per index_getnext call. So do it here and save the fmgr info
* result in the scan descriptor.
*/
GET_SCAN_PROCEDURE(beginscan, amgettuple);
fmgr_info(procedure, &scan->fn_getnext);
@ -342,8 +342,8 @@ index_getnext(IndexScanDesc scan,
pgstat_count_index_scan(&scan->xs_pgstat_info);
/*
* have the am's gettuple proc do all the work.
* index_beginscan already set up fn_getnext.
* have the am's gettuple proc do all the work. index_beginscan
* already set up fn_getnext.
*/
result = (RetrieveIndexResult)
DatumGetPointer(FunctionCall2(&scan->fn_getnext,

6
src/backend/access/index/istrat.c
View File

@ -9,7 +9,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/index/Attic/istrat.c,v 1.53 2001/10/06 23:21:43 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/index/Attic/istrat.c,v 1.54 2001/10/25 05:49:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -196,7 +196,6 @@ StrategyEvaluationIsValid(StrategyEvaluation evaluation)
}
return true;
}
#endif
#ifdef NOT_USED
@ -255,7 +254,6 @@ StrategyTermEvaluate(StrategyTerm term,
return result;
}
#endif
/* ----------------
@ -453,7 +451,6 @@ RelationInvokeStrategy(Relation relation,
/* not reached, just to make compiler happy */
return FALSE;
}
#endif
/* ----------------
@ -643,5 +640,4 @@ IndexStrategyDisplay(IndexStrategy indexStrategy,
}
}
}
#endif /* defined(ISTRATDEBUG) */

2
src/backend/access/nbtree/nbtcompare.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtcompare.c,v 1.42 2001/05/03 19:00:36 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtcompare.c,v 1.43 2001/10/25 05:49:21 momjian Exp $
*
* NOTES
*

6
src/backend/access/nbtree/nbtinsert.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtinsert.c,v 1.86 2001/09/29 23:49:51 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtinsert.c,v 1.87 2001/10/25 05:49:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -1115,7 +1115,8 @@ _bt_checksplitloc(FindSplitData *state, OffsetNumber firstright,
{
/*
* On a rightmost page, try to equalize right free space with
* twice the left free space. See comments for _bt_findsplitloc.
* twice the left free space. See comments for
* _bt_findsplitloc.
*/
delta = (2 * leftfree) - rightfree;
}
@ -1618,7 +1619,6 @@ _bt_fixlevel(Relation rel, Buffer buf, BlockNumber limit)
for (;;)
{
/*
* Read up to 2 more child pages and look for pointers to them in
* *saved* parent page

6
src/backend/access/nbtree/nbtpage.c
View File

@ -9,7 +9,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtpage.c,v 1.53 2001/07/15 22:48:16 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtpage.c,v 1.54 2001/10/25 05:49:21 momjian Exp $
*
* NOTES
* Postgres btree pages look like ordinary relation pages. The opaque
@ -153,7 +153,6 @@ _bt_getroot(Relation rel, int access)
*/
if (metad->btm_root == P_NONE)
{
/*
* Get, initialize, write, and leave a lock of the appropriate
* type on the new root page. Since this is the first page in
@ -209,7 +208,6 @@ _bt_getroot(Relation rel, int access)
}
else
{
/*
* Metadata initialized by someone else. In order to
* guarantee no deadlocks, we have to release the metadata
@ -237,7 +235,6 @@ _bt_getroot(Relation rel, int access)
if (!P_ISROOT(rootopaque))
{
/*
* It happened, but if root page splitter failed to create new
* root page then we'll go in loop trying to call _bt_getroot
@ -402,7 +399,6 @@ _bt_wrtnorelbuf(Relation rel, Buffer buf)
void
_bt_pageinit(Page page, Size size)
{
/*
* Cargo_cult programming -- don't really need this to be zero, but
* creating new pages is an infrequent occurrence and it makes me feel

42
src/backend/access/nbtree/nbtree.c
View File

@ -12,7 +12,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtree.c,v 1.82 2001/07/15 22:48:16 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtree.c,v 1.83 2001/10/25 05:49:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -37,6 +37,7 @@ typedef struct
bool haveDead;
Relation heapRel;
BTSpool *spool;
/*
* spool2 is needed only when the index is an unique index. Dead
* tuples are put into spool2 instead of spool in order to avoid
@ -134,6 +135,7 @@ btbuild(PG_FUNCTION_ARGS)
if (buildstate.usefast)
{
buildstate.spool = _bt_spoolinit(index, indexInfo->ii_Unique);
/*
* Different from spool, the uniqueness isn't checked for spool2.
*/
@ -226,9 +228,9 @@ btbuildCallback(Relation index,
btitem = _bt_formitem(itup);
/*
* if we are doing bottom-up btree build, we insert the index into
* a spool file for subsequent processing. otherwise, we insert
* into the btree.
* if we are doing bottom-up btree build, we insert the index into a
* spool file for subsequent processing. otherwise, we insert into
* the btree.
*/
if (buildstate->usefast)
{
@ -305,7 +307,6 @@ btgettuple(PG_FUNCTION_ARGS)
if (ItemPointerIsValid(&(scan->currentItemData)))
{
/*
* Restore scan position using heap TID returned by previous call
* to btgettuple(). _bt_restscan() re-grabs the read lock on the
@ -362,7 +363,6 @@ btrescan(PG_FUNCTION_ARGS)
#ifdef NOT_USED /* XXX surely it's wrong to ignore this? */
bool fromEnd = PG_GETARG_BOOL(1);
#endif
ScanKey scankey = (ScanKey) PG_GETARG_POINTER(2);
ItemPointer iptr;
@ -559,15 +559,16 @@ btbulkdelete(PG_FUNCTION_ARGS)
num_index_tuples = 0;
/*
* We use a standard IndexScanDesc scan object, but to speed up the loop,
* we skip most of the wrapper layers of index_getnext and instead call
* _bt_step directly. This implies holding buffer lock on a target page
* throughout the loop over the page's tuples. Initially, we have a read
* lock acquired by _bt_step when we stepped onto the page. If we find
* a tuple we need to delete, we trade in the read lock for an exclusive
* write lock; after that, we hold the write lock until we step off the
* page (fortunately, _bt_relbuf doesn't care which kind of lock it's
* releasing). This should minimize the amount of work needed per page.
* We use a standard IndexScanDesc scan object, but to speed up the
* loop, we skip most of the wrapper layers of index_getnext and
* instead call _bt_step directly. This implies holding buffer lock
* on a target page throughout the loop over the page's tuples.
* Initially, we have a read lock acquired by _bt_step when we stepped
* onto the page. If we find a tuple we need to delete, we trade in
* the read lock for an exclusive write lock; after that, we hold the
* write lock until we step off the page (fortunately, _bt_relbuf
* doesn't care which kind of lock it's releasing). This should
* minimize the amount of work needed per page.
*/
scan = index_beginscan(rel, false, 0, (ScanKey) NULL);
so = (BTScanOpaque) scan->opaque;
@ -607,9 +608,10 @@ btbulkdelete(PG_FUNCTION_ARGS)
{
/*
* If this is first deletion on this page, trade in read
* lock for a really-exclusive write lock. Then, step back
* one and re-examine the item, because someone else might
* have inserted an item while we weren't holding the lock!
* lock for a really-exclusive write lock. Then, step
* back one and re-examine the item, because someone else
* might have inserted an item while we weren't holding
* the lock!
*/
if (blkno != lockedBlock)
{
@ -632,8 +634,8 @@ btbulkdelete(PG_FUNCTION_ARGS)
* We need to back up the scan one item so that the next
* cycle will re-examine the same offnum on this page.
*
* For now, just hack the current-item index. Will need
* to be smarter when deletion includes removal of empty
* For now, just hack the current-item index. Will need to
* be smarter when deletion includes removal of empty
* index pages.
*/
current->ip_posid--;

6
src/backend/access/nbtree/nbtsearch.c
View File

@ -8,7 +8,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtsearch.c,v 1.68 2001/10/06 23:21:43 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtsearch.c,v 1.69 2001/10/25 05:49:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -590,8 +590,8 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
/*
* At this point we are positioned at the first item >= scan key, or
* possibly at the end of a page on which all the existing items are
* greater than the scan key and we know that everything on later pages
* is less than or equal to scan key.
* greater than the scan key and we know that everything on later
* pages is less than or equal to scan key.
*
* We could step forward in the latter case, but that'd be a waste of
* time if we want to scan backwards. So, it's now time to examine

4
src/backend/access/nbtree/nbtsort.c
View File

@ -35,7 +35,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtsort.c,v 1.60 2001/03/22 03:59:15 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtsort.c,v 1.61 2001/10/25 05:49:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -354,7 +354,6 @@ _bt_buildadd(Relation index, BTPageState *state, BTItem bti)
if (pgspc < btisz || pgspc < state->btps_full)
{
/*
* Item won't fit on this page, or we feel the page is full enough
* already. Finish off the page and write it out.
@ -544,7 +543,6 @@ _bt_load(Relation index, BTSpool *btspool, BTSpool *btspool2)
if (merge)
{
/*
* Another BTSpool for dead tuples exists. Now we have to merge
* btspool and btspool2.

3
src/backend/access/nbtree/nbtstrat.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/Attic/nbtstrat.c,v 1.14 2001/05/30 19:53:40 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/Attic/nbtstrat.c,v 1.15 2001/10/25 05:49:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -134,5 +134,4 @@ _bt_invokestrat(Relation rel,
return (RelationInvokeStrategy(rel, &BTEvaluationData, attno, strat,
left, right));
}
#endif

4
src/backend/access/nbtree/nbtutils.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtutils.c,v 1.46 2001/10/06 23:21:43 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtutils.c,v 1.47 2001/10/25 05:49:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -221,7 +221,6 @@ _bt_orderkeys(Relation relation, BTScanOpaque so)
/* We can short-circuit most of the work if there's just one key */
if (numberOfKeys == 1)
{
/*
* We don't use indices for 'A is null' and 'A is not null'
* currently and 'A < = > <> NULL' will always fail - so qual is
@ -317,7 +316,6 @@ _bt_orderkeys(Relation relation, BTScanOpaque so)
}
else
{
/*
* No "=" for this key, so we're done with required keys
*/

123
src/backend/access/rtree/rtree.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtree.c,v 1.65 2001/10/06 23:21:43 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtree.c,v 1.66 2001/10/25 05:49:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -194,11 +194,11 @@ rtbuildCallback(Relation index,
}
/*
* Since we already have the index relation locked, we call
* rtdoinsert directly. Normal access method calls dispatch
* through rtinsert, which locks the relation for write. This is
* the right thing to do if you're inserting single tups, but not
* when you're initializing the whole index at once.
* Since we already have the index relation locked, we call rtdoinsert
* directly. Normal access method calls dispatch through rtinsert,
* which locks the relation for write. This is the right thing to do
* if you're inserting single tups, but not when you're initializing
* the whole index at once.
*/
res = rtdoinsert(index, itup, &buildstate->rtState);
@ -223,6 +223,7 @@ rtinsert(PG_FUNCTION_ARGS)
Datum *datum = (Datum *) PG_GETARG_POINTER(1);
char *nulls = (char *) PG_GETARG_POINTER(2);
ItemPointer ht_ctid = (ItemPointer) PG_GETARG_POINTER(3);
#ifdef NOT_USED
Relation heapRel = (Relation) PG_GETARG_POINTER(4);
#endif
@ -376,9 +377,8 @@ rttighten(Relation r,
PointerGetDatum(&newd_size));
/*
* If newd_size == 0 we have degenerate rectangles, so we
* don't know if there was any change, so we have to
* assume there was.
* If newd_size == 0 we have degenerate rectangles, so we don't know
* if there was any change, so we have to assume there was.
*/
if ((newd_size == 0) || (newd_size != old_size))
{
@ -386,7 +386,6 @@ rttighten(Relation r,
if (td->attrs[0]->attlen < 0)
{
/*
* This is an internal page, so 'oldud' had better be a union
* (constant-length) key, too. (See comment below.)
@ -500,10 +499,10 @@ rtdosplit(Relation r,
res = (InsertIndexResult) palloc(sizeof(InsertIndexResultData));
/*
* spl_left contains a list of the offset numbers of the
* tuples that will go to the left page. For each offset
* number, get the tuple item, then add the item to the
* left page. Similarly for the right side.
* spl_left contains a list of the offset numbers of the tuples that
* will go to the left page. For each offset number, get the tuple
* item, then add the item to the left page. Similarly for the right
* side.
*/
/* fill left node */
@ -765,7 +764,8 @@ rtpicksplit(Relation r,
int total_num_tuples,
num_tuples_without_seeds,
max_after_split; /* in Guttman's lingo, (M - m) */
float diff; /* diff between cost of putting tuple left or right */
float diff; /* diff between cost of putting tuple left
* or right */
SPLITCOST *cost_vector;
int n;
@ -852,7 +852,6 @@ rtpicksplit(Relation r,
if (firsttime)
{
/*
* There is no possible split except to put the new item on its
* own page. Since we still have to compute the union rectangles,
@ -885,25 +884,25 @@ rtpicksplit(Relation r,
/*
* Now split up the regions between the two seeds.
*
* The cost_vector array will contain hints for determining where
* each tuple should go. Each record in the array will contain
* a boolean, choose_left, that indicates which node the tuple
* prefers to be on, and the absolute difference in cost between
* putting the tuple in its favored node and in the other node.
* The cost_vector array will contain hints for determining where each
* tuple should go. Each record in the array will contain a boolean,
* choose_left, that indicates which node the tuple prefers to be on,
* and the absolute difference in cost between putting the tuple in
* its favored node and in the other node.
*
* Later, we will sort the cost_vector in descending order by cost
* difference, and consider the tuples in that order for
* placement. That way, the tuples that *really* want to be in
* one node or the other get to choose first, and the tuples that
* don't really care choose last.
* difference, and consider the tuples in that order for placement.
* That way, the tuples that *really* want to be in one node or the
* other get to choose first, and the tuples that don't really care
* choose last.
*
* First, build the cost_vector array. The new index tuple will
* also be handled in this loop, and represented in the array,
* with i==newitemoff.
* First, build the cost_vector array. The new index tuple will also be
* handled in this loop, and represented in the array, with
* i==newitemoff.
*
* In the case of variable size tuples it is possible that we only
* have the two seeds and no other tuples, in which case we don't
* do any of this cost_vector stuff.
* In the case of variable size tuples it is possible that we only have
* the two seeds and no other tuples, in which case we don't do any of
* this cost_vector stuff.
*/
/* to keep compiler quiet */
@ -943,21 +942,21 @@ rtpicksplit(Relation r,
}
/*
* Sort the array. The function qsort_comp_splitcost is
* set up "backwards", to provided descending order.
* Sort the array. The function qsort_comp_splitcost is set up
* "backwards", to provided descending order.
*/
qsort(cost_vector, num_tuples_without_seeds, sizeof(SPLITCOST),
&qsort_comp_splitcost);
}
/*
* Now make the final decisions about where each tuple will go,
* and build the vectors to return in the SPLITVEC record.
* Now make the final decisions about where each tuple will go, and
* build the vectors to return in the SPLITVEC record.
*
* The cost_vector array contains (descriptions of) all the
* tuples, in the order that we want to consider them, so we
* we just iterate through it and place each tuple in left
* or right nodes, according to the criteria described below.
* The cost_vector array contains (descriptions of) all the tuples, in
* the order that we want to consider them, so we we just iterate
* through it and place each tuple in left or right nodes, according
* to the criteria described below.
*/
left = v->spl_left;
@ -965,9 +964,9 @@ rtpicksplit(Relation r,
right = v->spl_right;
v->spl_nright = 0;
/* Place the seeds first.
* left avail space, left union, right avail space, and right
* union have already been adjusted for the seeds.
/*
* Place the seeds first. left avail space, left union, right avail
* space, and right union have already been adjusted for the seeds.
*/
*left++ = seed_1;
@ -983,8 +982,8 @@ rtpicksplit(Relation r,
choose_left;
/*
* We need to figure out which page needs the least
* enlargement in order to store the item.
* We need to figure out which page needs the least enlargement in
* order to store the item.
*/
i = cost_vector[n].offset_number;
@ -1021,20 +1020,20 @@ rtpicksplit(Relation r,
* Guttman's algorithm actually has two factors to consider (in
* order): 1. if one node has so many tuples already assigned to
* it that the other needs all the rest in order to satisfy the
* condition that neither node has fewer than m tuples, then
* that is decisive; 2. otherwise, choose the page that shows
* the smaller enlargement of its union area.
* condition that neither node has fewer than m tuples, then that
* is decisive; 2. otherwise, choose the page that shows the
* smaller enlargement of its union area.
*
* I have chosen m = M/2, where M is the maximum number of
* tuples on a page. (Actually, this is only strictly
* true for fixed size tuples. For variable size tuples,
* there still might have to be only one tuple on a page,
* if it is really big. But even with variable size
* tuples we still try to get m as close as possible to M/2.)
* I have chosen m = M/2, where M is the maximum number of tuples on
* a page. (Actually, this is only strictly true for fixed size
* tuples. For variable size tuples, there still might have to be
* only one tuple on a page, if it is really big. But even with
* variable size tuples we still try to get m as close as possible
* to M/2.)
*
* The question of which page shows the smaller enlargement of
* its union area has already been answered, and the answer
* stored in the choose_left field of the SPLITCOST record.
* The question of which page shows the smaller enlargement of its
* union area has already been answered, and the answer stored in
* the choose_left field of the SPLITCOST record.
*/
left_feasible = (left_avail_space >= item_1_sz &&
((left_avail_space - item_1_sz) >= newitemsz ||
@ -1045,10 +1044,10 @@ rtpicksplit(Relation r,
if (left_feasible && right_feasible)
{
/*
* Both feasible, use Guttman's algorithm.
* First check the m condition described above, and if
* that doesn't apply, choose the page with the smaller
* enlargement of its union area.
* Both feasible, use Guttman's algorithm. First check the m
* condition described above, and if that doesn't apply,
* choose the page with the smaller enlargement of its union
* area.
*/
if (v->spl_nleft > max_after_split)
choose_left = false;
@ -1090,9 +1089,7 @@ rtpicksplit(Relation r,
}
if (num_tuples_without_seeds > 0)
{
pfree(cost_vector);
}
*left = *right = InvalidOffsetNumber; /* add ending sentinels */
@ -1282,6 +1279,7 @@ qsort_comp_splitcost(const void *a, const void *b)
float diff =
((SPLITCOST *) a)->cost_differential -
((SPLITCOST *) b)->cost_differential;
if (diff < 0)
return 1;
else if (diff > 0)
@ -1342,7 +1340,6 @@ _rtdump(Relation r)
ReleaseBuffer(buf);
}
}
#endif /* defined RTDEBUG */
void

3
src/backend/access/rtree/rtscan.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtscan.c,v 1.38 2001/07/15 22:48:16 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtscan.c,v 1.39 2001/10/25 05:49:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -380,7 +380,6 @@ adjustiptr(IndexScanDesc s,
}
else
{
/*
* remember that we're before the current
* tuple

3
src/backend/access/rtree/rtstrat.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtstrat.c,v 1.17 2001/05/30 19:53:40 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtstrat.c,v 1.18 2001/10/25 05:49:22 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -221,7 +221,6 @@ RelationInvokeRTStrategy(Relation r,
return (RelationInvokeStrategy(r, &RTEvaluationData, attnum, s,
left, right));
}
#endif
RegProcedure

84
src/backend/access/transam/clog.c
View File

@ -13,7 +13,7 @@
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $Header: /cvsroot/pgsql/src/backend/access/transam/clog.c,v 1.4 2001/09/29 04:02:21 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/transam/clog.c,v 1.5 2001/10/25 05:49:22 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -121,10 +121,12 @@
typedef enum
{
CLOG_PAGE_EMPTY,/* CLOG buffer is not in use */
CLOG_PAGE_READ_IN_PROGRESS, /* CLOG page is being read in */
CLOG_PAGE_READ_IN_PROGRESS, /* CLOG page is being read
* in */
CLOG_PAGE_CLEAN,/* CLOG page is valid and not dirty */
CLOG_PAGE_DIRTY,/* CLOG page is valid but needs write */
CLOG_PAGE_WRITE_IN_PROGRESS /* CLOG page is being written out in */
CLOG_PAGE_WRITE_IN_PROGRESS /* CLOG page is being
* written out in */
} ClogPageStatus;
/*
@ -134,14 +136,15 @@ typedef struct ClogCtlData
{
/*
* Info for each buffer slot. Page number is undefined when status is
* EMPTY. lru_count is essentially the number of operations since last
* use of this page; the page with highest lru_count is the best candidate
* to replace.
* EMPTY. lru_count is essentially the number of operations since
* last use of this page; the page with highest lru_count is the best
* candidate to replace.
*/
char *page_buffer[NUM_CLOG_BUFFERS];
ClogPageStatus page_status[NUM_CLOG_BUFFERS];
int page_number[NUM_CLOG_BUFFERS];
unsigned int page_lru_count[NUM_CLOG_BUFFERS];
/*
* latest_page_number is the page number of the current end of the
* CLOG; this is not critical data, since we use it only to avoid
@ -489,11 +492,12 @@ WriteCLOGPage(int slotno)
* update on this page will mark it dirty again. NB: we are assuming
* that read/write of the page status field is atomic, since we change
* the state while not holding control lock. However, we cannot set
* this state any sooner, or we'd possibly fool a previous writer
* into thinking he's successfully dumped the page when he hasn't.
* (Scenario: other writer starts, page is redirtied, we come along and
* set WRITE_IN_PROGRESS again, other writer completes and sets CLEAN
* because redirty info has been lost, then we think it's clean too.)
* this state any sooner, or we'd possibly fool a previous writer into
* thinking he's successfully dumped the page when he hasn't.
* (Scenario: other writer starts, page is redirtied, we come along
* and set WRITE_IN_PROGRESS again, other writer completes and sets
* CLEAN because redirty info has been lost, then we think it's clean
* too.)
*/
ClogCtl->page_status[slotno] = CLOG_PAGE_WRITE_IN_PROGRESS;
@ -533,8 +537,8 @@ CLOGPhysicalReadPage(int pageno, int slotno)
/*
* In a crash-and-restart situation, it's possible for us to receive
* commands to set the commit status of transactions whose bits are
* in already-truncated segments of the commit log (see notes in
* commands to set the commit status of transactions whose bits are in
* already-truncated segments of the commit log (see notes in
* CLOGPhysicalWritePage). Hence, if we are InRecovery, allow the
* case where the file doesn't exist, and return zeroes instead.
*/
@ -578,16 +582,17 @@ CLOGPhysicalWritePage(int pageno, int slotno)
ClogFileName(path, segno);
/*
* If the file doesn't already exist, we should create it. It is possible
* for this to need to happen when writing a page that's not first in
* its segment; we assume the OS can cope with that. (Note: it might seem
* that it'd be okay to create files only when ZeroCLOGPage is called for
* the first page of a segment. However, if after a crash and restart
* the REDO logic elects to replay the log from a checkpoint before the
* latest one, then it's possible that we will get commands to set
* transaction status of transactions that have already been truncated
* from the commit log. Easiest way to deal with that is to accept
* references to nonexistent files here and in CLOGPhysicalReadPage.)
* If the file doesn't already exist, we should create it. It is
* possible for this to need to happen when writing a page that's not
* first in its segment; we assume the OS can cope with that. (Note:
* it might seem that it'd be okay to create files only when
* ZeroCLOGPage is called for the first page of a segment. However,
* if after a crash and restart the REDO logic elects to replay the
* log from a checkpoint before the latest one, then it's possible
* that we will get commands to set transaction status of transactions
* that have already been truncated from the commit log. Easiest way
* to deal with that is to accept references to nonexistent files here
* and in CLOGPhysicalReadPage.)
*/
fd = BasicOpenFile(path, O_RDWR | PG_BINARY, S_IRUSR | S_IWUSR);
if (fd < 0)
@ -649,9 +654,8 @@ SelectLRUCLOGPage(int pageno)
}
/*
* If we find any EMPTY slot, just select that one.
* Else locate the least-recently-used slot that isn't the
* latest CLOG page.
* If we find any EMPTY slot, just select that one. Else locate
* the least-recently-used slot that isn't the latest CLOG page.
*/
for (slotno = 0; slotno < NUM_CLOG_BUFFERS; slotno++)
{
@ -672,10 +676,10 @@ SelectLRUCLOGPage(int pageno)
return bestslot;
/*
* We need to do I/O. Normal case is that we have to write it out,
* but it's possible in the worst case to have selected a read-busy
* page. In that case we use ReadCLOGPage to wait for the read to
* complete.
* We need to do I/O. Normal case is that we have to write it
* out, but it's possible in the worst case to have selected a
* read-busy page. In that case we use ReadCLOGPage to wait for
* the read to complete.
*/
if (ClogCtl->page_status[bestslot] == CLOG_PAGE_READ_IN_PROGRESS)
(void) ReadCLOGPage(ClogCtl->page_number[bestslot]);
@ -683,9 +687,9 @@ SelectLRUCLOGPage(int pageno)
WriteCLOGPage(bestslot);
/*
* Now loop back and try again. This is the easiest way of dealing
* with corner cases such as the victim page being re-dirtied while
* we wrote it.
* Now loop back and try again. This is the easiest way of
* dealing with corner cases such as the victim page being
* re-dirtied while we wrote it.
*/
}
}
@ -736,6 +740,7 @@ CheckPointCLOG(void)
for (slotno = 0; slotno < NUM_CLOG_BUFFERS; slotno++)
{
WriteCLOGPage(slotno);
/*
* We cannot assert that the slot is clean now, since another
* process might have re-dirtied it already. That's okay.
@ -813,15 +818,16 @@ TruncateCLOG(TransactionId oldestXact)
/*
* Scan CLOG shared memory and remove any pages preceding the cutoff
* page, to ensure we won't rewrite them later. (Any dirty pages
* should have been flushed already during the checkpoint, we're
* just being extra careful here.)
* should have been flushed already during the checkpoint, we're just
* being extra careful here.)
*/
LWLockAcquire(CLogControlLock, LW_EXCLUSIVE);
restart:;
/*
* While we are holding the lock, make an important safety check:
* the planned cutoff point must be <= the current CLOG endpoint page.
* While we are holding the lock, make an important safety check: the
* planned cutoff point must be <= the current CLOG endpoint page.
* Otherwise we have already wrapped around, and proceeding with the
* truncation would risk removing the current CLOG segment.
*/
@ -838,6 +844,7 @@ restart:;
continue;
if (!CLOGPagePrecedes(ClogCtl->page_number[slotno], cutoffPage))
continue;
/*
* If page is CLEAN, just change state to EMPTY (expected case).
*/
@ -846,6 +853,7 @@ restart:;
ClogCtl->page_status[slotno] = CLOG_PAGE_EMPTY;
continue;
}
/*
* Hmm, we have (or may have) I/O operations acting on the page,
* so we've got to wait for them to finish and then start again.
@ -929,8 +937,10 @@ CLOGPagePrecedes(int page1, int page2)
TransactionId xid2;
xid1 = (TransactionId) page1 *CLOG_XACTS_PER_PAGE;
xid1 += FirstNormalTransactionId;
xid2 = (TransactionId) page2 *CLOG_XACTS_PER_PAGE;
xid2 += FirstNormalTransactionId;
return TransactionIdPrecedes(xid1, xid2);

Some files were not shown because too many files have changed in this diff Show More