database/postgres
database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-04-20 00:42:27 +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_oideq(ArrayType *array, Oid value);
int32 array_all_oidne(ArrayType *array, Oid value); int32 array_all_oidne(ArrayType *array, Oid value);
#endif #endif
/* /*

358
contrib/btree_gist/btree_gist.c
View File

@ -8,21 +8,24 @@
#include "utils/geo_decls.h" #include "utils/geo_decls.h"
#include "utils/elog.h" #include "utils/elog.h"
typedef int (*CMPFUNC)(const void *a, const void *b); typedef int (*CMPFUNC) (const void *a, const void *b);
typedef void (*BINARY_UNION)(Datum*, char*); typedef void (*BINARY_UNION) (Datum *, char *);
typedef struct intkey { typedef struct intkey
{
int4 lower; int4 lower;
int4 upper; int4 upper;
} INT4KEY; } INT4KEY;
typedef struct tskey { typedef struct tskey
{
Timestamp lower; Timestamp lower;
Timestamp upper; Timestamp upper;
} TSKEY; } TSKEY;
/* used for sorting */ /* used for sorting */
typedef struct rix { typedef struct rix
{
int index; int index;
char *r; char *r;
} RIX; } RIX;
@ -113,7 +116,7 @@ static int tskey_cmp(const void *a, const void *b);
/* /*
** Common btree-function (for all ops) ** Common btree-function (for all ops)
*/ */
static GIST_SPLITVEC * btree_picksplit(bytea *entryvec, GIST_SPLITVEC *v, static GIST_SPLITVEC *btree_picksplit(bytea *entryvec, GIST_SPLITVEC *v,
BINARY_UNION bu, CMPFUNC cmp); BINARY_UNION bu, CMPFUNC cmp);
PG_FUNCTION_INFO_V1(btree_decompress); PG_FUNCTION_INFO_V1(btree_decompress);
@ -126,57 +129,60 @@ Datum btree_decompress(PG_FUNCTION_ARGS);
Datum Datum
gint4_compress(PG_FUNCTION_ARGS) gint4_compress(PG_FUNCTION_ARGS)
{ {
GISTENTRY *entry=(GISTENTRY*)PG_GETARG_POINTER(0); GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
GISTENTRY *retval; GISTENTRY *retval;
if ( entry->leafkey) { if (entry->leafkey)
{
INT4KEY *r = palloc(sizeof(INT4KEY)); INT4KEY *r = palloc(sizeof(INT4KEY));
retval = palloc(sizeof(GISTENTRY)); retval = palloc(sizeof(GISTENTRY));
r->lower = r->upper = (entry->key); r->lower = r->upper = (entry->key);
gistentryinit(*retval, PointerGetDatum(r), entry->rel, entry->page, gistentryinit(*retval, PointerGetDatum(r), entry->rel, entry->page,
entry->offset, sizeof(INT4KEY),FALSE); entry->offset, sizeof(INT4KEY), FALSE);
} else {
retval = entry;
} }
PG_RETURN_POINTER( retval ); else
retval = entry;
PG_RETURN_POINTER(retval);
} }
Datum Datum
gint4_consistent(PG_FUNCTION_ARGS) gint4_consistent(PG_FUNCTION_ARGS)
{ {
GISTENTRY *entry = (GISTENTRY*) PG_GETARG_POINTER(0); GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
int4 query = PG_GETARG_INT32(1); int4 query = PG_GETARG_INT32(1);
INT4KEY *kkk= (INT4KEY *)DatumGetPointer(entry->key); INT4KEY *kkk = (INT4KEY *) DatumGetPointer(entry->key);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
bool retval; bool retval;
switch(strategy) { switch (strategy)
{
case BTLessEqualStrategyNumber: case BTLessEqualStrategyNumber:
retval = ( query >= kkk->lower ); retval = (query >= kkk->lower);
break; break;
case BTLessStrategyNumber: case BTLessStrategyNumber:
if (GIST_LEAF(entry)) if (GIST_LEAF(entry))
retval = ( query > kkk->lower ); retval = (query > kkk->lower);
else else
retval = ( query >= kkk->lower ); retval = (query >= kkk->lower);
break; break;
case BTEqualStrategyNumber: case BTEqualStrategyNumber:
/* in leaf page kkk->lower always = kkk->upper */ /* in leaf page kkk->lower always = kkk->upper */
if (GIST_LEAF(entry)) if (GIST_LEAF(entry))
retval = ( query == kkk->lower ); retval = (query == kkk->lower);
else else
retval = ( kkk->lower <= query && query <= kkk->upper ); retval = (kkk->lower <= query && query <= kkk->upper);
break; break;
case BTGreaterStrategyNumber: case BTGreaterStrategyNumber:
if (GIST_LEAF(entry)) if (GIST_LEAF(entry))
retval = ( query < kkk->upper ); retval = (query < kkk->upper);
else else
retval = ( query <= kkk->upper ); retval = (query <= kkk->upper);
break; break;
case BTGreaterEqualStrategyNumber: case BTGreaterEqualStrategyNumber:
retval = ( query <= kkk->upper ); retval = (query <= kkk->upper);
break; break;
default: default:
retval = FALSE; retval = FALSE;
@ -187,58 +193,63 @@ gint4_consistent(PG_FUNCTION_ARGS)
Datum Datum
gint4_union(PG_FUNCTION_ARGS) gint4_union(PG_FUNCTION_ARGS)
{ {
bytea *entryvec = (bytea*) PG_GETARG_POINTER(0); bytea *entryvec = (bytea *) PG_GETARG_POINTER(0);
int i, numranges; int i,
INT4KEY *cur, *out=palloc(sizeof(INT4KEY)); numranges;
INT4KEY *cur,
*out = palloc(sizeof(INT4KEY));
numranges = (VARSIZE(entryvec) - VARHDRSZ)/sizeof(GISTENTRY); numranges = (VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY);
*(int*) PG_GETARG_POINTER(1) = sizeof(INT4KEY); *(int *) PG_GETARG_POINTER(1) = sizeof(INT4KEY);
cur = (INT4KEY *)DatumGetPointer( (((GISTENTRY *)(VARDATA(entryvec)))[0].key) ); cur = (INT4KEY *) DatumGetPointer((((GISTENTRY *) (VARDATA(entryvec)))[0].key));
out->lower = cur->lower; out->lower = cur->lower;
out->upper = cur->upper; 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; cur = (INT4KEY *) DatumGetPointer((((GISTENTRY *) (VARDATA(entryvec)))[i].key));
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 ); PG_RETURN_POINTER(out);
} }
Datum Datum
gint4_penalty(PG_FUNCTION_ARGS) gint4_penalty(PG_FUNCTION_ARGS)
{ {
INT4KEY *origentry = (INT4KEY*) DatumGetPointer( ((GISTENTRY*) PG_GETARG_POINTER(0))->key ); INT4KEY *origentry = (INT4KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key);
INT4KEY *newentry = (INT4KEY*) DatumGetPointer( ((GISTENTRY*) PG_GETARG_POINTER(1))->key ); INT4KEY *newentry = (INT4KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key);
float *result = (float*) PG_GETARG_POINTER(2); float *result = (float *) PG_GETARG_POINTER(2);
*result = Max( newentry->upper - origentry->upper, 0 ) + *result = Max(newentry->upper - origentry->upper, 0) +
Max( origentry->lower - newentry->lower, 0 ); Max(origentry->lower - newentry->lower, 0);
PG_RETURN_POINTER( result ); PG_RETURN_POINTER(result);
} }
Datum Datum
gint4_picksplit(PG_FUNCTION_ARGS) gint4_picksplit(PG_FUNCTION_ARGS)
{ {
PG_RETURN_POINTER( btree_picksplit( PG_RETURN_POINTER(btree_picksplit(
(bytea*)PG_GETARG_POINTER(0), (bytea *) PG_GETARG_POINTER(0),
(GIST_SPLITVEC*)PG_GETARG_POINTER(1), (GIST_SPLITVEC *) PG_GETARG_POINTER(1),
gint4_binary_union, gint4_binary_union,
int4key_cmp int4key_cmp
) ); ));
} }
Datum Datum
gint4_same(PG_FUNCTION_ARGS) gint4_same(PG_FUNCTION_ARGS)
{ {
INT4KEY *b1 = (INT4KEY*) PG_GETARG_POINTER(0); INT4KEY *b1 = (INT4KEY *) PG_GETARG_POINTER(0);
INT4KEY *b2 = (INT4KEY*) PG_GETARG_POINTER(1); INT4KEY *b2 = (INT4KEY *) PG_GETARG_POINTER(1);
bool *result = (bool*) PG_GETARG_POINTER(2); bool *result = (bool *) PG_GETARG_POINTER(2);
*result = ( b1->lower == b2->lower && b1->upper == b2->upper ) ? TRUE : FALSE; *result = (b1->lower == b2->lower && b1->upper == b2->upper) ? TRUE : FALSE;
PG_RETURN_POINTER(result); PG_RETURN_POINTER(result);
} }
@ -246,26 +257,31 @@ static void
gint4_binary_union(Datum *r1, char *r2) gint4_binary_union(Datum *r1, char *r2)
{ {
INT4KEY *b1; INT4KEY *b1;
INT4KEY *b2 = (INT4KEY*) r2; INT4KEY *b2 = (INT4KEY *) r2;
if ( ! DatumGetPointer( *r1 ) ) {
*r1 = PointerGetDatum( palloc( sizeof(INT4KEY) ) ); if (!DatumGetPointer(*r1))
b1 = (INT4KEY*)DatumGetPointer( *r1 ); {
*r1 = PointerGetDatum(palloc(sizeof(INT4KEY)));
b1 = (INT4KEY *) DatumGetPointer(*r1);
b1->upper = b2->upper; b1->upper = b2->upper;
b1->lower = b2->lower; b1->lower = b2->lower;
} else { }
b1 = (INT4KEY*)DatumGetPointer( *r1 ); else
{
b1 = (INT4KEY *) DatumGetPointer(*r1);
b1->lower = ( b1->lower > b2->lower ) ? b1->lower = (b1->lower > b2->lower) ?
b2->lower : b1->lower; b2->lower : b1->lower;
b1->upper = ( b1->upper > b2->upper ) ? b1->upper = (b1->upper > b2->upper) ?
b1->upper : b2->upper; b1->upper : b2->upper;
} }
} }
static int 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 ); {
return (((INT4KEY *) (((RIX *) a)->r))->lower - ((INT4KEY *) (((RIX *) b)->r))->lower);
} }
/************************************************** /**************************************************
@ -275,71 +291,78 @@ int4key_cmp(const void *a, const void *b) {
Datum Datum
gts_compress(PG_FUNCTION_ARGS) gts_compress(PG_FUNCTION_ARGS)
{ {
GISTENTRY *entry=(GISTENTRY*)PG_GETARG_POINTER(0); GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
GISTENTRY *retval; GISTENTRY *retval;
if ( entry->leafkey) { if (entry->leafkey)
TSKEY *r = (TSKEY *)palloc( sizeof(TSKEY) ); {
TSKEY *r = (TSKEY *) palloc(sizeof(TSKEY));
retval = palloc(sizeof(GISTENTRY)); retval = palloc(sizeof(GISTENTRY));
if ( entry->key ) { if (entry->key)
r->lower = r->upper = *(Timestamp*)(entry->key); {
r->lower = r->upper = *(Timestamp *) (entry->key);
gistentryinit(*retval, PointerGetDatum(r), gistentryinit(*retval, PointerGetDatum(r),
entry->rel, entry->page, entry->rel, entry->page,
entry->offset, sizeof(TSKEY), FALSE); entry->offset, sizeof(TSKEY), FALSE);
} else { }
else
{
gistentryinit(*retval, PointerGetDatum(NULL), gistentryinit(*retval, PointerGetDatum(NULL),
entry->rel, entry->page, entry->rel, entry->page,
entry->offset, 0, FALSE); entry->offset, 0, FALSE);
} }
} else {
retval = entry;
} }
PG_RETURN_POINTER( retval ); else
retval = entry;
PG_RETURN_POINTER(retval);
} }
Datum Datum
gts_consistent(PG_FUNCTION_ARGS) gts_consistent(PG_FUNCTION_ARGS)
{ {
GISTENTRY *entry = (GISTENTRY*) PG_GETARG_POINTER(0); GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
Timestamp *query = (Timestamp *)PG_GETARG_POINTER(1); Timestamp *query = (Timestamp *) PG_GETARG_POINTER(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
bool retval; bool retval;
TSKEY *key; TSKEY *key;
/*
** 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) { /*
* * 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)
{
case BTLessEqualStrategyNumber: case BTLessEqualStrategyNumber:
retval = TSGE( query, &(key->lower) ); retval = TSGE(query, &(key->lower));
break; break;
case BTLessStrategyNumber: case BTLessStrategyNumber:
if (GIST_LEAF(entry)) if (GIST_LEAF(entry))
retval = TSGT( query, &(key->lower) ); retval = TSGT(query, &(key->lower));
else else
retval = TSGE( query, &(key->lower) ); retval = TSGE(query, &(key->lower));
break; break;
case BTEqualStrategyNumber: case BTEqualStrategyNumber:
/* in leaf page key->lower always = key->upper */ /* in leaf page key->lower always = key->upper */
if (GIST_LEAF(entry)) if (GIST_LEAF(entry))
retval = TSEQ( query, &(key->lower)); retval = TSEQ(query, &(key->lower));
else else
retval = ( TSLE( &(key->lower), query ) && TSLE( query, &(key->upper) ) ); retval = (TSLE(&(key->lower), query) && TSLE(query, &(key->upper)));
break; break;
case BTGreaterStrategyNumber: case BTGreaterStrategyNumber:
if (GIST_LEAF(entry)) if (GIST_LEAF(entry))
retval = TSLT( query, &(key->upper) ); retval = TSLT(query, &(key->upper));
else else
retval = TSLE( query, &(key->upper) ); retval = TSLE(query, &(key->upper));
break; break;
case BTGreaterEqualStrategyNumber: case BTGreaterEqualStrategyNumber:
retval = TSLE( query, &(key->upper) ); retval = TSLE(query, &(key->upper));
break; break;
default: default:
retval = FALSE; retval = FALSE;
@ -350,77 +373,83 @@ gts_consistent(PG_FUNCTION_ARGS)
Datum Datum
gts_union(PG_FUNCTION_ARGS) gts_union(PG_FUNCTION_ARGS)
{ {
bytea *entryvec = (bytea*) PG_GETARG_POINTER(0); bytea *entryvec = (bytea *) PG_GETARG_POINTER(0);
int i, numranges; int i,
TSKEY *cur, *out=palloc(sizeof(TSKEY)); numranges;
TSKEY *cur,
*out = palloc(sizeof(TSKEY));
numranges = (VARSIZE(entryvec) - VARHDRSZ)/sizeof(GISTENTRY); numranges = (VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY);
*(int*) PG_GETARG_POINTER(1) = sizeof(TSKEY); *(int *) PG_GETARG_POINTER(1) = sizeof(TSKEY);
cur = (TSKEY *)DatumGetPointer( (((GISTENTRY *)(VARDATA(entryvec)))[0].key) ); cur = (TSKEY *) DatumGetPointer((((GISTENTRY *) (VARDATA(entryvec)))[0].key));
out->lower = cur->lower; out->lower = cur->lower;
out->upper = cur->upper; 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; cur = (TSKEY *) DatumGetPointer((((GISTENTRY *) (VARDATA(entryvec)))[i].key));
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 ); PG_RETURN_POINTER(out);
} }
Datum Datum
gts_penalty(PG_FUNCTION_ARGS) gts_penalty(PG_FUNCTION_ARGS)
{ {
TSKEY *origentry = (TSKEY*) DatumGetPointer( ((GISTENTRY*) PG_GETARG_POINTER(0))->key ); TSKEY *origentry = (TSKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key);
TSKEY *newentry = (TSKEY*) DatumGetPointer( ((GISTENTRY*) PG_GETARG_POINTER(1))->key ); TSKEY *newentry = (TSKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key);
float *result = (float*) PG_GETARG_POINTER(2); float *result = (float *) PG_GETARG_POINTER(2);
Interval *intr; Interval *intr;
intr = DatumGetIntervalP( DirectFunctionCall2( intr = DatumGetIntervalP(DirectFunctionCall2(
timestamp_mi, timestamp_mi,
TimestampGetDatum( newentry->upper ), TimestampGetDatum(newentry->upper),
TimestampGetDatum( origentry->upper )) ); TimestampGetDatum(origentry->upper)));
/* see interval_larger */ /* see interval_larger */
*result = Max( intr->time+intr->month * (30.0 * 86400),0 ); *result = Max(intr->time + intr->month * (30.0 * 86400), 0);
pfree( intr ); pfree(intr);
intr = DatumGetIntervalP( DirectFunctionCall2( intr = DatumGetIntervalP(DirectFunctionCall2(
timestamp_mi, timestamp_mi,
TimestampGetDatum( origentry->lower ), TimestampGetDatum(origentry->lower),
TimestampGetDatum( newentry->lower )) ); TimestampGetDatum(newentry->lower)));
/* see interval_larger */ /* see interval_larger */
*result += Max( intr->time+intr->month * (30.0 * 86400),0 ); *result += Max(intr->time + intr->month * (30.0 * 86400), 0);
pfree( intr ); pfree(intr);
PG_RETURN_POINTER( result ); PG_RETURN_POINTER(result);
} }
Datum Datum
gts_picksplit(PG_FUNCTION_ARGS) gts_picksplit(PG_FUNCTION_ARGS)
{ {
PG_RETURN_POINTER( btree_picksplit( PG_RETURN_POINTER(btree_picksplit(
(bytea*)PG_GETARG_POINTER(0), (bytea *) PG_GETARG_POINTER(0),
(GIST_SPLITVEC*)PG_GETARG_POINTER(1), (GIST_SPLITVEC *) PG_GETARG_POINTER(1),
gts_binary_union, gts_binary_union,
tskey_cmp tskey_cmp
) ); ));
} }
Datum Datum
gts_same(PG_FUNCTION_ARGS) gts_same(PG_FUNCTION_ARGS)
{ {
TSKEY *b1 = (TSKEY*) PG_GETARG_POINTER(0); TSKEY *b1 = (TSKEY *) PG_GETARG_POINTER(0);
TSKEY *b2 = (TSKEY*) PG_GETARG_POINTER(1); TSKEY *b2 = (TSKEY *) PG_GETARG_POINTER(1);
bool *result = (bool*) PG_GETARG_POINTER(2); bool *result = (bool *) PG_GETARG_POINTER(2);
if ( b1 && b2 )
*result = ( TSEQ( &(b1->lower), &(b2->lower) ) && TSEQ( &(b1->upper), &(b2->upper) ) ) ? TRUE : FALSE; if (b1 && b2)
*result = (TSEQ(&(b1->lower), &(b2->lower)) && TSEQ(&(b1->upper), &(b2->upper))) ? TRUE : FALSE;
else else
*result = ( b1==NULL && b2==NULL ) ? TRUE : FALSE; *result = (b1 == NULL && b2 == NULL) ? TRUE : FALSE;
PG_RETURN_POINTER(result); PG_RETURN_POINTER(result);
} }
@ -428,30 +457,34 @@ static void
gts_binary_union(Datum *r1, char *r2) gts_binary_union(Datum *r1, char *r2)
{ {
TSKEY *b1; TSKEY *b1;
TSKEY *b2 = (TSKEY*) r2; TSKEY *b2 = (TSKEY *) r2;
if ( ! DatumGetPointer( *r1 ) ) { if (!DatumGetPointer(*r1))
*r1 = PointerGetDatum( palloc( sizeof(TSKEY) ) ); {
b1 = (TSKEY*)DatumGetPointer( *r1 ); *r1 = PointerGetDatum(palloc(sizeof(TSKEY)));
b1 = (TSKEY *) DatumGetPointer(*r1);
b1->upper = b2->upper; b1->upper = b2->upper;
b1->lower = b2->lower; b1->lower = b2->lower;
} else { }
b1 = (TSKEY*)DatumGetPointer( *r1 ); else
{
b1 = (TSKEY *) DatumGetPointer(*r1);
b1->lower = ( TSGT( &b1->lower, &b2->lower) ) ? b1->lower = (TSGT(&b1->lower, &b2->lower)) ?
b2->lower : b1->lower; b2->lower : b1->lower;
b1->upper = ( TSGT( &b1->upper, &b2->upper) ) ? b1->upper = (TSGT(&b1->upper, &b2->upper)) ?
b1->upper : b2->upper; b1->upper : b2->upper;
} }
} }
static int static int
tskey_cmp(const void *a, const void *b) { tskey_cmp(const void *a, const void *b)
{
return DatumGetInt32( return DatumGetInt32(
DirectFunctionCall2( DirectFunctionCall2(
timestamp_cmp, timestamp_cmp,
TimestampGetDatum( ((TSKEY*)(((RIX*)a)->r))->lower ), TimestampGetDatum(((TSKEY *) (((RIX *) a)->r))->lower),
TimestampGetDatum( ((TSKEY*)(((RIX*)b)->r))->lower ) TimestampGetDatum(((TSKEY *) (((RIX *) b)->r))->lower)
) )
); );
} }
@ -471,38 +504,43 @@ btree_picksplit(bytea *entryvec, GIST_SPLITVEC *v, BINARY_UNION bu, CMPFUNC cmp)
OffsetNumber maxoff; OffsetNumber maxoff;
int nbytes; int nbytes;
maxoff = ((VARSIZE(entryvec) - VARHDRSZ)/sizeof(GISTENTRY)) - 1; maxoff = ((VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY)) - 1;
nbytes = (maxoff + 2) * sizeof(OffsetNumber); nbytes = (maxoff + 2) * sizeof(OffsetNumber);
v->spl_left = (OffsetNumber *) palloc(nbytes); v->spl_left = (OffsetNumber *) palloc(nbytes);
v->spl_right = (OffsetNumber *) palloc(nbytes); v->spl_right = (OffsetNumber *) palloc(nbytes);
v->spl_nleft = 0; v->spl_nleft = 0;
v->spl_nright = 0; v->spl_nright = 0;
v->spl_ldatum = PointerGetDatum( 0 ); v->spl_ldatum = PointerGetDatum(0);
v->spl_rdatum = PointerGetDatum( 0 ); v->spl_rdatum = PointerGetDatum(0);
array = (RIX*)palloc( sizeof(RIX) * (maxoff+1) ); array = (RIX *) palloc(sizeof(RIX) * (maxoff + 1));
/* copy the data into RIXes, and sort the RIXes */ /* 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].index = i;
array[i].r=(char *)DatumGetPointer( (((GISTENTRY *)(VARDATA(entryvec)))[i].key) ); array[i].r = (char *) DatumGetPointer((((GISTENTRY *) (VARDATA(entryvec)))[i].key));
} }
qsort((void*)&array[FirstOffsetNumber], maxoff - FirstOffsetNumber + 1, qsort((void *) &array[FirstOffsetNumber], maxoff - FirstOffsetNumber + 1,
sizeof(RIX), cmp); sizeof(RIX), cmp);
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) { for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
if (i <= (maxoff - FirstOffsetNumber + 1)/2) { {
v->spl_left[ v->spl_nleft ] = array[i].index; if (i <= (maxoff - FirstOffsetNumber + 1) / 2)
{
v->spl_left[v->spl_nleft] = array[i].index;
v->spl_nleft++; v->spl_nleft++;
(*bu)( &v->spl_ldatum, array[i].r ); (*bu) (&v->spl_ldatum, array[i].r);
} else { }
v->spl_right[ v->spl_nright ] = array[i].index; else
{
v->spl_right[v->spl_nright] = array[i].index;
v->spl_nright++; v->spl_nright++;
(*bu)( &v->spl_rdatum, array[i].r ); (*bu) (&v->spl_rdatum, array[i].r);
} }
} }
pfree(array); pfree(array);
return( v ); return (v);
} }
/* /*
@ -520,30 +558,36 @@ btree_decompress(PG_FUNCTION_ARGS)
* In/Out for keys, not really needed * In/Out for keys, not really needed
**************************************************/ **************************************************/
Datum Datum
int4key_in(PG_FUNCTION_ARGS) { int4key_in(PG_FUNCTION_ARGS)
{
INT4KEY *key = palloc(sizeof(INT4KEY)); INT4KEY *key = palloc(sizeof(INT4KEY));
if ( sscanf( PG_GETARG_POINTER(0), "%d|%d", &(key->lower), &(key->upper)) != 2 ) if (sscanf(PG_GETARG_POINTER(0), "%d|%d", &(key->lower), &(key->upper)) != 2)
elog(ERROR, "Error in input format"); elog(ERROR, "Error in input format");
PG_RETURN_POINTER( key ); PG_RETURN_POINTER(key);
} }
Datum int4key_out(PG_FUNCTION_ARGS) { Datum
int4key_out(PG_FUNCTION_ARGS)
{
INT4KEY *key = (INT4KEY *) PG_GETARG_POINTER(0); INT4KEY *key = (INT4KEY *) PG_GETARG_POINTER(0);
char *str=palloc(sizeof(char)*22); char *str = palloc(sizeof(char) * 22);
sprintf(str,"%d|%d", key->lower, key->upper);
PG_RETURN_POINTER( str ); sprintf(str, "%d|%d", key->lower, key->upper);
PG_RETURN_POINTER(str);
} }
Datum Datum
tskey_in(PG_FUNCTION_ARGS) { tskey_in(PG_FUNCTION_ARGS)
{
elog(ERROR, "Not implemented"); elog(ERROR, "Not implemented");
PG_RETURN_POINTER( NULL ); PG_RETURN_POINTER(NULL);
} }
Datum Datum
tskey_out(PG_FUNCTION_ARGS) { tskey_out(PG_FUNCTION_ARGS)
{
elog(ERROR, "Not implemented"); elog(ERROR, "Not implemented");
PG_RETURN_POINTER( NULL ); PG_RETURN_POINTER(NULL);
} }

16
contrib/chkpass/chkpass.c
View File

@ -4,7 +4,7 @@
* darcy@druid.net * darcy@druid.net
* http://www.druid.net/darcy/ * 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 * best viewed with tabs set to 4
*/ */
@ -166,10 +166,11 @@ chkpass_eq(PG_FUNCTION_ARGS)
if (!a1 || !a2) if (!a1 || !a2)
PG_RETURN_BOOL(0); 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); strncpy(str, a2->vl_dat, sz);
str[sz] = 0; str[sz] = 0;
PG_RETURN_BOOL (strcmp(a1->password, crypt(str, a1->password)) == 0); PG_RETURN_BOOL(strcmp(a1->password, crypt(str, a1->password)) == 0);
} }
PG_FUNCTION_INFO_V1(chkpass_ne) PG_FUNCTION_INFO_V1(chkpass_ne)
@ -181,10 +182,11 @@ chkpass_ne(PG_FUNCTION_ARGS)
char str[10]; char str[10];
int sz = 8; int sz = 8;
if (!a1 || !a2) PG_RETURN_BOOL(0); if (!a1 || !a2)
if (a2->vl_len < 12) sz = a2->vl_len - 4; PG_RETURN_BOOL(0);
if (a2->vl_len < 12)
sz = a2->vl_len - 4;
strncpy(str, a2->vl_dat, sz); strncpy(str, a2->vl_dat, sz);
str[sz] = 0; str[sz] = 0;
PG_RETURN_BOOL (strcmp(a1->password, crypt(str, a1->password)) != 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, NDBOX * query,
StrategyNumber strategy) StrategyNumber strategy)
{ {
/* /*
* if entry is not leaf, use g_cube_internal_consistent, else use * if entry is not leaf, use g_cube_internal_consistent, else use
* g_cube_leaf_consistent * g_cube_leaf_consistent
@ -365,7 +364,6 @@ g_cube_picksplit(bytea *entryvec,
maxoff = OffsetNumberNext(maxoff); maxoff = OffsetNumberNext(maxoff);
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
{ {
/* /*
* If we've already decided where to place this item, just put it * 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 * 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) if (a->dim < b->dim)
{ {
/* /*
* the further comparisons will make sense if the excess * the further comparisons will make sense if the excess
* dimensions of (b) were zeroes * dimensions of (b) were zeroes

297
contrib/dbase/dbf.c
View File

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

49
contrib/dbase/dbf.h
View File

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

517
contrib/dbase/dbf2pg.c
View File

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

20
contrib/dbase/endian.c
View File

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

81
contrib/dblink/dblink.c
View File

@ -41,18 +41,17 @@ dblink(PG_FUNCTION_ARGS)
int ntuples = 0; int ntuples = 0;
ReturnSetInfo *rsi; ReturnSetInfo *rsi;
if (PG_ARGISNULL(0) || PG_ARGISNULL(1)) { if (PG_ARGISNULL(0) || PG_ARGISNULL(1))
elog(ERROR, "dblink: NULL arguments are not permitted"); 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"); elog(ERROR, "dblink: function called in context that does not accept a set result");
}
optstr = DatumGetCString(DirectFunctionCall1(textout, PointerGetDatum(PG_GETARG_TEXT_P(0)))); optstr = DatumGetCString(DirectFunctionCall1(textout, PointerGetDatum(PG_GETARG_TEXT_P(0))));
sqlstatement = DatumGetCString(DirectFunctionCall1(textout, PointerGetDatum(PG_GETARG_TEXT_P(1)))); 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); conn = PQconnectdb(optstr);
if (PQstatus(conn) == CONNECTION_BAD) if (PQstatus(conn) == CONNECTION_BAD)
@ -73,13 +72,14 @@ dblink(PG_FUNCTION_ARGS)
PQclear(res); PQclear(res);
execstatement = (char *) palloc(strlen(curstr) + strlen(sqlstatement) + 1); execstatement = (char *) palloc(strlen(curstr) + strlen(sqlstatement) + 1);
if (execstatement != NULL) { if (execstatement != NULL)
{
strcpy(execstatement, curstr); strcpy(execstatement, curstr);
strcat(execstatement, sqlstatement); strcat(execstatement, sqlstatement);
strcat(execstatement, "\0"); strcat(execstatement, "\0");
} else {
elog(ERROR, "dblink: insufficient memory" );
} }
else
elog(ERROR, "dblink: insufficient memory");
res = PQexec(conn, execstatement); res = PQexec(conn, execstatement);
if (!res || (PQresultStatus(res) != PGRES_COMMAND_OK && PQresultStatus(res) != PGRES_TUPLES_OK)) if (!res || (PQresultStatus(res) != PGRES_COMMAND_OK && PQresultStatus(res) != PGRES_TUPLES_OK))
@ -88,14 +88,17 @@ dblink(PG_FUNCTION_ARGS)
PQclear(res); PQclear(res);
PQfinish(conn); PQfinish(conn);
elog(ERROR, "dblink: sql error: %s", msg); elog(ERROR, "dblink: sql error: %s", msg);
} else { }
else
{
/* /*
* got results, start fetching them * got results, start fetching them
*/ */
PQclear(res); PQclear(res);
res = PQexec(conn, "FETCH ALL in mycursor"); 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)); msg = pstrdup(PQerrorMessage(conn));
PQclear(res); PQclear(res);
PQfinish(conn); PQfinish(conn);
@ -104,7 +107,8 @@ dblink(PG_FUNCTION_ARGS)
ntuples = PQntuples(res); ntuples = PQntuples(res);
if (ntuples > 0) { if (ntuples > 0)
{
results = init_dblink_results(fcinfo->flinfo->fn_mcxt); results = init_dblink_results(fcinfo->flinfo->fn_mcxt);
results->tup_num = 0; results->tup_num = 0;
@ -127,12 +131,14 @@ dblink(PG_FUNCTION_ARGS)
/* close the connection to the database and cleanup */ /* close the connection to the database and cleanup */
PQfinish(conn); PQfinish(conn);
rsi = (ReturnSetInfo *)fcinfo->resultinfo; rsi = (ReturnSetInfo *) fcinfo->resultinfo;
rsi->isDone = ExprMultipleResult; rsi->isDone = ExprMultipleResult;
PG_RETURN_POINTER(results); PG_RETURN_POINTER(results);
} else { }
else
{
PQclear(res); PQclear(res);
@ -147,13 +153,15 @@ dblink(PG_FUNCTION_ARGS)
/* close the connection to the database and cleanup */ /* close the connection to the database and cleanup */
PQfinish(conn); PQfinish(conn);
rsi = (ReturnSetInfo *)fcinfo->resultinfo; rsi = (ReturnSetInfo *) fcinfo->resultinfo;
rsi->isDone = ExprEndResult ; rsi->isDone = ExprEndResult;
PG_RETURN_NULL(); PG_RETURN_NULL();
} }
} }
} else { }
else
{
/* /*
* check for more results * check for more results
*/ */
@ -162,19 +170,20 @@ dblink(PG_FUNCTION_ARGS)
results->tup_num++; results->tup_num++;
ntuples = PQntuples(results->res); ntuples = PQntuples(results->res);
if (results->tup_num < ntuples) { if (results->tup_num < ntuples)
{
/* /*
* fetch them if available * fetch them if available
*/ */
rsi = (ReturnSetInfo *)fcinfo->resultinfo; rsi = (ReturnSetInfo *) fcinfo->resultinfo;
rsi->isDone = ExprMultipleResult; rsi->isDone = ExprMultipleResult;
PG_RETURN_POINTER(results); PG_RETURN_POINTER(results);
} else { }
else
{
/* /*
* or if no more, clean things up * or if no more, clean things up
*/ */
@ -183,8 +192,8 @@ dblink(PG_FUNCTION_ARGS)
PQclear(results->res); PQclear(results->res);
rsi = (ReturnSetInfo *)fcinfo->resultinfo; rsi = (ReturnSetInfo *) fcinfo->resultinfo;
rsi->isDone = ExprEndResult ; rsi->isDone = ExprEndResult;
PG_RETURN_NULL(); PG_RETURN_NULL();
} }
@ -211,41 +220,41 @@ dblink_tok(PG_FUNCTION_ARGS)
int nfields = 0; int nfields = 0;
int text_len = 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"); elog(ERROR, "dblink: NULL arguments are not permitted");
}
results = (dblink_results *) PG_GETARG_POINTER(0); results = (dblink_results *) PG_GETARG_POINTER(0);
if (results == NULL) { if (results == NULL)
elog(ERROR, "dblink: function called with invalid result pointer"); elog(ERROR, "dblink: function called with invalid result pointer");
}
fldnum = PG_GETARG_INT32(1); fldnum = PG_GETARG_INT32(1);
if (fldnum < 0) { if (fldnum < 0)
elog(ERROR, "dblink: field number < 0 not permitted"); elog(ERROR, "dblink: field number < 0 not permitted");
}
nfields = PQnfields(results->res); nfields = PQnfields(results->res);
if (fldnum > (nfields - 1)) { if (fldnum > (nfields - 1))
elog(ERROR, "dblink: field number %d does not exist", fldnum); 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(); PG_RETURN_NULL();
} else { }
else
{
text_len = PQgetlength(results->res, results->tup_num, fldnum); text_len = PQgetlength(results->res, results->tup_num, fldnum);
result = (char *) palloc(text_len + 1); result = (char *) palloc(text_len + 1);
if (result != NULL) { if (result != NULL)
{
strcpy(result, PQgetvalue(results->res, results->tup_num, fldnum)); strcpy(result, PQgetvalue(results->res, results->tup_num, fldnum));
strcat(result, "\0"); strcat(result, "\0");
} else {
elog(ERROR, "dblink: insufficient memory" );
} }
else
elog(ERROR, "dblink: insufficient memory");
result_text = DatumGetTextP(DirectFunctionCall1(textin, CStringGetDatum(result))); 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 * Internal declarations
*/ */
dblink_results *init_dblink_results(MemoryContext fn_mcxt); dblink_results *init_dblink_results(MemoryContext fn_mcxt);
#endif /* DBLINK_H */ #endif /* DBLINK_H */

8
contrib/fulltextindex/fti.c
View File

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

333
contrib/fuzzystrmatch/fuzzystrmatch.c
View File

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

12
contrib/fuzzystrmatch/fuzzystrmatch.h
View File

@ -132,13 +132,14 @@ static const char *soundex_table = "01230120022455012623010202";
#define SH 'X' #define SH 'X'
#define TH '0' #define TH '0'
char Lookahead(char * word, int how_far); char Lookahead(char *word, int how_far);
int _metaphone ( int
_metaphone(
/* IN */ /* IN */
char * word, char *word,
int max_phonemes, int max_phonemes,
/* OUT */ /* OUT */
char ** phoned_word char **phoned_word
); );
/* Metachar.h ... little bits about characters for metaphone */ /* Metachar.h ... little bits about characters for metaphone */
@ -147,7 +148,7 @@ int _metaphone (
/*-- Character encoding array & accessing macros --*/ /*-- Character encoding array & accessing macros --*/
/* Stolen directly out of the book... */ /* Stolen directly out of the book... */
char _codes[26] = { char _codes[26] = {
1,16,4,16,9,2,4,16,9,2,0,2,2,2,1,4,0,2,4,4,1,0,0,0,8,0 1, 16, 4, 16, 9, 2, 4, 16, 9, 2, 0, 2, 2, 2, 1, 4, 0, 2, 4, 4, 1, 0, 0, 0, 8, 0
/* a b c d e f g h i j k l m n o p q r s t u v w x y z */ /* a b c d e f g h i j k l m n o p q r s t u v w x y z */
}; };
@ -168,5 +169,4 @@ char _codes[26] = {
/* These prevent GH from becoming F */ /* These prevent GH from becoming F */
#define NOGHTOF(c) (ENCODE(c) & 16) /* BDH */ #define NOGHTOF(c) (ENCODE(c) & 16) /* BDH */
#endif /* FUZZYSTRMATCH_H */ #endif /* FUZZYSTRMATCH_H */

9
contrib/lo/lo.c
View File

@ -1,7 +1,7 @@
/* /*
* PostgreSQL type definitions for managed LargeObjects. * 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 $
* *
*/ */
@ -33,8 +33,8 @@ typedef Oid Blob;
*/ */
Blob *lo_in(char *str); /* Create from String */ Blob *lo_in(char *str); /* Create from String */
char *lo_out(Blob * addr);/* Output oid as String */ char *lo_out(Blob * addr); /* Output oid as String */
Oid lo_oid(Blob * addr);/* Return oid as an oid */ Oid lo_oid(Blob * addr); /* Return oid as an oid */
Blob *lo(Oid oid); /* Return Blob based on oid */ Blob *lo(Oid oid); /* Return Blob based on oid */
Datum lo_manage(PG_FUNCTION_ARGS); /* Trigger handler */ Datum lo_manage(PG_FUNCTION_ARGS); /* Trigger handler */
@ -64,7 +64,6 @@ lo_in(char *str)
} }
else else
{ {
/* /*
* There is no Oid passed, so create a new one * There is no Oid passed, so create a new one
*/ */
@ -140,7 +139,7 @@ lo_manage(PG_FUNCTION_ARGS)
TupleDesc tupdesc; /* Tuple Descriptor */ TupleDesc tupdesc; /* Tuple Descriptor */
HeapTuple rettuple; /* Tuple to be returned */ HeapTuple rettuple; /* Tuple to be returned */
bool isdelete; /* are we deleting? */ bool isdelete; /* are we deleting? */
HeapTuple newtuple = NULL;/* The new value for tuple */ HeapTuple newtuple = NULL; /* The new value for tuple */
HeapTuple trigtuple; /* The original value of tuple */ HeapTuple trigtuple; /* The original value of tuple */
if (!CALLED_AS_TRIGGER(fcinfo)) if (!CALLED_AS_TRIGGER(fcinfo))

1
contrib/miscutil/misc_utils.h
View File

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

2
contrib/pg_controldata/pg_controldata.c
View File

@ -6,7 +6,7 @@
* copyright (c) Oliver Elphick <olly@lfix.co.uk>, 2001; * copyright (c) Oliver Elphick <olly@lfix.co.uk>, 2001;
* licence: BSD * 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" #include "postgres.h"

7
contrib/pg_dumplo/lo_export.c
View File

@ -1,7 +1,7 @@
/* ------------------------------------------------------------------------- /* -------------------------------------------------------------------------
* pg_dumplo * 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 * Karel Zak 1999-2000
* ------------------------------------------------------------------------- * -------------------------------------------------------------------------
@ -38,8 +38,8 @@ load_lolist(LODumpMaster * pgLO)
* NOTE: System tables including pg_largeobject will be ignored. * NOTE: System tables including pg_largeobject will be ignored.
* Otherwise we'd end up dumping all LOs, referenced or not. * Otherwise we'd end up dumping all LOs, referenced or not.
* *
* NOTE: the system oid column is ignored, as it has attnum < 1. * NOTE: the system oid column is ignored, as it has attnum < 1. This
* This shouldn't matter for correctness, but it saves time. * shouldn't matter for correctness, but it saves time.
*/ */
pgLO->res = PQexec(pgLO->conn, pgLO->res = PQexec(pgLO->conn,
"SELECT c.relname, a.attname " "SELECT c.relname, a.attname "
@ -107,7 +107,6 @@ pglo_export(LODumpMaster * pgLO)
for (ll = pgLO->lolist; ll->lo_table != NULL; ll++) for (ll = pgLO->lolist; ll->lo_table != NULL; ll++)
{ {
/* /*
* Query: find the LOs referenced by this column * Query: find the LOs referenced by this column
*/ */

2
contrib/pg_dumplo/lo_import.c
View File

@ -1,7 +1,7 @@
/* ------------------------------------------------------------------------- /* -------------------------------------------------------------------------
* pg_dumplo * 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 * Karel Zak 1999-2000
* ------------------------------------------------------------------------- * -------------------------------------------------------------------------

3
contrib/pg_dumplo/main.c
View File

@ -1,7 +1,7 @@
/* ------------------------------------------------------------------------- /* -------------------------------------------------------------------------
* pg_dumplo * 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 * Karel Zak 1999-2000
* ------------------------------------------------------------------------- * -------------------------------------------------------------------------
@ -304,7 +304,6 @@ usage()
"-q run quietly\n" "-q run quietly\n"
"-w not dump, but show all LO in DB\n" "-w not dump, but show all LO in DB\n"
); /* puts() */ ); /* puts() */
#endif #endif
puts( puts(

3
contrib/pg_dumplo/pg_dumplo.h
View File

@ -1,7 +1,7 @@
/* ------------------------------------------------------------------------- /* -------------------------------------------------------------------------
* pg_dumplo * 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 * Karel Zak 1999-2000
* ------------------------------------------------------------------------- * -------------------------------------------------------------------------
@ -78,5 +78,4 @@ extern void index_file(LODumpMaster * pgLO);
extern void load_lolist(LODumpMaster * pgLO); extern void load_lolist(LODumpMaster * pgLO);
extern void pglo_export(LODumpMaster * pgLO); extern void pglo_export(LODumpMaster * pgLO);
extern void pglo_import(LODumpMaster * pgLO); extern void pglo_import(LODumpMaster * pgLO);
#endif /* PG_DUMPLO_H */ #endif /* PG_DUMPLO_H */

7
contrib/pg_resetxlog/pg_resetxlog.c
View File

@ -23,7 +23,7 @@
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California * 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 ((fd = open(ControlFilePath, O_RDONLY)) < 0)
{ {
/* /*
* If pg_control is not there at all, or we can't read it, the * 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 * 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)); (char *) malloc(_INTL_MAXLOGRECSZ));
if (record == NULL) if (record == NULL)
{ {
/* /*
* We have to guess at the checkpoint contents. * We have to guess at the checkpoint contents.
*/ */
@ -493,7 +491,7 @@ ReadRecordV0(XLogRecPtr *RecPtr, char *buffer)
readFile = XLogFileOpen(readId, readSeg); readFile = XLogFileOpen(readId, readSeg);
if (readFile < 0) if (readFile < 0)
goto next_record_is_invalid; goto next_record_is_invalid;
readOff = (uint32) (-1);/* force read to occur below */ readOff = (uint32) (-1); /* force read to occur below */
} }
targetPageOff = ((RecPtr->xrecoff % XLogSegSize) / BLCKSZ) * BLCKSZ; targetPageOff = ((RecPtr->xrecoff % XLogSegSize) / BLCKSZ) * BLCKSZ;
@ -617,7 +615,6 @@ GuessControlValues(void)
{ {
#ifdef USE_LOCALE #ifdef USE_LOCALE
char *localeptr; char *localeptr;
#endif #endif
/* /*

19
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 * pgbench: a simple TPC-B like benchmark program for PostgreSQL
* written by Tatsuo Ishii * written by Tatsuo Ishii
@ -39,7 +39,6 @@
/* for getrlimit */ /* for getrlimit */
#include <sys/resource.h> #include <sys/resource.h>
#endif /* WIN32 */ #endif /* WIN32 */
/******************************************************************** /********************************************************************
@ -67,7 +66,8 @@ int tps = 1;
int remains; /* number of remained clients */ 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 *pghost = "";
char *pgport = NULL; char *pgport = NULL;
@ -107,7 +107,8 @@ getrand(int min, int max)
} }
/* set up a connection to the backend */ /* set up a connection to the backend */
static PGconn *doConnect() static PGconn *
doConnect()
{ {
PGconn *con; PGconn *con;
@ -117,7 +118,7 @@ static PGconn *doConnect()
{ {
fprintf(stderr, "Connection to database '%s' failed.\n", dbName); fprintf(stderr, "Connection to database '%s' failed.\n", dbName);
fprintf(stderr, "Memory allocatin problem?\n"); fprintf(stderr, "Memory allocatin problem?\n");
return(NULL); return (NULL);
} }
if (PQstatus(con) == CONNECTION_BAD) if (PQstatus(con) == CONNECTION_BAD)
@ -129,7 +130,7 @@ static PGconn *doConnect()
else else
fprintf(stderr, "No explanation from the backend\n"); fprintf(stderr, "No explanation from the backend\n");
return(NULL); return (NULL);
} }
return (con); return (con);
} }
@ -532,8 +533,8 @@ init()
if (j % 10000 == 0) if (j % 10000 == 0)
{ {
/* /*
* every 10000 tuples, we commit the copy command. * every 10000 tuples, we commit the copy command. this should
* this should avoid generating too much WAL logs * avoid generating too much WAL logs
*/ */
fprintf(stderr, "%d tuples done.\n", j); fprintf(stderr, "%d tuples done.\n", j);
if (PQputline(con, "\\.\n")) if (PQputline(con, "\\.\n"))
@ -547,6 +548,7 @@ init()
fprintf(stderr, "PQendcopy failed\n"); fprintf(stderr, "PQendcopy failed\n");
exit(1); exit(1);
} }
/* /*
* do a checkpoint to purge the old WAL logs * do a checkpoint to purge the old WAL logs
*/ */
@ -634,7 +636,6 @@ main(int argc, char **argv)
#ifndef __CYGWIN__ #ifndef __CYGWIN__
struct rlimit rlim; struct rlimit rlim;
#endif #endif
PGconn *con; PGconn *con;

145
contrib/pgcrypto/blf.c
View File

@ -60,7 +60,7 @@
#define BLFRND(s,p,i,j,n) (i ^= F(s,j) ^ (p)[n]) #define BLFRND(s,p,i,j,n) (i ^= F(s,j) ^ (p)[n])
void void
Blowfish_encipher(blf_ctx *c, uint32 *x) Blowfish_encipher(blf_ctx * c, uint32 *x)
{ {
uint32 Xl; uint32 Xl;
uint32 Xr; uint32 Xr;
@ -71,21 +71,29 @@ Blowfish_encipher(blf_ctx *c, uint32 *x)
Xr = x[1]; Xr = x[1];
Xl ^= p[0]; Xl ^= p[0];
BLFRND(s, p, Xr, Xl, 1); BLFRND(s, p, Xl, Xr, 2); BLFRND(s, p, Xr, Xl, 1);
BLFRND(s, p, Xr, Xl, 3); BLFRND(s, p, Xl, Xr, 4); BLFRND(s, p, Xl, Xr, 2);
BLFRND(s, p, Xr, Xl, 5); BLFRND(s, p, Xl, Xr, 6); BLFRND(s, p, Xr, Xl, 3);
BLFRND(s, p, Xr, Xl, 7); BLFRND(s, p, Xl, Xr, 8); BLFRND(s, p, Xl, Xr, 4);
BLFRND(s, p, Xr, Xl, 9); BLFRND(s, p, Xl, Xr, 10); BLFRND(s, p, Xr, Xl, 5);
BLFRND(s, p, Xr, Xl, 11); BLFRND(s, p, Xl, Xr, 12); BLFRND(s, p, Xl, Xr, 6);
BLFRND(s, p, Xr, Xl, 13); BLFRND(s, p, Xl, Xr, 14); BLFRND(s, p, Xr, Xl, 7);
BLFRND(s, p, Xr, Xl, 15); BLFRND(s, p, Xl, Xr, 16); 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[0] = Xr ^ p[17];
x[1] = Xl; x[1] = Xl;
} }
void void
Blowfish_decipher(blf_ctx *c, uint32 *x) Blowfish_decipher(blf_ctx * c, uint32 *x)
{ {
uint32 Xl; uint32 Xl;
uint32 Xr; uint32 Xr;
@ -96,28 +104,36 @@ Blowfish_decipher(blf_ctx *c, uint32 *x)
Xr = x[1]; Xr = x[1];
Xl ^= p[17]; Xl ^= p[17];
BLFRND(s, p, Xr, Xl, 16); BLFRND(s, p, Xl, Xr, 15); BLFRND(s, p, Xr, Xl, 16);
BLFRND(s, p, Xr, Xl, 14); BLFRND(s, p, Xl, Xr, 13); BLFRND(s, p, Xl, Xr, 15);
BLFRND(s, p, Xr, Xl, 12); BLFRND(s, p, Xl, Xr, 11); BLFRND(s, p, Xr, Xl, 14);
BLFRND(s, p, Xr, Xl, 10); BLFRND(s, p, Xl, Xr, 9); BLFRND(s, p, Xl, Xr, 13);
BLFRND(s, p, Xr, Xl, 8); BLFRND(s, p, Xl, Xr, 7); BLFRND(s, p, Xr, Xl, 12);
BLFRND(s, p, Xr, Xl, 6); BLFRND(s, p, Xl, Xr, 5); BLFRND(s, p, Xl, Xr, 11);
BLFRND(s, p, Xr, Xl, 4); BLFRND(s, p, Xl, Xr, 3); BLFRND(s, p, Xr, Xl, 10);
BLFRND(s, p, Xr, Xl, 2); BLFRND(s, p, Xl, Xr, 1); 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[0] = Xr ^ p[0];
x[1] = Xl; x[1] = Xl;
} }
void void
Blowfish_initstate(blf_ctx *c) Blowfish_initstate(blf_ctx * c)
{ {
/* P-box and S-box tables initialized with digits of Pi */ /* P-box and S-box tables initialized with digits of Pi */
const blf_ctx initstate = const blf_ctx initstate =
{ { {{
{ {
0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7, 0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7,
0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99, 0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99,
@ -385,7 +401,7 @@ Blowfish_initstate(blf_ctx *c)
0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c, 0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917, 0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917,
0x9216d5d9, 0x8979fb1b 0x9216d5d9, 0x8979fb1b
} }; }};
*c = initstate; *c = initstate;
@ -401,7 +417,8 @@ Blowfish_stream2word(const uint8 *data, uint16 databytes, uint16 *current)
temp = 0x00000000; temp = 0x00000000;
j = *current; j = *current;
for (i = 0; i < 4; i++, j++) { for (i = 0; i < 4; i++, j++)
{
if (j >= databytes) if (j >= databytes)
j = 0; j = 0;
temp = (temp << 8) | data[j]; temp = (temp << 8) | data[j];
@ -412,7 +429,7 @@ Blowfish_stream2word(const uint8 *data, uint16 databytes, uint16 *current)
} }
void void
Blowfish_expand0state(blf_ctx *c, const uint8 *key, uint16 keybytes) Blowfish_expand0state(blf_ctx * c, const uint8 *key, uint16 keybytes)
{ {
uint16 i; uint16 i;
uint16 j; uint16 j;
@ -421,7 +438,8 @@ Blowfish_expand0state(blf_ctx *c, const uint8 *key, uint16 keybytes)
uint32 data[2]; uint32 data[2];
j = 0; 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 */ /* Extract 4 int8 to 1 int32 from keystream */
temp = Blowfish_stream2word(key, keybytes, &j); temp = Blowfish_stream2word(key, keybytes, &j);
c->P[i] = c->P[i] ^ temp; c->P[i] = c->P[i] ^ temp;
@ -430,15 +448,18 @@ Blowfish_expand0state(blf_ctx *c, const uint8 *key, uint16 keybytes)
j = 0; j = 0;
data[0] = 0x00000000; data[0] = 0x00000000;
data[1] = 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); Blowfish_encipher(c, data);
c->P[i] = data[0]; c->P[i] = data[0];
c->P[i + 1] = data[1]; c->P[i + 1] = data[1];
} }
for (i = 0; i < 4; i++) { for (i = 0; i < 4; i++)
for (k = 0; k < 256; k += 2) { {
for (k = 0; k < 256; k += 2)
{
Blowfish_encipher(c, data); Blowfish_encipher(c, data);
c->S[i][k] = data[0]; c->S[i][k] = data[0];
@ -449,7 +470,7 @@ Blowfish_expand0state(blf_ctx *c, const uint8 *key, uint16 keybytes)
void void
Blowfish_expandstate(blf_ctx *c, const uint8 *data, uint16 databytes, Blowfish_expandstate(blf_ctx * c, const uint8 *data, uint16 databytes,
const uint8 *key, uint16 keybytes) const uint8 *key, uint16 keybytes)
{ {
uint16 i; uint16 i;
@ -459,7 +480,8 @@ Blowfish_expandstate(blf_ctx *c, const uint8 *data, uint16 databytes,
uint32 d[2]; uint32 d[2];
j = 0; 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 */ /* Extract 4 int8 to 1 int32 from keystream */
temp = Blowfish_stream2word(key, keybytes, &j); temp = Blowfish_stream2word(key, keybytes, &j);
c->P[i] = c->P[i] ^ temp; c->P[i] = c->P[i] ^ temp;
@ -468,7 +490,8 @@ Blowfish_expandstate(blf_ctx *c, const uint8 *data, uint16 databytes,
j = 0; j = 0;
d[0] = 0x00000000; d[0] = 0x00000000;
d[1] = 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[0] ^= Blowfish_stream2word(data, databytes, &j);
d[1] ^= Blowfish_stream2word(data, databytes, &j); d[1] ^= Blowfish_stream2word(data, databytes, &j);
Blowfish_encipher(c, d); Blowfish_encipher(c, d);
@ -477,9 +500,11 @@ Blowfish_expandstate(blf_ctx *c, const uint8 *data, uint16 databytes,
c->P[i + 1] = d[1]; c->P[i + 1] = d[1];
} }
for (i = 0; i < 4; i++) { for (i = 0; i < 4; i++)
for (k = 0; k < 256; k += 2) { {
d[0]^= Blowfish_stream2word(data, databytes, &j); for (k = 0; k < 256; k += 2)
{
d[0] ^= Blowfish_stream2word(data, databytes, &j);
d[1] ^= Blowfish_stream2word(data, databytes, &j); d[1] ^= Blowfish_stream2word(data, databytes, &j);
Blowfish_encipher(c, d); Blowfish_encipher(c, d);
@ -491,7 +516,7 @@ Blowfish_expandstate(blf_ctx *c, const uint8 *data, uint16 databytes,
} }
void void
blf_key(blf_ctx *c, const uint8 *k, uint16 len) blf_key(blf_ctx * c, const uint8 *k, uint16 len)
{ {
/* Initalize S-boxes and subkeys with Pi */ /* Initalize S-boxes and subkeys with Pi */
Blowfish_initstate(c); Blowfish_initstate(c);
@ -501,38 +526,43 @@ blf_key(blf_ctx *c, const uint8 *k, uint16 len)
} }
void void
blf_enc(blf_ctx *c, uint32 *data, uint16 blocks) blf_enc(blf_ctx * c, uint32 *data, uint16 blocks)
{ {
uint32 *d; uint32 *d;
uint16 i; uint16 i;
d = data; d = data;
for (i = 0; i < blocks; i++) { for (i = 0; i < blocks; i++)
{
Blowfish_encipher(c, d); Blowfish_encipher(c, d);
d += 2; d += 2;
} }
} }
void void
blf_dec(blf_ctx *c, uint32 *data, uint16 blocks) blf_dec(blf_ctx * c, uint32 *data, uint16 blocks)
{ {
uint32 *d; uint32 *d;
uint16 i; uint16 i;
d = data; d = data;
for (i = 0; i < blocks; i++) { for (i = 0; i < blocks; i++)
{
Blowfish_decipher(c, d); Blowfish_decipher(c, d);
d += 2; d += 2;
} }
} }
void void
blf_ecb_encrypt(blf_ctx *c, uint8 *data, uint32 len) blf_ecb_encrypt(blf_ctx * c, uint8 *data, uint32 len)
{ {
uint32 l, r, d[2]; uint32 l,
r,
d[2];
uint32 i; 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]; l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7]; r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
d[0] = l; d[0] = l;
@ -553,12 +583,15 @@ blf_ecb_encrypt(blf_ctx *c, uint8 *data, uint32 len)
} }
void void
blf_ecb_decrypt(blf_ctx *c, uint8 *data, uint32 len) blf_ecb_decrypt(blf_ctx * c, uint8 *data, uint32 len)
{ {
uint32 l, r, d[2]; uint32 l,
r,
d[2];
uint32 i; 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]; l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7]; r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
d[0] = l; d[0] = l;
@ -579,12 +612,16 @@ blf_ecb_decrypt(blf_ctx *c, uint8 *data, uint32 len)
} }
void void
blf_cbc_encrypt(blf_ctx *c, uint8 *iv, uint8 *data, uint32 len) blf_cbc_encrypt(blf_ctx * c, uint8 *iv, uint8 *data, uint32 len)
{ {
uint32 l, r, d[2]; uint32 l,
uint32 i, j; 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++) for (j = 0; j < 8; j++)
data[j] ^= iv[j]; data[j] ^= iv[j];
l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3]; l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
@ -608,15 +645,19 @@ blf_cbc_encrypt(blf_ctx *c, uint8 *iv, uint8 *data, uint32 len)
} }
void void
blf_cbc_decrypt(blf_ctx *c, uint8 *iva, uint8 *data, uint32 len) blf_cbc_decrypt(blf_ctx * c, uint8 *iva, uint8 *data, uint32 len)
{ {
uint32 l, r, d[2]; uint32 l,
r,
d[2];
uint8 *iv; uint8 *iv;
uint32 i, j; uint32 i,
j;
iv = data + len - 16; iv = data + len - 16;
data = data + len - 8; 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]; l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7]; r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
d[0] = l; d[0] = l;

28
contrib/pgcrypto/blf.h
View File

@ -46,7 +46,8 @@
#define BLF_MAXKEYLEN ((BLF_N-2)*4) /* 448 bits */ #define BLF_MAXKEYLEN ((BLF_N-2)*4) /* 448 bits */
/* Blowfish context */ /* Blowfish context */
typedef struct BlowfishContext { typedef struct BlowfishContext
{
uint32 S[4][256]; /* S-Boxes */ uint32 S[4][256]; /* S-Boxes */
uint32 P[BLF_N + 2]; /* Subkeys */ uint32 P[BLF_N + 2]; /* Subkeys */
} blf_ctx; } blf_ctx;
@ -57,26 +58,25 @@ typedef struct BlowfishContext {
* Blowfish_expand0state( state, key, keylen ) * Blowfish_expand0state( state, key, keylen )
*/ */
void Blowfish_encipher (blf_ctx *, uint32 *); void Blowfish_encipher(blf_ctx *, uint32 *);
void Blowfish_decipher (blf_ctx *, uint32 *); void Blowfish_decipher(blf_ctx *, uint32 *);
void Blowfish_initstate (blf_ctx *); void Blowfish_initstate(blf_ctx *);
void Blowfish_expand0state (blf_ctx *, const uint8 *, uint16); void Blowfish_expand0state(blf_ctx *, const uint8 *, uint16);
void Blowfish_expandstate void Blowfish_expandstate
(blf_ctx *, const uint8 *, uint16, const uint8 *, uint16); (blf_ctx *, const uint8 *, uint16, const uint8 *, uint16);
/* Standard Blowfish */ /* Standard Blowfish */
void blf_key (blf_ctx *, const uint8 *, uint16); void blf_key(blf_ctx *, const uint8 *, uint16);
void blf_enc (blf_ctx *, uint32 *, uint16); void blf_enc(blf_ctx *, uint32 *, uint16);
void blf_dec (blf_ctx *, uint32 *, uint16); void blf_dec(blf_ctx *, uint32 *, uint16);
/* Converts uint8 to uint32 */ /* Converts uint8 to uint32 */
uint32 Blowfish_stream2word (const uint8 *, uint16, uint16 *); uint32 Blowfish_stream2word(const uint8 *, uint16, uint16 *);
void blf_ecb_encrypt (blf_ctx *, uint8 *, uint32); void blf_ecb_encrypt(blf_ctx *, uint8 *, uint32);
void blf_ecb_decrypt (blf_ctx *, uint8 *, uint32); 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);
void blf_cbc_encrypt(blf_ctx *, uint8 *, uint8 *, uint32);
void blf_cbc_decrypt(blf_ctx *, uint8 *, uint8 *, uint32);
#endif #endif

121
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 BF_word BF_key[BF_N + 2];
typedef struct { typedef struct
{
BF_word S[4][0x100]; BF_word S[4][0x100];
BF_key P; BF_key P;
} BF_ctx; } BF_ctx;
@ -347,7 +348,7 @@ static BF_ctx BF_init_state = {
}; };
static unsigned char BF_itoa64[64 + 1] = static unsigned char BF_itoa64[64 + 1] =
"./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"; "./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
static unsigned char BF_atoi64[0x60] = { static unsigned char BF_atoi64[0x60] = {
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 0, 1, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 0, 1,
@ -367,22 +368,30 @@ do { \
(dst) = tmp; \ (dst) = tmp; \
} while (0) } 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 *dptr = (unsigned char *) dst;
unsigned char *end = dptr + size; unsigned char *end = dptr + size;
unsigned char *sptr = (unsigned char *)src; 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(c1, *sptr++);
BF_safe_atoi64(c2, *sptr++); BF_safe_atoi64(c2, *sptr++);
*dptr++ = (c1 << 2) | ((c2 & 0x30) >> 4); *dptr++ = (c1 << 2) | ((c2 & 0x30) >> 4);
if (dptr >= end) break; if (dptr >= end)
break;
BF_safe_atoi64(c3, *sptr++); BF_safe_atoi64(c3, *sptr++);
*dptr++ = ((c2 & 0x0F) << 4) | ((c3 & 0x3C) >> 2); *dptr++ = ((c2 & 0x0F) << 4) | ((c3 & 0x3C) >> 2);
if (dptr >= end) break; if (dptr >= end)
break;
BF_safe_atoi64(c4, *sptr++); BF_safe_atoi64(c4, *sptr++);
*dptr++ = ((c3 & 0x03) << 6) | c4; *dptr++ = ((c3 & 0x03) << 6) | c4;
@ -391,18 +400,22 @@ static int BF_decode(BF_word *dst, const char *src, int size)
return 0; 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 *sptr = (unsigned char *) src;
unsigned char *end = sptr + size; unsigned char *end = sptr + size;
unsigned char *dptr = (unsigned char *)dst; unsigned char *dptr = (unsigned char *) dst;
unsigned int c1, c2; unsigned int c1,
c2;
do { do
{
c1 = *sptr++; c1 = *sptr++;
*dptr++ = BF_itoa64[c1 >> 2]; *dptr++ = BF_itoa64[c1 >> 2];
c1 = (c1 & 0x03) << 4; c1 = (c1 & 0x03) << 4;
if (sptr >= end) { if (sptr >= end)
{
*dptr++ = BF_itoa64[c1]; *dptr++ = BF_itoa64[c1];
break; break;
} }
@ -411,7 +424,8 @@ static void BF_encode(char *dst, const BF_word *src, int size)
c1 |= c2 >> 4; c1 |= c2 >> 4;
*dptr++ = BF_itoa64[c1]; *dptr++ = BF_itoa64[c1];
c1 = (c2 & 0x0f) << 2; c1 = (c2 & 0x0f) << 2;
if (sptr >= end) { if (sptr >= end)
{
*dptr++ = BF_itoa64[c1]; *dptr++ = BF_itoa64[c1];
break; break;
} }
@ -423,14 +437,16 @@ static void BF_encode(char *dst, const BF_word *src, int size)
} while (sptr < end); } 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; static int endianness_check = 1;
char *is_little_endian = (char *)&endianness_check; char *is_little_endian = (char *) &endianness_check;
BF_word tmp; BF_word tmp;
if (*is_little_endian) if (*is_little_endian)
do { do
{
tmp = *x; tmp = *x;
tmp = (tmp << 16) | (tmp >> 16); tmp = (tmp << 16) | (tmp >> 16);
*x++ = ((tmp & 0x00FF00FF) << 8) | ((tmp >> 8) & 0x00FF00FF); *x++ = ((tmp & 0x00FF00FF) << 8) | ((tmp >> 8) & 0x00FF00FF);
@ -504,7 +520,8 @@ static void BF_swap(BF_word *x, int count)
#if BF_ASM #if BF_ASM
extern void _BF_body_r(BF_ctx *ctx); extern void _BF_body_r(BF_ctx * ctx);
#define BF_body() \ #define BF_body() \
_BF_body_r(&data.ctx); _BF_body_r(&data.ctx);
@ -527,22 +544,28 @@ extern void _BF_body_r(BF_ctx *ctx);
*(ptr - 2) = L; \ *(ptr - 2) = L; \
*(ptr - 1) = R; \ *(ptr - 1) = R; \
} while (ptr < &data.ctx.S[3][0xFF]); } while (ptr < &data.ctx.S[3][0xFF]);
#endif #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; const char *ptr = key;
int i, j; int i,
j;
BF_word tmp; BF_word tmp;
for (i = 0; i < BF_N + 2; i++) { for (i = 0; i < BF_N + 2; i++)
{
tmp = 0; tmp = 0;
for (j = 0; j < 4; j++) { for (j = 0; j < 4; j++)
{
tmp <<= 8; tmp <<= 8;
tmp |= *ptr; tmp |= *ptr;
if (!*ptr) ptr = key; else ptr++; if (!*ptr)
ptr = key;
else
ptr++;
} }
expanded[i] = tmp; 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) char *output, int size)
{ {
struct { struct
{
BF_ctx ctx; BF_ctx ctx;
BF_key expanded_key; BF_key expanded_key;
union { union
{
BF_word salt[4]; BF_word salt[4];
BF_word output[6]; BF_word output[6];
} binary; } binary;
} data; } data;
BF_word L, R; BF_word L,
BF_word tmp1, tmp2, tmp3, tmp4; R;
BF_word tmp1,
tmp2,
tmp3,
tmp4;
BF_word *ptr; BF_word *ptr;
BF_word count; BF_word count;
int i; int i;
if (size < 7 + 22 + 31 + 1) { if (size < 7 + 22 + 31 + 1)
{
__set_errno(ERANGE); __set_errno(ERANGE);
return NULL; return NULL;
} }
@ -578,13 +609,15 @@ char *_crypt_blowfish_rn(const char *key, const char *setting,
setting[3] != '$' || setting[3] != '$' ||
setting[4] < '0' || setting[4] > '3' || setting[4] < '0' || setting[4] > '3' ||
setting[5] < '0' || setting[5] > '9' || setting[5] < '0' || setting[5] > '9' ||
setting[6] != '$') { setting[6] != '$')
{
__set_errno(EINVAL); __set_errno(EINVAL);
return NULL; return NULL;
} }
count = (BF_word)1 << ((setting[4] - '0') * 10 + (setting[5] - '0')); 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)); memset(data.binary.salt, 0, sizeof(data.binary.salt));
__set_errno(EINVAL); __set_errno(EINVAL);
return NULL; 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)); memcpy(data.ctx.S, BF_init_state.S, sizeof(data.ctx.S));
L = R = 0; 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]; L ^= data.binary.salt[i & 2];
R ^= data.binary.salt[(i & 2) + 1]; R ^= data.binary.salt[(i & 2) + 1];
BF_ENCRYPT; BF_ENCRYPT;
@ -605,7 +639,8 @@ char *_crypt_blowfish_rn(const char *key, const char *setting,
} }
ptr = data.ctx.S[0]; ptr = data.ctx.S[0];
do { do
{
ptr += 4; ptr += 4;
L ^= data.binary.salt[(BF_N + 2) & 3]; L ^= data.binary.salt[(BF_N + 2) & 3];
R ^= data.binary.salt[(BF_N + 3) & 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; *(ptr - 1) = R;
} while (ptr < &data.ctx.S[3][0xFF]); } while (ptr < &data.ctx.S[3][0xFF]);
do { do
{
data.ctx.P[0] ^= data.expanded_key[0]; data.ctx.P[0] ^= data.expanded_key[0];
data.ctx.P[1] ^= data.expanded_key[1]; data.ctx.P[1] ^= data.expanded_key[1];
data.ctx.P[2] ^= data.expanded_key[2]; data.ctx.P[2] ^= data.expanded_key[2];
@ -668,12 +704,14 @@ char *_crypt_blowfish_rn(const char *key, const char *setting,
BF_body(); BF_body();
} while (--count); } while (--count);
for (i = 0; i < 6; i += 2) { for (i = 0; i < 6; i += 2)
{
L = BF_magic_w[i]; L = BF_magic_w[i];
R = BF_magic_w[i + 1]; R = BF_magic_w[i + 1];
count = 64; count = 64;
do { do
{
BF_ENCRYPT; BF_ENCRYPT;
} while (--count); } while (--count);
@ -683,7 +721,7 @@ char *_crypt_blowfish_rn(const char *key, const char *setting,
memcpy(output, setting, 7 + 22 - 1); memcpy(output, setting, 7 + 22 - 1);
output[7 + 22 - 1] = BF_itoa64[(int) output[7 + 22 - 1] = BF_itoa64[(int)
BF_atoi64[(int)setting[7 + 22 - 1] - 0x20] & 0x30]; BF_atoi64[(int) setting[7 + 22 - 1] - 0x20] & 0x30];
/* This has to be bug-compatible with the original implementation, so /* This has to be bug-compatible with the original implementation, so
* only encode 23 of the 24 bytes. :-) */ * only encode 23 of the 24 bytes. :-) */
@ -698,4 +736,3 @@ char *_crypt_blowfish_rn(const char *key, const char *setting,
return output; return output;
} }

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

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

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

@ -22,25 +22,29 @@
typedef unsigned int BF_word; typedef unsigned int BF_word;
unsigned char _crypt_itoa64[64 + 1] = unsigned char _crypt_itoa64[64 + 1] =
"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; "./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) const char *input, int size, char *output, int output_size)
{ {
if (size < 2 || output_size < 2 + 1 || (count && count != 25)) { if (size < 2 || output_size < 2 + 1 || (count && count != 25))
if (output_size > 0) output[0] = '\0'; {
if (output_size > 0)
output[0] = '\0';
__set_errno((output_size < 2 + 1) ? ERANGE : EINVAL); __set_errno((output_size < 2 + 1) ? ERANGE : EINVAL);
return NULL; return NULL;
} }
output[0] = _crypt_itoa64[(unsigned int)input[0] & 0x3f]; output[0] = _crypt_itoa64[(unsigned int) input[0] & 0x3f];
output[1] = _crypt_itoa64[(unsigned int)input[1] & 0x3f]; output[1] = _crypt_itoa64[(unsigned int) input[1] & 0x3f];
output[2] = '\0'; output[2] = '\0';
return output; 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) const char *input, int size, char *output, int output_size)
{ {
unsigned long value; unsigned long value;
@ -48,22 +52,25 @@ char *_crypt_gensalt_extended_rn(unsigned long count,
/* Even iteration counts make it easier to detect weak DES keys from a look /* Even iteration counts make it easier to detect weak DES keys from a look
* at the hash, so they should be avoided */ * at the hash, so they should be avoided */
if (size < 3 || output_size < 1 + 4 + 4 + 1 || if (size < 3 || output_size < 1 + 4 + 4 + 1 ||
(count && (count > 0xffffff || !(count & 1)))) { (count && (count > 0xffffff || !(count & 1))))
if (output_size > 0) output[0] = '\0'; {
if (output_size > 0)
output[0] = '\0';
__set_errno((output_size < 1 + 4 + 4 + 1) ? ERANGE : EINVAL); __set_errno((output_size < 1 + 4 + 4 + 1) ? ERANGE : EINVAL);
return NULL; return NULL;
} }
if (!count) count = 725; if (!count)
count = 725;
output[0] = '_'; output[0] = '_';
output[1] = _crypt_itoa64[count & 0x3f]; output[1] = _crypt_itoa64[count & 0x3f];
output[2] = _crypt_itoa64[(count >> 6) & 0x3f]; output[2] = _crypt_itoa64[(count >> 6) & 0x3f];
output[3] = _crypt_itoa64[(count >> 12) & 0x3f]; output[3] = _crypt_itoa64[(count >> 12) & 0x3f];
output[4] = _crypt_itoa64[(count >> 18) & 0x3f]; output[4] = _crypt_itoa64[(count >> 18) & 0x3f];
value = (unsigned long)input[0] | value = (unsigned long) input[0] |
((unsigned long)input[1] << 8) | ((unsigned long) input[1] << 8) |
((unsigned long)input[2] << 16); ((unsigned long) input[2] << 16);
output[5] = _crypt_itoa64[value & 0x3f]; output[5] = _crypt_itoa64[value & 0x3f];
output[6] = _crypt_itoa64[(value >> 6) & 0x3f]; output[6] = _crypt_itoa64[(value >> 6) & 0x3f];
output[7] = _crypt_itoa64[(value >> 12) & 0x3f]; output[7] = _crypt_itoa64[(value >> 12) & 0x3f];
@ -73,13 +80,16 @@ char *_crypt_gensalt_extended_rn(unsigned long count,
return output; 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) const char *input, int size, char *output, int output_size)
{ {
unsigned long value; unsigned long value;
if (size < 3 || output_size < 3 + 4 + 1 || (count && count != 1000)) { if (size < 3 || output_size < 3 + 4 + 1 || (count && count != 1000))
if (output_size > 0) output[0] = '\0'; {
if (output_size > 0)
output[0] = '\0';
__set_errno((output_size < 3 + 4 + 1) ? ERANGE : EINVAL); __set_errno((output_size < 3 + 4 + 1) ? ERANGE : EINVAL);
return NULL; return NULL;
} }
@ -87,19 +97,20 @@ char *_crypt_gensalt_md5_rn(unsigned long count,
output[0] = '$'; output[0] = '$';
output[1] = '1'; output[1] = '1';
output[2] = '$'; output[2] = '$';
value = (unsigned long)input[0] | value = (unsigned long) input[0] |
((unsigned long)input[1] << 8) | ((unsigned long) input[1] << 8) |
((unsigned long)input[2] << 16); ((unsigned long) input[2] << 16);
output[3] = _crypt_itoa64[value & 0x3f]; output[3] = _crypt_itoa64[value & 0x3f];
output[4] = _crypt_itoa64[(value >> 6) & 0x3f]; output[4] = _crypt_itoa64[(value >> 6) & 0x3f];
output[5] = _crypt_itoa64[(value >> 12) & 0x3f]; output[5] = _crypt_itoa64[(value >> 12) & 0x3f];
output[6] = _crypt_itoa64[(value >> 18) & 0x3f]; output[6] = _crypt_itoa64[(value >> 18) & 0x3f];
output[7] = '\0'; 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) | value = (unsigned long) input[3] |
((unsigned long)input[5] << 16); ((unsigned long) input[4] << 8) |
((unsigned long) input[5] << 16);
output[7] = _crypt_itoa64[value & 0x3f]; output[7] = _crypt_itoa64[value & 0x3f];
output[8] = _crypt_itoa64[(value >> 6) & 0x3f]; output[8] = _crypt_itoa64[(value >> 6) & 0x3f];
output[9] = _crypt_itoa64[(value >> 12) & 0x3f]; output[9] = _crypt_itoa64[(value >> 12) & 0x3f];
@ -113,20 +124,24 @@ char *_crypt_gensalt_md5_rn(unsigned long count,
static unsigned char BF_itoa64[64 + 1] = static unsigned char BF_itoa64[64 + 1] =
"./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"; "./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 *sptr = (unsigned char *) src;
unsigned char *end = sptr + size; unsigned char *end = sptr + size;
unsigned char *dptr = (unsigned char *)dst; unsigned char *dptr = (unsigned char *) dst;
unsigned int c1, c2; unsigned int c1,
c2;
do { do
{
c1 = *sptr++; c1 = *sptr++;
*dptr++ = BF_itoa64[c1 >> 2]; *dptr++ = BF_itoa64[c1 >> 2];
c1 = (c1 & 0x03) << 4; c1 = (c1 & 0x03) << 4;
if (sptr >= end) { if (sptr >= end)
{
*dptr++ = BF_itoa64[c1]; *dptr++ = BF_itoa64[c1];
break; break;
} }
@ -135,7 +150,8 @@ static void BF_encode(char *dst, const BF_word *src, int size)
c1 |= c2 >> 4; c1 |= c2 >> 4;
*dptr++ = BF_itoa64[c1]; *dptr++ = BF_itoa64[c1];
c1 = (c2 & 0x0f) << 2; c1 = (c2 & 0x0f) << 2;
if (sptr >= end) { if (sptr >= end)
{
*dptr++ = BF_itoa64[c1]; *dptr++ = BF_itoa64[c1];
break; break;
} }
@ -147,17 +163,21 @@ static void BF_encode(char *dst, const BF_word *src, int size)
} while (sptr < end); } 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) const char *input, int size, char *output, int output_size)
{ {
if (size < 16 || output_size < 7 + 22 + 1 || if (size < 16 || output_size < 7 + 22 + 1 ||
(count && (count < 4 || count > 31))) { (count && (count < 4 || count > 31)))
if (output_size > 0) output[0] = '\0'; {
if (output_size > 0)
output[0] = '\0';
__set_errno((output_size < 7 + 22 + 1) ? ERANGE : EINVAL); __set_errno((output_size < 7 + 22 + 1) ? ERANGE : EINVAL);
return NULL; return NULL;
} }
if (!count) count = 5; if (!count)
count = 5;
output[0] = '$'; output[0] = '$';
output[1] = '2'; output[1] = '2';
@ -167,9 +187,8 @@ char *_crypt_gensalt_blowfish_rn(unsigned long count,
output[5] = '0' + count % 10; output[5] = '0' + count % 10;
output[6] = '$'; output[6] = '$';
BF_encode(&output[7], (BF_word *)input, 16); BF_encode(&output[7], (BF_word *) input, 16);
output[7 + 22] = '\0'; output[7 + 22] = '\0';
return output; 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 $ * $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 <postgres.h>
#include "px.h" #include "px.h"
@ -23,12 +23,9 @@
char * char *
px_crypt_md5(const char *pw, const char *salt, char *passwd, unsigned dstlen) px_crypt_md5(const char *pw, const char *salt, char *passwd, unsigned dstlen)
{ {
static char *magic = "$1$"; /* static char *magic = "$1$"; /* This string is magic for this
* This string is magic for * algorithm. Having it this way, we can
* this algorithm. Having * get get better later on */
* it this way, we can get
* get better later on
*/
static char *p; static char *p;
static const char *sp, static const char *sp,
*ep; *ep;
@ -99,9 +96,9 @@ px_crypt_md5(const char *pw, const char *salt, char *passwd, unsigned dstlen)
px_md_finish(ctx, final); px_md_finish(ctx, final);
/* /*
* and now, just to make sure things don't run too fast * and now, just to make sure things don't run too fast On a 60 Mhz
* On a 60 Mhz Pentium this takes 34 msec, so you would * Pentium this takes 34 msec, so you would need 30 seconds to build a
* need 30 seconds to build a 1000 entry dictionary... * 1000 entry dictionary...
*/ */
for (i = 0; i < 1000; i++) for (i = 0; i < 1000; i++)
{ {

214
contrib/pgcrypto/internal.c
View File

@ -26,7 +26,7 @@
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE. * 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; char *name;
void (*init) (PX_MD * h); void (*init) (PX_MD * h);
} int_digest_list[] = } int_digest_list[] =
{ {
{ "md5", init_md5 }, {
{ "sha1", init_sha1 }, "md5", init_md5
{ NULL, NULL } },
{
"sha1", init_sha1
},
{
NULL, NULL
}
}; };
/* MD5 */ /* MD5 */
@ -83,7 +90,7 @@ int_md5_block_len(PX_MD * h)
} }
static void static void
int_md5_update(PX_MD * h, const uint8 * data, uint dlen) int_md5_update(PX_MD * h, const uint8 *data, uint dlen)
{ {
MD5_CTX *ctx = (MD5_CTX *) h->p.ptr; MD5_CTX *ctx = (MD5_CTX *) h->p.ptr;
@ -99,7 +106,7 @@ int_md5_reset(PX_MD * h)
} }
static void static void
int_md5_finish(PX_MD * h, uint8 * dst) int_md5_finish(PX_MD * h, uint8 *dst)
{ {
MD5_CTX *ctx = (MD5_CTX *) h->p.ptr; MD5_CTX *ctx = (MD5_CTX *) h->p.ptr;
@ -130,7 +137,7 @@ int_sha1_block_len(PX_MD * h)
} }
static void static void
int_sha1_update(PX_MD * h, const uint8 * data, uint dlen) int_sha1_update(PX_MD * h, const uint8 *data, uint dlen)
{ {
SHA1_CTX *ctx = (SHA1_CTX *) h->p.ptr; SHA1_CTX *ctx = (SHA1_CTX *) h->p.ptr;
@ -146,7 +153,7 @@ int_sha1_reset(PX_MD * h)
} }
static void static void
int_sha1_finish(PX_MD * h, uint8 * dst) int_sha1_finish(PX_MD * h, uint8 *dst)
{ {
SHA1_CTX *ctx = (SHA1_CTX *) h->p.ptr; SHA1_CTX *ctx = (SHA1_CTX *) h->p.ptr;
@ -209,10 +216,12 @@ init_sha1(PX_MD * md)
#define INT_MAX_KEY (512/8) #define INT_MAX_KEY (512/8)
#define INT_MAX_IV (128/8) #define INT_MAX_IV (128/8)
struct int_ctx { struct int_ctx
{
uint8 keybuf[INT_MAX_KEY]; uint8 keybuf[INT_MAX_KEY];
uint8 iv[INT_MAX_IV]; uint8 iv[INT_MAX_IV];
union { union
{
blf_ctx bf; blf_ctx bf;
rijndael_ctx rj; rijndael_ctx rj;
} ctx; } ctx;
@ -221,10 +230,13 @@ struct int_ctx {
int mode; 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; struct int_ctx *cx = (struct int_ctx *) c->ptr;
if (cx) {
if (cx)
{
memset(cx, 0, sizeof *cx); memset(cx, 0, sizeof *cx);
px_free(cx); px_free(cx);
} }
@ -238,53 +250,60 @@ static void intctx_free(PX_Cipher *c)
#define MODE_ECB 0 #define MODE_ECB 0
#define MODE_CBC 1 #define MODE_CBC 1
static uint rj_block_size(PX_Cipher *c) static uint
rj_block_size(PX_Cipher * c)
{ {
return 128/8; return 128 / 8;
} }
static uint rj_key_size(PX_Cipher *c) static uint
rj_key_size(PX_Cipher * c)
{ {
return 256/8; return 256 / 8;
} }
static uint rj_iv_size(PX_Cipher *c) static uint
rj_iv_size(PX_Cipher * c)
{ {
return 128/8; 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; struct int_ctx *cx = (struct int_ctx *) c->ptr;
if (klen <= 128/8) if (klen <= 128 / 8)
cx->keylen = 128/8; cx->keylen = 128 / 8;
else if (klen <= 192/8) else if (klen <= 192 / 8)
cx->keylen = 192/8; cx->keylen = 192 / 8;
else if (klen <= 256/8) else if (klen <= 256 / 8)
cx->keylen = 256/8; cx->keylen = 256 / 8;
else else
return -1; return -1;
memcpy(&cx->keybuf, key, klen); memcpy(&cx->keybuf, key, klen);
if (iv) if (iv)
memcpy(cx->iv, iv, 128/8); memcpy(cx->iv, iv, 128 / 8);
return 0; 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); aes_set_key(&cx->ctx.rj, cx->keybuf, cx->keylen * 8, dir);
return 0; 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; struct int_ctx *cx = (struct int_ctx *) c->ptr;
if (!cx->is_init) { if (!cx->is_init)
{
if (rj_real_init(cx, 1)) if (rj_real_init(cx, 1))
return -1; return -1;
} }
@ -292,23 +311,26 @@ static int rj_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
if (dlen == 0) if (dlen == 0)
return 0; return 0;
if ((dlen & 15) || (((unsigned)res) & 3)) if ((dlen & 15) || (((unsigned) res) & 3))
return -1; return -1;
memcpy(res, data, dlen); memcpy(res, data, dlen);
if (cx->mode == MODE_CBC) { if (cx->mode == MODE_CBC)
{
aes_cbc_encrypt(&cx->ctx.rj, cx->iv, res, dlen); aes_cbc_encrypt(&cx->ctx.rj, cx->iv, res, dlen);
memcpy(cx->iv, res + dlen - 16, 16); memcpy(cx->iv, res + dlen - 16, 16);
} else }
else
aes_ecb_encrypt(&cx->ctx.rj, res, dlen); aes_ecb_encrypt(&cx->ctx.rj, res, dlen);
return 0; 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; struct int_ctx *cx = (struct int_ctx *) c->ptr;
if (!cx->is_init) if (!cx->is_init)
if (rj_real_init(cx, 0)) if (rj_real_init(cx, 0))
@ -317,15 +339,17 @@ static int rj_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
if (dlen == 0) if (dlen == 0)
return 0; return 0;
if ((dlen & 15) || (((unsigned)res) & 3)) if ((dlen & 15) || (((unsigned) res) & 3))
return -1; return -1;
memcpy(res, data, dlen); memcpy(res, data, dlen);
if (cx->mode == MODE_CBC) { if (cx->mode == MODE_CBC)
{
aes_cbc_decrypt(&cx->ctx.rj, cx->iv, res, dlen); aes_cbc_decrypt(&cx->ctx.rj, cx->iv, res, dlen);
memcpy(cx->iv, data + dlen - 16, 16); memcpy(cx->iv, data + dlen - 16, 16);
} else }
else
aes_ecb_decrypt(&cx->ctx.rj, res, dlen); aes_ecb_decrypt(&cx->ctx.rj, res, dlen);
return 0; return 0;
@ -335,7 +359,8 @@ static int rj_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
* initializers * initializers
*/ */
static PX_Cipher * rj_load(int mode) static PX_Cipher *
rj_load(int mode)
{ {
PX_Cipher *c; PX_Cipher *c;
struct int_ctx *cx; struct int_ctx *cx;
@ -363,24 +388,28 @@ static PX_Cipher * rj_load(int mode)
* blowfish * blowfish
*/ */
static uint bf_block_size(PX_Cipher *c) static uint
bf_block_size(PX_Cipher * c)
{ {
return 8; return 8;
} }
static uint bf_key_size(PX_Cipher *c) static uint
bf_key_size(PX_Cipher * c)
{ {
return BLF_MAXKEYLEN; return BLF_MAXKEYLEN;
} }
static uint bf_iv_size(PX_Cipher *c) static uint
bf_iv_size(PX_Cipher * c)
{ {
return 8; 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; struct int_ctx *cx = (struct int_ctx *) c->ptr;
blf_key(&cx->ctx.bf, key, klen); blf_key(&cx->ctx.bf, key, klen);
if (iv) if (iv)
@ -389,18 +418,20 @@ static int bf_init(PX_Cipher *c, const uint8 *key, uint klen, const uint8 *iv)
return 0; 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; struct int_ctx *cx = (struct int_ctx *) c->ptr;
if (dlen == 0) if (dlen == 0)
return 0; return 0;
if ((dlen & 7) || (((unsigned)res) & 3)) if ((dlen & 7) || (((unsigned) res) & 3))
return -1; return -1;
memcpy(res, data, dlen); memcpy(res, data, dlen);
switch (cx->mode) { switch (cx->mode)
{
case MODE_ECB: case MODE_ECB:
blf_ecb_encrypt(&cx->ctx.bf, res, dlen); blf_ecb_encrypt(&cx->ctx.bf, res, dlen);
break; break;
@ -411,18 +442,20 @@ static int bf_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
return 0; 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; struct int_ctx *cx = (struct int_ctx *) c->ptr;
if (dlen == 0) if (dlen == 0)
return 0; return 0;
if ((dlen & 7) || (((unsigned)res) & 3)) if ((dlen & 7) || (((unsigned) res) & 3))
return -1; return -1;
memcpy(res, data, dlen); memcpy(res, data, dlen);
switch (cx->mode) { switch (cx->mode)
{
case MODE_ECB: case MODE_ECB:
blf_ecb_decrypt(&cx->ctx.bf, res, dlen); blf_ecb_decrypt(&cx->ctx.bf, res, dlen);
break; break;
@ -433,7 +466,8 @@ static int bf_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
return 0; return 0;
} }
static PX_Cipher * bf_load(int mode) static PX_Cipher *
bf_load(int mode)
{ {
PX_Cipher *c; PX_Cipher *c;
struct int_ctx *cx; struct int_ctx *cx;
@ -458,47 +492,64 @@ static PX_Cipher * bf_load(int mode)
/* ciphers */ /* ciphers */
static PX_Cipher * rj_128_ecb() static PX_Cipher *
rj_128_ecb()
{ {
return rj_load(MODE_ECB); return rj_load(MODE_ECB);
} }
static PX_Cipher * rj_128_cbc() static PX_Cipher *
rj_128_cbc()
{ {
return rj_load(MODE_CBC); return rj_load(MODE_CBC);
} }
static PX_Cipher * bf_ecb_load() static PX_Cipher *
bf_ecb_load()
{ {
return bf_load(MODE_ECB); return bf_load(MODE_ECB);
} }
static PX_Cipher * bf_cbc_load() static PX_Cipher *
bf_cbc_load()
{ {
return bf_load(MODE_CBC); return bf_load(MODE_CBC);
} }
static struct { static struct
{
char *name; char *name;
PX_Cipher *(*load)(void); PX_Cipher *(*load) (void);
} int_ciphers [] = { } int_ciphers[] =
{ "bf-cbc", bf_cbc_load },
{ "bf-ecb", bf_ecb_load }, {
{ "aes-128-cbc", rj_128_cbc }, {
{ "aes-128-ecb", rj_128_ecb }, "bf-cbc", bf_cbc_load
{ NULL, NULL } },
{
"bf-ecb", bf_ecb_load
},
{
"aes-128-cbc", rj_128_cbc
},
{
"aes-128-ecb", rj_128_ecb
},
{
NULL, NULL
}
}; };
static PX_Alias int_aliases [] = { static PX_Alias int_aliases[] = {
{ "bf", "bf-cbc" }, {"bf", "bf-cbc"},
{ "blowfish", "bf-cbc" }, {"blowfish", "bf-cbc"},
{ "aes", "aes-128-cbc" }, {"aes", "aes-128-cbc"},
{ "aes-ecb", "aes-128-ecb" }, {"aes-ecb", "aes-128-ecb"},
{ "aes-cbc", "aes-128-cbc" }, {"aes-cbc", "aes-128-cbc"},
{ "aes-128", "aes-128-cbc" }, {"aes-128", "aes-128-cbc"},
{ "rijndael", "aes-128-cbc" }, {"rijndael", "aes-128-cbc"},
{ "rijndael-128", "aes-128-cbc" }, {"rijndael-128", "aes-128-cbc"},
{ NULL, NULL } {NULL, NULL}
}; };
/* PUBLIC FUNCTIONS */ /* PUBLIC FUNCTIONS */
@ -523,7 +574,7 @@ px_find_digest(const char *name, PX_MD ** res)
} }
int int
px_find_cipher(const char *name, PX_Cipher **res) px_find_cipher(const char *name, PX_Cipher ** res)
{ {
int i; int i;
PX_Cipher *c = NULL; PX_Cipher *c = NULL;
@ -531,7 +582,8 @@ px_find_cipher(const char *name, PX_Cipher **res)
name = px_resolve_alias(int_aliases, name); name = px_resolve_alias(int_aliases, name);
for (i = 0; int_ciphers[i].name; i++) 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(); c = int_ciphers[i].load();
break; break;
} }
@ -542,5 +594,3 @@ px_find_cipher(const char *name, PX_Cipher **res)
*res = c; *res = c;
return 0; return 0;
} }

12
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 $ */ /* $KAME: md5.c,v 1.3 2000/02/22 14:01:17 itojun Exp $ */
/* /*
@ -132,7 +132,7 @@ static const uint8 md5_paddat[MD5_BUFLEN] = {
static void md5_calc(uint8 *, md5_ctxt *); static void md5_calc(uint8 *, md5_ctxt *);
void void
md5_init(md5_ctxt *ctxt) md5_init(md5_ctxt * ctxt)
{ {
ctxt->md5_n = 0; ctxt->md5_n = 0;
ctxt->md5_i = 0; ctxt->md5_i = 0;
@ -144,7 +144,7 @@ md5_init(md5_ctxt *ctxt)
} }
void void
md5_loop(md5_ctxt *ctxt, const uint8 *input, unsigned len) md5_loop(md5_ctxt * ctxt, const uint8 *input, unsigned len)
{ {
unsigned int gap, unsigned int gap,
i; i;
@ -173,7 +173,7 @@ md5_loop(md5_ctxt *ctxt, const uint8 *input, unsigned len)
} }
void void
md5_pad(md5_ctxt *ctxt) md5_pad(md5_ctxt * ctxt)
{ {
unsigned int gap; unsigned int gap;
@ -215,7 +215,7 @@ md5_pad(md5_ctxt *ctxt)
} }
void void
md5_result(uint8 *digest, md5_ctxt *ctxt) md5_result(uint8 *digest, md5_ctxt * ctxt)
{ {
/* 4 byte words */ /* 4 byte words */
#if BYTE_ORDER == LITTLE_ENDIAN #if BYTE_ORDER == LITTLE_ENDIAN
@ -246,7 +246,7 @@ static uint32 X[16];
#endif #endif
static void static void
md5_calc(uint8 *b64, md5_ctxt *ctxt) md5_calc(uint8 *b64, md5_ctxt * ctxt)
{ {
uint32 A = ctxt->md5_sta; uint32 A = ctxt->md5_sta;
uint32 B = ctxt->md5_stb; uint32 B = ctxt->md5_stb;

97
contrib/pgcrypto/mhash.c
View File

@ -26,7 +26,7 @@
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE. * 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> #include <postgres.h>
@ -75,7 +75,7 @@ digest_reset(PX_MD * h)
} }
static void static void
digest_update(PX_MD * h, const uint8 * data, uint dlen) digest_update(PX_MD * h, const uint8 *data, uint dlen)
{ {
MHASH mh = (MHASH) h->p.ptr; MHASH mh = (MHASH) h->p.ptr;
@ -83,7 +83,7 @@ digest_update(PX_MD * h, const uint8 * data, uint dlen)
} }
static void static void
digest_finish(PX_MD * h, uint8 * dst) digest_finish(PX_MD * h, uint8 *dst)
{ {
MHASH mh = (MHASH) h->p.ptr; MHASH mh = (MHASH) h->p.ptr;
uint hlen = digest_result_size(h); uint hlen = digest_result_size(h);
@ -111,34 +111,37 @@ digest_free(PX_MD * h)
/* ENCRYPT / DECRYPT */ /* ENCRYPT / DECRYPT */
static uint static uint
cipher_block_size(PX_Cipher *c) cipher_block_size(PX_Cipher * c)
{ {
MCRYPT ctx = (MCRYPT)c->ptr; MCRYPT ctx = (MCRYPT) c->ptr;
return mcrypt_enc_get_block_size(ctx); return mcrypt_enc_get_block_size(ctx);
} }
static uint static uint
cipher_key_size(PX_Cipher *c) cipher_key_size(PX_Cipher * c)
{ {
MCRYPT ctx = (MCRYPT)c->ptr; MCRYPT ctx = (MCRYPT) c->ptr;
return mcrypt_enc_get_key_size(ctx); return mcrypt_enc_get_key_size(ctx);
} }
static uint static uint
cipher_iv_size(PX_Cipher *c) cipher_iv_size(PX_Cipher * c)
{ {
MCRYPT ctx = (MCRYPT)c->ptr; MCRYPT ctx = (MCRYPT) c->ptr;
return mcrypt_enc_mode_has_iv(ctx) return mcrypt_enc_mode_has_iv(ctx)
? mcrypt_enc_get_iv_size(ctx) : 0; ? mcrypt_enc_get_iv_size(ctx) : 0;
} }
static int static int
cipher_init(PX_Cipher *c, const uint8 *key, uint klen, const uint8 *iv) cipher_init(PX_Cipher * c, const uint8 *key, uint klen, const uint8 *iv)
{ {
int err; int err;
MCRYPT ctx = (MCRYPT)c->ptr; MCRYPT ctx = (MCRYPT) c->ptr;
err = mcrypt_generic_init(ctx, (char *)key, klen, (char*)iv); err = mcrypt_generic_init(ctx, (char *) key, klen, (char *) iv);
if (err < 0) if (err < 0)
elog(ERROR, "mcrypt_generic_init error: %s", mcrypt_strerror(err)); elog(ERROR, "mcrypt_generic_init error: %s", mcrypt_strerror(err));
@ -147,10 +150,10 @@ cipher_init(PX_Cipher *c, const uint8 *key, uint klen, const uint8 *iv)
} }
static int static int
cipher_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) cipher_encrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res)
{ {
int err; int err;
MCRYPT ctx = (MCRYPT)c->ptr; MCRYPT ctx = (MCRYPT) c->ptr;
memcpy(res, data, dlen); memcpy(res, data, dlen);
@ -161,10 +164,10 @@ cipher_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
} }
static int static int
cipher_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) cipher_decrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res)
{ {
int err; int err;
MCRYPT ctx = (MCRYPT)c->ptr; MCRYPT ctx = (MCRYPT) c->ptr;
memcpy(res, data, dlen); memcpy(res, data, dlen);
@ -176,9 +179,9 @@ cipher_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
static void static void
cipher_free(PX_Cipher *c) cipher_free(PX_Cipher * c)
{ {
MCRYPT ctx = (MCRYPT)c->ptr; MCRYPT ctx = (MCRYPT) c->ptr;
if (c->pstat) if (c->pstat)
mcrypt_generic_end(ctx); mcrypt_generic_end(ctx);
@ -223,30 +226,31 @@ static char *modes[] = {
}; };
static PX_Alias aliases[] = { static PX_Alias aliases[] = {
{"bf", "blowfish" }, {"bf", "blowfish"},
{"3des", "tripledes" }, {"3des", "tripledes"},
{"des3", "tripledes" }, {"des3", "tripledes"},
{"aes", "rijndael-128" }, {"aes", "rijndael-128"},
{"rijndael", "rijndael-128" }, {"rijndael", "rijndael-128"},
{"aes-128", "rijndael-128" }, {"aes-128", "rijndael-128"},
{"aes-192", "rijndael-192" }, {"aes-192", "rijndael-192"},
{"aes-256", "rijndael-256" }, {"aes-256", "rijndael-256"},
{ NULL, NULL } {NULL, NULL}
}; };
static PX_Alias mode_aliases[] = { static PX_Alias mode_aliases[] = {
#if 0 /* N/A */ #if 0 /* N/A */
{ "cfb", "ncfb" }, {"cfb", "ncfb"},
{ "ofb", "nofb" }, {"ofb", "nofb"},
{ "cfb64", "ncfb" }, {"cfb64", "ncfb"},
#endif #endif
/* { "ofb64", "nofb" }, not sure it works */ /* { "ofb64", "nofb" }, not sure it works */
{ "cfb8", "cfb" }, {"cfb8", "cfb"},
{ "ofb8", "ofb" }, {"ofb8", "ofb"},
{ NULL, NULL } {NULL, NULL}
}; };
static int is_mode(char *s) static int
is_mode(char *s)
{ {
char **p; char **p;
@ -263,7 +267,7 @@ static int is_mode(char *s)
/* PUBLIC FUNCTIONS */ /* PUBLIC FUNCTIONS */
int int
px_find_digest(const char *name, PX_MD **res) px_find_digest(const char *name, PX_MD ** res)
{ {
PX_MD *h; PX_MD *h;
MHASH mh; MHASH mh;
@ -290,7 +294,7 @@ px_find_digest(const char *name, PX_MD **res)
int int
px_find_cipher(const char *name, PX_Cipher **res) px_find_cipher(const char *name, PX_Cipher ** res)
{ {
char nbuf[PX_MAX_NAMELEN + 1]; char nbuf[PX_MAX_NAMELEN + 1];
const char *mode = NULL; const char *mode = NULL;
@ -301,8 +305,10 @@ px_find_cipher(const char *name, PX_Cipher **res)
strcpy(nbuf, name); strcpy(nbuf, name);
if ((p = strrchr(nbuf, '-')) != NULL) { if ((p = strrchr(nbuf, '-')) != NULL)
if (is_mode(p + 1)) { {
if (is_mode(p + 1))
{
mode = p + 1; mode = p + 1;
*p = 0; *p = 0;
} }
@ -310,19 +316,19 @@ px_find_cipher(const char *name, PX_Cipher **res)
name = px_resolve_alias(aliases, nbuf); name = px_resolve_alias(aliases, nbuf);
if (!mode) { if (!mode)
{
mode = "cbc"; mode = "cbc";
/* /*
if (mcrypt_module_is_block_algorithm(name, NULL)) * if (mcrypt_module_is_block_algorithm(name, NULL)) mode = "cbc";
mode = "cbc"; * else mode = "stream";
else
mode = "stream";
*/ */
} }
mode = px_resolve_alias(mode_aliases, mode); mode = px_resolve_alias(mode_aliases, mode);
ctx = mcrypt_module_open((char*)name, NULL, (char*)mode, NULL); ctx = mcrypt_module_open((char *) name, NULL, (char *) mode, NULL);
if (ctx == (void*)MCRYPT_FAILED) if (ctx == (void *) MCRYPT_FAILED)
return -1; return -1;
c = palloc(sizeof *c); c = palloc(sizeof *c);
@ -339,4 +345,3 @@ px_find_cipher(const char *name, PX_Cipher **res)
*res = c; *res = c;
return 0; return 0;
} }

2
contrib/pgcrypto/misc.c
View File

@ -33,7 +33,7 @@
#include "px-crypt.h" #include "px-crypt.h"
char px_crypt_a64[] = char px_crypt_a64[] =
"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
/* 0000000000111111111122222222223333333333444444444455555555556666 */ /* 0000000000111111111122222222223333333333444444444455555555556666 */
/* 0123456789012345678901234567890123456789012345678901234567890123 */ /* 0123456789012345678901234567890123456789012345678901234567890123 */

174
contrib/pgcrypto/openssl.c
View File

@ -26,7 +26,7 @@
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE. * 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> #include <postgres.h>
@ -60,7 +60,7 @@ digest_reset(PX_MD * h)
} }
static void static void
digest_update(PX_MD * h, const uint8 * data, uint dlen) digest_update(PX_MD * h, const uint8 *data, uint dlen)
{ {
EVP_MD_CTX *ctx = (EVP_MD_CTX *) h->p.ptr; EVP_MD_CTX *ctx = (EVP_MD_CTX *) h->p.ptr;
@ -68,7 +68,7 @@ digest_update(PX_MD * h, const uint8 * data, uint dlen)
} }
static void static void
digest_finish(PX_MD * h, uint8 * dst) digest_finish(PX_MD * h, uint8 *dst)
{ {
EVP_MD_CTX *ctx = (EVP_MD_CTX *) h->p.ptr; EVP_MD_CTX *ctx = (EVP_MD_CTX *) h->p.ptr;
@ -94,9 +94,12 @@ digest_free(PX_MD * h)
*/ */
typedef struct { typedef struct
union { {
struct { union
{
struct
{
BF_KEY key; BF_KEY key;
int num; int num;
} bf; } bf;
@ -112,32 +115,36 @@ typedef struct {
/* generic EVP */ /* generic EVP */
static uint static uint
gen_evp_block_size(PX_Cipher *c) gen_evp_block_size(PX_Cipher * c)
{ {
ossldata *od = (ossldata *)c->ptr; ossldata *od = (ossldata *) c->ptr;
return EVP_CIPHER_block_size(od->evp_ciph); return EVP_CIPHER_block_size(od->evp_ciph);
} }
static uint static uint
gen_evp_key_size(PX_Cipher *c) gen_evp_key_size(PX_Cipher * c)
{ {
ossldata *od = (ossldata *)c->ptr; ossldata *od = (ossldata *) c->ptr;
return EVP_CIPHER_key_length(od->evp_ciph); return EVP_CIPHER_key_length(od->evp_ciph);
} }
static uint static uint
gen_evp_iv_size(PX_Cipher *c) gen_evp_iv_size(PX_Cipher * c)
{ {
uint ivlen; uint ivlen;
ossldata *od = (ossldata *)c->ptr; ossldata *od = (ossldata *) c->ptr;
ivlen = EVP_CIPHER_iv_length(od->evp_ciph); ivlen = EVP_CIPHER_iv_length(od->evp_ciph);
return ivlen; return ivlen;
} }
static void static void
gen_evp_free(PX_Cipher *c) gen_evp_free(PX_Cipher * c)
{ {
ossldata *od = (ossldata*)c->ptr; ossldata *od = (ossldata *) c->ptr;
memset(od, 0, sizeof(*od)); memset(od, 0, sizeof(*od));
pfree(od); pfree(od);
pfree(c); pfree(c);
@ -146,13 +153,14 @@ gen_evp_free(PX_Cipher *c)
/* fun */ /* fun */
static int static int
gen_evp_init(PX_Cipher *c, const uint8 *key, uint klen, const uint8 *iv) gen_evp_init(PX_Cipher * c, const uint8 *key, uint klen, const uint8 *iv)
{ {
ossldata *od = (ossldata*)c->ptr; ossldata *od = (ossldata *) c->ptr;
uint bs = gen_evp_block_size(c); uint bs = gen_evp_block_size(c);
if (iv) {
if (iv)
memcpy(od->iv, iv, bs); memcpy(od->iv, iv, bs);
} else else
memset(od->iv, 0, bs); memset(od->iv, 0, bs);
memcpy(od->key, key, klen); memcpy(od->key, key, klen);
od->klen = klen; od->klen = klen;
@ -161,7 +169,7 @@ gen_evp_init(PX_Cipher *c, const uint8 *key, uint klen, const uint8 *iv)
} }
static void static void
_gen_init(PX_Cipher *c, int enc) _gen_init(PX_Cipher * c, int enc)
{ {
ossldata *od = c->ptr; ossldata *od = c->ptr;
@ -171,9 +179,10 @@ _gen_init(PX_Cipher *c, int enc)
} }
static int static int
gen_evp_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) gen_evp_encrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res)
{ {
ossldata *od = c->ptr; ossldata *od = c->ptr;
if (!od->init) if (!od->init)
_gen_init(c, 1); _gen_init(c, 1);
od->evp_ciph->do_cipher(&od->u.evp_ctx, res, data, dlen); od->evp_ciph->do_cipher(&od->u.evp_ctx, res, data, dlen);
@ -181,9 +190,10 @@ gen_evp_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
} }
static int static int
gen_evp_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) gen_evp_decrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res)
{ {
ossldata *od = c->ptr; ossldata *od = c->ptr;
if (!od->init) if (!od->init)
_gen_init(c, 0); _gen_init(c, 0);
od->evp_ciph->do_cipher(&od->u.evp_ctx, res, data, dlen); od->evp_ciph->do_cipher(&od->u.evp_ctx, res, data, dlen);
@ -193,84 +203,95 @@ gen_evp_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
/* Blowfish */ /* Blowfish */
static int static int
bf_init(PX_Cipher *c, const uint8 *key, uint klen, const uint8 *iv) bf_init(PX_Cipher * c, const uint8 *key, uint klen, const uint8 *iv)
{ {
ossldata *od = c->ptr; ossldata *od = c->ptr;
BF_set_key(&od->u.bf.key, klen, key); BF_set_key(&od->u.bf.key, klen, key);
if (iv) { if (iv)
memcpy(od->iv, iv, BF_BLOCK); memcpy(od->iv, iv, BF_BLOCK);
} else else
memset(od->iv, 0, BF_BLOCK); memset(od->iv, 0, BF_BLOCK);
od->u.bf.num = 0; od->u.bf.num = 0;
return 0; return 0;
} }
static int static int
bf_ecb_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) 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; ossldata *od = c->ptr;
for (i = 0; i < dlen / bs; i++) for (i = 0; i < dlen / bs; i++)
BF_ecb_encrypt(data+i*bs, res+i*bs, &od->u.bf.key, BF_ENCRYPT); BF_ecb_encrypt(data + i * bs, res + i * bs, &od->u.bf.key, BF_ENCRYPT);
return 0; return 0;
} }
static int static int
bf_ecb_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) 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; ossldata *od = c->ptr;
for (i = 0; i < dlen / bs; i++) for (i = 0; i < dlen / bs; i++)
BF_ecb_encrypt(data+i*bs, res+i*bs, &od->u.bf.key, BF_DECRYPT); BF_ecb_encrypt(data + i * bs, res + i * bs, &od->u.bf.key, BF_DECRYPT);
return 0; return 0;
} }
static int static int
bf_cbc_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) bf_cbc_encrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res)
{ {
ossldata *od = c->ptr; ossldata *od = c->ptr;
BF_cbc_encrypt(data, res, dlen, &od->u.bf.key, od->iv, BF_ENCRYPT); BF_cbc_encrypt(data, res, dlen, &od->u.bf.key, od->iv, BF_ENCRYPT);
return 0; return 0;
} }
static int static int
bf_cbc_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) bf_cbc_decrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res)
{ {
ossldata *od = c->ptr; ossldata *od = c->ptr;
BF_cbc_encrypt(data, res, dlen, &od->u.bf.key, od->iv, BF_DECRYPT); BF_cbc_encrypt(data, res, dlen, &od->u.bf.key, od->iv, BF_DECRYPT);
return 0; return 0;
} }
static int static int
bf_cfb64_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) bf_cfb64_encrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res)
{ {
ossldata *od = c->ptr; ossldata *od = c->ptr;
BF_cfb64_encrypt(data, res, dlen, &od->u.bf.key, od->iv, BF_cfb64_encrypt(data, res, dlen, &od->u.bf.key, od->iv,
&od->u.bf.num, BF_ENCRYPT); &od->u.bf.num, BF_ENCRYPT);
return 0; return 0;
} }
static int static int
bf_cfb64_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) bf_cfb64_decrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res)
{ {
ossldata *od = c->ptr; ossldata *od = c->ptr;
BF_cfb64_encrypt(data, res, dlen, &od->u.bf.key, od->iv, BF_cfb64_encrypt(data, res, dlen, &od->u.bf.key, od->iv,
&od->u.bf.num, BF_DECRYPT); &od->u.bf.num, BF_DECRYPT);
return 0; return 0;
} }
static int static int
bf_ofb64_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) bf_ofb64_encrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res)
{ {
ossldata *od = c->ptr; ossldata *od = c->ptr;
BF_ofb64_encrypt(data, res, dlen, &od->u.bf.key, od->iv, &od->u.bf.num); BF_ofb64_encrypt(data, res, dlen, &od->u.bf.key, od->iv, &od->u.bf.num);
return 0; return 0;
} }
static int static int
bf_ofb64_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) bf_ofb64_decrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res)
{ {
ossldata *od = c->ptr; ossldata *od = c->ptr;
BF_ofb64_encrypt(data, res, dlen, &od->u.bf.key, od->iv, &od->u.bf.num); BF_ofb64_encrypt(data, res, dlen, &od->u.bf.key, od->iv, &od->u.bf.num);
return 0; return 0;
} }
@ -279,14 +300,14 @@ bf_ofb64_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
* aliases * aliases
*/ */
static PX_Alias ossl_aliases [] = { static PX_Alias ossl_aliases[] = {
{ "bf", "bf-cbc" }, {"bf", "bf-cbc"},
{ "blowfish", "bf-cbc" }, {"blowfish", "bf-cbc"},
{ "blowfish-cbc", "bf-cbc" }, {"blowfish-cbc", "bf-cbc"},
{ "blowfish-ecb", "bf-ecb" }, {"blowfish-ecb", "bf-ecb"},
{ "blowfish-cfb", "bf-cfb" }, {"blowfish-cfb", "bf-cfb"},
{ "blowfish-ofb", "bf-ofb" }, {"blowfish-ofb", "bf-ofb"},
{ NULL } {NULL}
}; };
/* /*
@ -299,19 +320,44 @@ static PX_Alias ossl_mode_aliases [] = {
/* /*
* Special handlers * Special handlers
*/ */
struct { struct
{
char *name; char *name;
PX_Cipher cf; PX_Cipher cf;
} spec_types [] = { } 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-cbc",
{ "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}}, gen_evp_block_size, gen_evp_key_size, gen_evp_iv_size,
{ "bf-ofb", { gen_evp_block_size, gen_evp_key_size, gen_evp_iv_size, bf_init, bf_cbc_encrypt, bf_cbc_decrypt, gen_evp_free
bf_init, bf_ofb64_encrypt, bf_ofb64_decrypt, gen_evp_free}}, }
{ NULL } },
{
"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
}
}; };
/* /*
@ -333,7 +379,7 @@ static void o_free(void *p) { px_free(p); }
/* PUBLIC functions */ /* PUBLIC functions */
int int
px_find_digest(const char *name, PX_MD **res) px_find_digest(const char *name, PX_MD ** res)
{ {
const EVP_MD *md; const EVP_MD *md;
EVP_MD_CTX *ctx; EVP_MD_CTX *ctx;
@ -342,7 +388,7 @@ px_find_digest(const char *name, PX_MD **res)
if (!px_openssl_initialized) if (!px_openssl_initialized)
{ {
px_openssl_initialized = 1; px_openssl_initialized = 1;
/*CRYPTO_set_mem_functions(o_alloc, o_realloc, o_free);*/ /* CRYPTO_set_mem_functions(o_alloc, o_realloc, o_free); */
OpenSSL_add_all_algorithms(); OpenSSL_add_all_algorithms();
} }
@ -368,17 +414,19 @@ px_find_digest(const char *name, PX_MD **res)
int int
px_find_cipher(const char *name, PX_Cipher **res) px_find_cipher(const char *name, PX_Cipher ** res)
{ {
uint i; uint i;
PX_Cipher *c = NULL, *csrc; PX_Cipher *c = NULL,
*csrc;
ossldata *od; ossldata *od;
const EVP_CIPHER *evp_c; const EVP_CIPHER *evp_c;
if (!px_openssl_initialized) { if (!px_openssl_initialized)
{
px_openssl_initialized = 1; px_openssl_initialized = 1;
/*CRYPTO_set_mem_functions(o_alloc, o_realloc, o_free);*/ /* CRYPTO_set_mem_functions(o_alloc, o_realloc, o_free); */
OpenSSL_add_all_algorithms(); OpenSSL_add_all_algorithms();
} }
@ -394,7 +442,8 @@ px_find_cipher(const char *name, PX_Cipher **res)
csrc = NULL; csrc = NULL;
for (i = 0; spec_types[i].name; i++) 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; csrc = &spec_types[i].cf;
break; break;
} }
@ -409,4 +458,3 @@ px_find_cipher(const char *name, PX_Cipher **res)
*res = c; *res = c;
return 0; return 0;
} }

55
contrib/pgcrypto/pgcrypto.c
View File

@ -26,7 +26,7 @@
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE. * 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> #include <postgres.h>
@ -41,7 +41,7 @@
typedef int (*PFN) (const char *name, void **res); typedef int (*PFN) (const char *name, void **res);
static void * static void *
find_provider(text * name, PFN pf, char *desc, int silent); find_provider(text *name, PFN pf, char *desc, int silent);
/* SQL function: hash(text, text) returns text */ /* SQL function: hash(text, text) returns text */
PG_FUNCTION_INFO_V1(pg_digest); PG_FUNCTION_INFO_V1(pg_digest);
@ -314,16 +314,20 @@ Datum
pg_encrypt(PG_FUNCTION_ARGS) pg_encrypt(PG_FUNCTION_ARGS)
{ {
int err; int err;
bytea *data, *key, *res; bytea *data,
*key,
*res;
text *type; text *type;
PX_Combo *c; PX_Combo *c;
uint dlen, klen, rlen; uint dlen,
klen,
rlen;
if (PG_ARGISNULL(0) || PG_ARGISNULL(1) || PG_ARGISNULL(2)) if (PG_ARGISNULL(0) || PG_ARGISNULL(1) || PG_ARGISNULL(2))
PG_RETURN_NULL(); PG_RETURN_NULL();
type = PG_GETARG_TEXT_P(2); type = PG_GETARG_TEXT_P(2);
c = find_provider(type, (PFN)px_find_combo, "Cipher", 0); c = find_provider(type, (PFN) px_find_combo, "Cipher", 0);
data = PG_GETARG_BYTEA_P(0); data = PG_GETARG_BYTEA_P(0);
key = PG_GETARG_BYTEA_P(1); key = PG_GETARG_BYTEA_P(1);
@ -342,7 +346,8 @@ pg_encrypt(PG_FUNCTION_ARGS)
PG_FREE_IF_COPY(key, 1); PG_FREE_IF_COPY(key, 1);
PG_FREE_IF_COPY(type, 2); PG_FREE_IF_COPY(type, 2);
if (err) { if (err)
{
pfree(res); pfree(res);
elog(ERROR, "encrypt error: %d", err); elog(ERROR, "encrypt error: %d", err);
} }
@ -358,16 +363,20 @@ Datum
pg_decrypt(PG_FUNCTION_ARGS) pg_decrypt(PG_FUNCTION_ARGS)
{ {
int err; int err;
bytea *data, *key, *res; bytea *data,
*key,
*res;
text *type; text *type;
PX_Combo *c; PX_Combo *c;
uint dlen, klen, rlen; uint dlen,
klen,
rlen;
if (PG_ARGISNULL(0) || PG_ARGISNULL(1) || PG_ARGISNULL(2)) if (PG_ARGISNULL(0) || PG_ARGISNULL(1) || PG_ARGISNULL(2))
PG_RETURN_NULL(); PG_RETURN_NULL();
type = PG_GETARG_TEXT_P(2); type = PG_GETARG_TEXT_P(2);
c = find_provider(type, (PFN)px_find_combo, "Cipher", 0); c = find_provider(type, (PFN) px_find_combo, "Cipher", 0);
data = PG_GETARG_BYTEA_P(0); data = PG_GETARG_BYTEA_P(0);
key = PG_GETARG_BYTEA_P(1); key = PG_GETARG_BYTEA_P(1);
@ -402,17 +411,23 @@ Datum
pg_encrypt_iv(PG_FUNCTION_ARGS) pg_encrypt_iv(PG_FUNCTION_ARGS)
{ {
int err; int err;
bytea *data, *key, *iv, *res; bytea *data,
*key,
*iv,
*res;
text *type; text *type;
PX_Combo *c; PX_Combo *c;
uint dlen, klen, ivlen, rlen; uint dlen,
klen,
ivlen,
rlen;
if (PG_ARGISNULL(0) || PG_ARGISNULL(1) if (PG_ARGISNULL(0) || PG_ARGISNULL(1)
|| PG_ARGISNULL(2) || PG_ARGISNULL(3)) || PG_ARGISNULL(2) || PG_ARGISNULL(3))
PG_RETURN_NULL(); PG_RETURN_NULL();
type = PG_GETARG_TEXT_P(3); type = PG_GETARG_TEXT_P(3);
c = find_provider(type, (PFN)px_find_combo, "Cipher", 0); c = find_provider(type, (PFN) px_find_combo, "Cipher", 0);
data = PG_GETARG_BYTEA_P(0); data = PG_GETARG_BYTEA_P(0);
key = PG_GETARG_BYTEA_P(1); key = PG_GETARG_BYTEA_P(1);
@ -450,17 +465,23 @@ Datum
pg_decrypt_iv(PG_FUNCTION_ARGS) pg_decrypt_iv(PG_FUNCTION_ARGS)
{ {
int err; int err;
bytea *data, *key, *iv, *res; bytea *data,
*key,
*iv,
*res;
text *type; text *type;
PX_Combo *c; PX_Combo *c;
uint dlen, klen, rlen, ivlen; uint dlen,
klen,
rlen,
ivlen;
if (PG_ARGISNULL(0) || PG_ARGISNULL(1) if (PG_ARGISNULL(0) || PG_ARGISNULL(1)
|| PG_ARGISNULL(2) || PG_ARGISNULL(3)) || PG_ARGISNULL(2) || PG_ARGISNULL(3))
PG_RETURN_NULL(); PG_RETURN_NULL();
type = PG_GETARG_TEXT_P(3); type = PG_GETARG_TEXT_P(3);
c = find_provider(type, (PFN)px_find_combo, "Cipher", 0); c = find_provider(type, (PFN) px_find_combo, "Cipher", 0);
data = PG_GETARG_BYTEA_P(0); data = PG_GETARG_BYTEA_P(0);
key = PG_GETARG_BYTEA_P(1); key = PG_GETARG_BYTEA_P(1);
@ -505,7 +526,7 @@ pg_cipher_exists(PG_FUNCTION_ARGS)
arg = PG_GETARG_TEXT_P(0); arg = PG_GETARG_TEXT_P(0);
c = find_provider(arg, (PFN)px_find_combo, "Cipher", 1); c = find_provider(arg, (PFN) px_find_combo, "Cipher", 1);
if (c != NULL) if (c != NULL)
px_combo_free(c); px_combo_free(c);
@ -514,7 +535,7 @@ pg_cipher_exists(PG_FUNCTION_ARGS)
static void * static void *
find_provider(text * name, find_provider(text *name,
PFN provider_lookup, PFN provider_lookup,
char *desc, int silent) char *desc, int silent)
{ {

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 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE. * 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 #ifndef _PG_CRYPTO_H
@ -45,6 +45,4 @@ Datum pg_decrypt(PG_FUNCTION_ARGS);
Datum pg_encrypt_iv(PG_FUNCTION_ARGS); Datum pg_encrypt_iv(PG_FUNCTION_ARGS);
Datum pg_decrypt_iv(PG_FUNCTION_ARGS); Datum pg_decrypt_iv(PG_FUNCTION_ARGS);
Datum pg_cipher_exists(PG_FUNCTION_ARGS); Datum pg_cipher_exists(PG_FUNCTION_ARGS);
#endif #endif

55
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 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE. * 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> #include <postgres.h>
@ -54,6 +54,7 @@ run_crypt_md5(const char *psw, const char *salt,
char *buf, unsigned len) char *buf, unsigned len)
{ {
char *res; char *res;
res = px_crypt_md5(psw, salt, buf, len); res = px_crypt_md5(psw, salt, buf, len);
return res; return res;
} }
@ -63,6 +64,7 @@ run_crypt_bf(const char *psw, const char *salt,
char *buf, unsigned len) char *buf, unsigned len)
{ {
char *res; char *res;
res = _crypt_blowfish_rn(psw, salt, buf, len); res = _crypt_blowfish_rn(psw, salt, buf, len);
return res; return res;
} }
@ -76,12 +78,24 @@ static struct
} px_crypt_list[] = } px_crypt_list[] =
{ {
{ "$2a$", 4, run_crypt_bf }, {
{ "$2$", 3, NULL }, /* N/A */ "$2a$", 4, run_crypt_bf
{ "$1$", 3, run_crypt_md5 }, },
{ "_", 1, run_crypt_des }, {
{ "", 0, run_crypt_des }, "$2$", 3, NULL
{ NULL, 0, NULL } }, /* N/A */
{
"$1$", 3, run_crypt_md5
},
{
"_", 1, run_crypt_des
},
{
"", 0, run_crypt_des
},
{
NULL, 0, NULL
}
}; };
char * char *
@ -125,9 +139,10 @@ px_crypt(const char *psw, const char *salt,
* salt generators * salt generators
*/ */
struct generator { struct generator
{
char *name; char *name;
char *(*gen)(unsigned long count, const char *input, int size, char *(*gen) (unsigned long count, const char *input, int size,
char *output, int output_size); char *output, int output_size);
int input_len; int input_len;
int def_rounds; int def_rounds;
@ -135,28 +150,31 @@ struct generator {
int max_rounds; int max_rounds;
}; };
static struct generator gen_list [] = { static struct generator gen_list[] = {
{ "des", _crypt_gensalt_traditional_rn, 2, 0, 0, 0 }, {"des", _crypt_gensalt_traditional_rn, 2, 0, 0, 0},
{ "md5", _crypt_gensalt_md5_rn, 6, 0, 0, 0 }, {"md5", _crypt_gensalt_md5_rn, 6, 0, 0, 0},
{ "xdes", _crypt_gensalt_extended_rn, 3, PX_XDES_ROUNDS, 1, 0xFFFFFF }, {"xdes", _crypt_gensalt_extended_rn, 3, PX_XDES_ROUNDS, 1, 0xFFFFFF},
{ "bf", _crypt_gensalt_blowfish_rn, 16, PX_BF_ROUNDS, 4, 31 }, {"bf", _crypt_gensalt_blowfish_rn, 16, PX_BF_ROUNDS, 4, 31},
{ NULL, NULL, 0, 0, 0 } {NULL, NULL, 0, 0, 0}
}; };
uint uint
px_gen_salt(const char *salt_type, char *buf, int rounds) px_gen_salt(const char *salt_type, char *buf, int rounds)
{ {
int i, res; int i,
res;
struct generator *g; struct generator *g;
char *p; char *p;
char rbuf[16]; char rbuf[16];
for (i = 0; gen_list[i].name; i++) { for (i = 0; gen_list[i].name; i++)
{
g = &gen_list[i]; g = &gen_list[i];
if (strcasecmp(g->name, salt_type) != 0) if (strcasecmp(g->name, salt_type) != 0)
continue; continue;
if (g->def_rounds) { if (g->def_rounds)
{
if (rounds == 0) if (rounds == 0)
rounds = g->def_rounds; rounds = g->def_rounds;
@ -176,4 +194,3 @@ px_gen_salt(const char *salt_type, char *buf, int rounds)
return 0; 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 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE. * 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 #ifndef _PX_CRYPT_H
@ -58,6 +58,7 @@ unsigned px_gen_salt(const char *salt_type, char *dst, int rounds);
/* misc.c */ /* misc.c */
extern void px_crypt_to64(char *s, unsigned long v, int n); extern void px_crypt_to64(char *s, unsigned long v, int n);
extern char px_crypt_a64[]; extern char px_crypt_a64[];
/* avoid conflicts with system libs */ /* avoid conflicts with system libs */
#define _crypt_to64 px_crypt_to64 #define _crypt_to64 px_crypt_to64
#define _crypt_a64 px_crypt_a64 #define _crypt_a64 px_crypt_a64
@ -87,6 +88,5 @@ char *px_crypt_des(const char *key, const char *setting);
/* crypt-md5.c */ /* crypt-md5.c */
char *px_crypt_md5(const char *pw, const char *salt, char *px_crypt_md5(const char *pw, const char *salt,
char *dst, unsigned dstlen); char *dst, unsigned dstlen);
#endif /* !PX_SYSTEM_CRYPT */ #endif /* !PX_SYSTEM_CRYPT */
#endif /* _PX_CRYPT_H */ #endif /* _PX_CRYPT_H */

8
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 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE. * 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 $
*/ */
@ -50,7 +50,7 @@ hmac_block_size(PX_HMAC * h)
} }
static void static void
hmac_init(PX_HMAC * h, const uint8 * key, uint klen) hmac_init(PX_HMAC * h, const uint8 *key, uint klen)
{ {
uint bs, uint bs,
hlen, hlen,
@ -95,13 +95,13 @@ hmac_reset(PX_HMAC * h)
} }
static void static void
hmac_update(PX_HMAC * h, const uint8 * data, uint dlen) hmac_update(PX_HMAC * h, const uint8 *data, uint dlen)
{ {
px_md_update(h->md, data, dlen); px_md_update(h->md, data, dlen);
} }
static void static void
hmac_finish(PX_HMAC * h, uint8 * dst) hmac_finish(PX_HMAC * h, uint8 *dst)
{ {
PX_MD *md = h->md; PX_MD *md = h->md;
uint bs, uint bs,

104
contrib/pgcrypto/px.c
View File

@ -26,7 +26,7 @@
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE. * 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> #include <postgres.h>
@ -35,9 +35,10 @@
const char * const char *
px_resolve_alias(const PX_Alias *list, const char *name) px_resolve_alias(const PX_Alias * list, const char *name)
{ {
while (list->name) { while (list->name)
{
if (!strcasecmp(list->alias, name)) if (!strcasecmp(list->alias, name))
return list->name; return list->name;
list++; list++;
@ -50,23 +51,25 @@ px_resolve_alias(const PX_Alias *list, const char *name)
*/ */
static uint static uint
combo_encrypt_len(PX_Combo *cx, uint dlen) combo_encrypt_len(PX_Combo * cx, uint dlen)
{ {
return dlen + 512; return dlen + 512;
} }
static uint static uint
combo_decrypt_len(PX_Combo *cx, uint dlen) combo_decrypt_len(PX_Combo * cx, uint dlen)
{ {
return dlen; return dlen;
} }
static int static int
combo_init(PX_Combo *cx, const uint8 *key, uint klen, combo_init(PX_Combo * cx, const uint8 *key, uint klen,
const uint8 *iv, uint ivlen) const uint8 *iv, uint ivlen)
{ {
int err; int err;
uint bs, ks, ivs; uint bs,
ks,
ivs;
PX_Cipher *c = cx->cipher; PX_Cipher *c = cx->cipher;
uint8 *ivbuf = NULL; uint8 *ivbuf = NULL;
uint8 *keybuf; uint8 *keybuf;
@ -75,7 +78,8 @@ combo_init(PX_Combo *cx, const uint8 *key, uint klen,
ks = px_cipher_key_size(c); ks = px_cipher_key_size(c);
ivs = px_cipher_iv_size(c); ivs = px_cipher_iv_size(c);
if (ivs > 0) { if (ivs > 0)
{
ivbuf = px_alloc(ivs); ivbuf = px_alloc(ivs);
memset(ivbuf, 0, ivs); memset(ivbuf, 0, ivs);
if (ivlen > ivs) if (ivlen > ivs)
@ -97,12 +101,16 @@ combo_init(PX_Combo *cx, const uint8 *key, uint klen,
} }
static int static int
combo_encrypt(PX_Combo *cx, const uint8 *data, uint dlen, combo_encrypt(PX_Combo * cx, const uint8 *data, uint dlen,
uint8 *res, uint *rlen) uint8 *res, uint *rlen)
{ {
int err = 0; int err = 0;
uint8 *bbuf; uint8 *bbuf;
uint bs, maxlen, bpos, i, pad; uint bs,
maxlen,
bpos,
i,
pad;
PX_Cipher *c = cx->cipher; 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); bs = px_cipher_block_size(c);
/* encrypt */ /* encrypt */
if (bs > 1) { if (bs > 1)
{
bbuf = px_alloc(bs * 4); bbuf = px_alloc(bs * 4);
bpos = dlen % bs; bpos = dlen % bs;
*rlen = dlen - bpos; *rlen = dlen - bpos;
memcpy(bbuf, data + *rlen, bpos); memcpy(bbuf, data + *rlen, bpos);
/* encrypt full-block data */ /* encrypt full-block data */
if (*rlen) { if (*rlen)
{
err = px_cipher_encrypt(c, data, *rlen, res); err = px_cipher_encrypt(c, data, *rlen, res);
if (err) if (err)
goto out; goto out;
} }
/* bbuf has now bpos bytes of stuff */ /* bbuf has now bpos bytes of stuff */
if (cx->padding) { if (cx->padding)
{
pad = bs - (bpos % bs); pad = bs - (bpos % bs);
for (i = 0; i < pad; i++) for (i = 0; i < pad; i++)
bbuf[bpos++] = pad; bbuf[bpos++] = pad;
} else if (bpos % bs) { }
else if (bpos % bs)
{
/* ERROR? */ /* ERROR? */
pad = bs - (bpos % bs); pad = bs - (bpos % bs);
for (i = 0; i < pad; i++) for (i = 0; i < pad; i++)
@ -137,11 +150,14 @@ combo_encrypt(PX_Combo *cx, const uint8 *data, uint dlen,
} }
/* encrypt the rest - pad */ /* encrypt the rest - pad */
if (bpos) { if (bpos)
{
err = px_cipher_encrypt(c, bbuf, bpos, res + *rlen); err = px_cipher_encrypt(c, bbuf, bpos, res + *rlen);
*rlen += bpos; *rlen += bpos;
} }
} else { }
else
{
/* stream cipher/mode - no pad needed */ /* stream cipher/mode - no pad needed */
err = px_cipher_encrypt(c, data, dlen, res); err = px_cipher_encrypt(c, data, dlen, res);
if (err) if (err)
@ -149,37 +165,42 @@ combo_encrypt(PX_Combo *cx, const uint8 *data, uint dlen,
*rlen = dlen; *rlen = dlen;
} }
out: out:
if (bbuf) px_free(bbuf); if (bbuf)
px_free(bbuf);
return err; return err;
} }
static int static int
combo_decrypt(PX_Combo *cx, const uint8 *data, uint dlen, combo_decrypt(PX_Combo * cx, const uint8 *data, uint dlen,
uint8 *res, uint *rlen) uint8 *res, uint *rlen)
{ {
uint bs, i, pad; uint bs,
i,
pad;
uint pad_ok; uint pad_ok;
PX_Cipher *c = cx->cipher; PX_Cipher *c = cx->cipher;
bs = px_cipher_block_size(c); bs = px_cipher_block_size(c);
if (bs > 1 && (dlen % bs) != 0) { if (bs > 1 && (dlen % bs) != 0)
goto block_error; goto block_error;
}
/* decrypt */ /* decrypt */
*rlen = dlen; *rlen = dlen;
px_cipher_decrypt(c, data, dlen, res); px_cipher_decrypt(c, data, dlen, res);
/* unpad */ /* unpad */
if (bs > 1 && cx->padding) { if (bs > 1 && cx->padding)
{
pad = res[*rlen - 1]; pad = res[*rlen - 1];
pad_ok = 0; pad_ok = 0;
if (pad > 0 && pad <= bs && pad <= *rlen) { if (pad > 0 && pad <= bs && pad <= *rlen)
{
pad_ok = 1; pad_ok = 1;
for (i = *rlen - pad; i < *rlen; i++) for (i = *rlen - pad; i < *rlen; i++)
if (res[i] != pad) { if (res[i] != pad)
{
pad_ok = 0; pad_ok = 0;
break; break;
} }
@ -198,7 +219,7 @@ block_error:
} }
static void static void
combo_free(PX_Combo *cx) combo_free(PX_Combo * cx)
{ {
if (cx->cipher) if (cx->cipher)
px_cipher_free(cx->cipher); px_cipher_free(cx->cipher);
@ -211,29 +232,36 @@ combo_free(PX_Combo *cx)
static int static int
parse_cipher_name(char *full, char **cipher, char **pad) parse_cipher_name(char *full, char **cipher, char **pad)
{ {
char *p, *p2, *q; char *p,
*p2,
*q;
*cipher = full; *cipher = full;
*pad = NULL; *pad = NULL;
p = strchr(full, '/'); p = strchr(full, '/');
if (p != NULL) if (p != NULL)
*p++ = 0; *p++ = 0;
while (p != NULL) { while (p != NULL)
{
if ((q = strchr(p, '/')) != NULL) if ((q = strchr(p, '/')) != NULL)
*q++ = 0; *q++ = 0;
if (!*p) { if (!*p)
{
p = q; p = q;
continue; continue;
} }
p2 = strchr(p, ':'); p2 = strchr(p, ':');
if (p2 != NULL) { if (p2 != NULL)
{
*p2++ = 0; *p2++ = 0;
if (!strcmp(p, "pad")) if (!strcmp(p, "pad"))
*pad = p2; *pad = p2;
else else
return -1; return -1;
} else }
else
return -1; return -1;
p = q; p = q;
@ -244,10 +272,12 @@ parse_cipher_name(char *full, char **cipher, char **pad)
/* provider */ /* provider */
int int
px_find_combo(const char *name, PX_Combo **res) px_find_combo(const char *name, PX_Combo ** res)
{ {
int err; int err;
char *buf, *s_cipher, *s_pad; char *buf,
*s_cipher,
*s_pad;
PX_Combo *cx; PX_Combo *cx;
@ -258,7 +288,8 @@ px_find_combo(const char *name, PX_Combo **res)
strcpy(buf, name); strcpy(buf, name);
err = parse_cipher_name(buf, &s_cipher, &s_pad); err = parse_cipher_name(buf, &s_cipher, &s_pad);
if (err) { if (err)
{
px_free(buf); px_free(buf);
px_free(cx); px_free(cx);
return err; return err;
@ -268,14 +299,16 @@ px_find_combo(const char *name, PX_Combo **res)
if (err) if (err)
goto err1; goto err1;
if (s_pad != NULL) { if (s_pad != NULL)
{
if (!strcmp(s_pad, "pkcs")) if (!strcmp(s_pad, "pkcs"))
cx->padding = 1; cx->padding = 1;
else if (!strcmp(s_pad, "none")) else if (!strcmp(s_pad, "none"))
cx->padding = 0; cx->padding = 0;
else else
goto err1; goto err1;
} else }
else
cx->padding = 1; cx->padding = 1;
cx->init = combo_init; cx->init = combo_init;
@ -298,4 +331,3 @@ err1:
px_free(buf); px_free(buf);
return -1; return -1;
} }

88
contrib/pgcrypto/px.h
View File

@ -26,7 +26,7 @@
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE. * 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 #ifndef __PX_H
@ -47,7 +47,6 @@ void xfree(void *p);
#define px_alloc(s) xalloc(s) #define px_alloc(s) xalloc(s)
#define px_realloc(p, s) xrealloc(p, s) #define px_realloc(p, s) xrealloc(p, s)
#define px_free(p) xfree(p) #define px_free(p) xfree(p)
#endif #endif
/* max len of 'type' parms */ /* max len of 'type' parms */
@ -63,79 +62,86 @@ typedef struct px_hmac PX_HMAC;
typedef struct px_cipher PX_Cipher; typedef struct px_cipher PX_Cipher;
typedef struct px_combo PX_Combo; typedef struct px_combo PX_Combo;
struct px_digest { struct px_digest
uint (*result_size)(PX_MD *h); {
uint (*block_size)(PX_MD *h); uint (*result_size) (PX_MD * h);
void (*reset)(PX_MD *h); uint (*block_size) (PX_MD * h);
void (*update)(PX_MD *h, const uint8 *data, uint dlen); void (*reset) (PX_MD * h);
void (*finish)(PX_MD *h, uint8 *dst); void (*update) (PX_MD * h, const uint8 *data, uint dlen);
void (*free)(PX_MD *h); void (*finish) (PX_MD * h, uint8 *dst);
void (*free) (PX_MD * h);
/* private */ /* private */
union { union
{
uint code; uint code;
const void *ptr; const void *ptr;
} p; } p;
}; };
struct px_alias { struct px_alias
{
char *alias; char *alias;
char *name; char *name;
}; };
struct px_hmac { struct px_hmac
uint (*result_size)(PX_HMAC *h); {
uint (*block_size)(PX_HMAC *h); uint (*result_size) (PX_HMAC * h);
void (*reset)(PX_HMAC *h); uint (*block_size) (PX_HMAC * h);
void (*update)(PX_HMAC *h, const uint8 *data, uint dlen); void (*reset) (PX_HMAC * h);
void (*finish)(PX_HMAC *h, uint8 *dst); void (*update) (PX_HMAC * h, const uint8 *data, uint dlen);
void (*free)(PX_HMAC *h); void (*finish) (PX_HMAC * h, uint8 *dst);
void (*init)(PX_HMAC *h, const uint8 *key, uint klen); void (*free) (PX_HMAC * h);
void (*init) (PX_HMAC * h, const uint8 *key, uint klen);
PX_MD *md; PX_MD *md;
/* private */ /* private */
struct { struct
{
uint8 *ipad; uint8 *ipad;
uint8 *opad; uint8 *opad;
} p; } p;
}; };
struct px_cipher { struct px_cipher
uint (*block_size)(PX_Cipher *c); {
uint (*key_size)(PX_Cipher *c); /* max key len */ uint (*block_size) (PX_Cipher * c);
uint (*iv_size)(PX_Cipher *c); uint (*key_size) (PX_Cipher * c); /* max key len */
uint (*iv_size) (PX_Cipher * c);
int (*init)(PX_Cipher *c, const uint8 *key, uint klen, const uint8 *iv); int (*init) (PX_Cipher * c, const uint8 *key, uint klen, const uint8 *iv);
int (*encrypt)(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res); int (*encrypt) (PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res);
int (*decrypt)(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res); int (*decrypt) (PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res);
void (*free)(PX_Cipher *c); void (*free) (PX_Cipher * c);
/* private */ /* private */
void *ptr; void *ptr;
int pstat; /* mcrypt uses it */ int pstat; /* mcrypt uses it */
}; };
struct px_combo { struct px_combo
int (*init)(PX_Combo *cx, const uint8 *key, uint klen, {
int (*init) (PX_Combo * cx, const uint8 *key, uint klen,
const uint8 *iv, uint ivlen); const uint8 *iv, uint ivlen);
int (*encrypt)(PX_Combo *cx, const uint8 *data, uint dlen, int (*encrypt) (PX_Combo * cx, const uint8 *data, uint dlen,
uint8 *res, uint *rlen); uint8 *res, uint *rlen);
int (*decrypt)(PX_Combo *cx, const uint8 *data, uint dlen, int (*decrypt) (PX_Combo * cx, const uint8 *data, uint dlen,
uint8 *res, uint *rlen); uint8 *res, uint *rlen);
uint (*encrypt_len)(PX_Combo *cx, uint dlen); uint (*encrypt_len) (PX_Combo * cx, uint dlen);
uint (*decrypt_len)(PX_Combo *cx, uint dlen); uint (*decrypt_len) (PX_Combo * cx, uint dlen);
void (*free)(PX_Combo *cx); void (*free) (PX_Combo * cx);
PX_Cipher *cipher; PX_Cipher *cipher;
uint padding; uint padding;
}; };
int px_find_digest(const char *name, PX_MD **res); int px_find_digest(const char *name, PX_MD ** res);
int px_find_hmac(const char *name, PX_HMAC **res); int px_find_hmac(const char *name, PX_HMAC ** res);
int px_find_cipher(const char *name, PX_Cipher **res); int px_find_cipher(const char *name, PX_Cipher ** res);
int px_find_combo(const char *name, PX_Combo **res); int px_find_combo(const char *name, PX_Combo ** res);
int px_get_random_bytes(uint8 *dst, unsigned count); int px_get_random_bytes(uint8 *dst, unsigned count);
const char *px_resolve_alias(const PX_Alias *aliases, const char *name); const char *px_resolve_alias(const PX_Alias * aliases, const char *name);
#define px_md_result_size(md) (md)->result_size(md) #define px_md_result_size(md) (md)->result_size(md)
#define px_md_block_size(md) (md)->block_size(md) #define px_md_block_size(md) (md)->block_size(md)
@ -174,6 +180,4 @@ const char *px_resolve_alias(const PX_Alias *aliases, const char *name);
(c)->decrypt(c, data, dlen, res, rlen) (c)->decrypt(c, data, dlen, res, rlen)
#define px_combo_free(c) (c)->free(c) #define px_combo_free(c) (c)->free(c)
#endif /* __PX_H */ #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 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE. * 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; char *p = buf;
int res; int res;
while (count) { while (count)
{
res = read(fd, p, count); res = read(fd, p, count);
if (res <= 0) { if (res <= 0)
{
if (errno == EINTR) if (errno == EINTR)
continue; continue;
return -1; return -1;
@ -75,20 +77,19 @@ px_get_random_bytes(uint8 *dst, unsigned count)
close(fd); close(fd);
return res; return res;
} }
#endif /* RAND_DEV */ #endif /* RAND_DEV */
#ifdef RAND_SILLY #ifdef RAND_SILLY
int px_get_random_bytes(uint8 *dst, unsigned count) int
px_get_random_bytes(uint8 *dst, unsigned count)
{ {
int i; int i;
for (i = 0; i < count; i++) {
for (i = 0; i < count; i++)
*dst++ = random(); *dst++ = random();
}
return i; return i;
} }
#endif /* RAND_SILLY */ #endif /* RAND_SILLY */
#ifdef RAND_OPENSSL #ifdef RAND_OPENSSL
@ -100,20 +101,21 @@ int px_get_random_bytes(uint8 *dst, unsigned count)
static int openssl_random_init = 0; 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; int res;
if (!openssl_random_init) { if (!openssl_random_init)
if (RAND_get_rand_method() == NULL) { {
if (RAND_get_rand_method() == NULL)
RAND_set_rand_method(RAND_SSLeay()); RAND_set_rand_method(RAND_SSLeay());
}
openssl_random_init = 1; openssl_random_init = 1;
} }
/* /*
* OpenSSL random should re-feeded occasionally. * OpenSSL random should re-feeded occasionally. From /dev/urandom
* From /dev/urandom preferrably. * preferrably.
*/ */
res = RAND_bytes(dst, count); res = RAND_bytes(dst, count);
@ -122,6 +124,4 @@ int px_get_random_bytes(uint8 *dst, unsigned count)
return -1; return -1;
} }
#endif /* RAND_OPENSSL */ #endif /* RAND_OPENSSL */

301
contrib/pgcrypto/rijndael.c
View File

@ -87,7 +87,7 @@ static u1byte pow_tab[256];
static u1byte log_tab[256]; static u1byte log_tab[256];
static u1byte sbx_tab[256]; static u1byte sbx_tab[256];
static u1byte isb_tab[256]; static u1byte isb_tab[256];
static u4byte rco_tab[ 10]; static u4byte rco_tab[10];
static u4byte ft_tab[4][256]; static u4byte ft_tab[4][256];
static u4byte it_tab[4][256]; static u4byte it_tab[4][256];
@ -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 + 3) & 3],1)]), 8) ^ \
rotl(((u4byte)isb_tab[byte(bi[(n + 2) & 3],2)]), 16) ^ \ rotl(((u4byte)isb_tab[byte(bi[(n + 2) & 3],2)]), 16) ^ \
rotl(((u4byte)isb_tab[byte(bi[(n + 1) & 3],3)]), 24) ^ *(k + n) rotl(((u4byte)isb_tab[byte(bi[(n + 1) & 3],3)]), 24) ^ *(k + n)
#endif #endif
static void static void
gen_tabs(void) gen_tabs(void)
{ {
#ifndef PRE_CALC_TABLES #ifndef PRE_CALC_TABLES
u4byte i, t; u4byte i,
u1byte p, q; t;
u1byte p,
q;
/* log and power tables for GF(2**8) finite field with */ /* log and power tables for GF(2**8) finite field with */
/* 0x11b as modular polynomial - the simplest prmitive */ /* 0x11b as modular polynomial - the simplest prmitive */
/* root is 0x11, used here to generate the tables */ /* root is 0x11, used here to generate the tables */
for(i = 0,p = 1; i < 256; ++i) { for (i = 0, p = 1; i < 256; ++i)
pow_tab[i] = (u1byte)p; log_tab[p] = (u1byte)i; {
pow_tab[i] = (u1byte) p;
log_tab[p] = (u1byte) i;
p = p ^ (p << 1) ^ (p & 0x80 ? 0x01b : 0); 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; rco_tab[i] = p;
p = (p << 1) ^ (p & 0x80 ? 0x1b : 0); p = (p << 1) ^ (p & 0x80 ? 0x1b : 0);
@ -186,29 +191,38 @@ gen_tabs(void)
/* of the specification the bits are numbered from the */ /* of the specification the bits are numbered from the */
/* least significant end of a byte. */ /* least significant end of a byte. */
for(i = 0; i < 256; ++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; p = (i ? pow_tab[255 - log_tab[i]] : 0);
q = (q >> 7) | (q << 1); p ^= q; q = p;
q = (q >> 7) | (q << 1); p ^= q; q = (q >> 7) | (q << 1);
q = (q >> 7) | (q << 1); p ^= q ^ 0x63; p ^= q;
sbx_tab[i] = (u1byte)p; isb_tab[p] = (u1byte)i; 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]; p = sbx_tab[i];
#ifdef LARGE_TABLES #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[1][i] = rotl(t, 8);
fl_tab[2][i] = rotl(t, 16); fl_tab[2][i] = rotl(t, 16);
fl_tab[3][i] = rotl(t, 24); fl_tab[3][i] = rotl(t, 24);
#endif #endif
t = ((u4byte)ff_mult(2, p)) | t = ((u4byte) ff_mult(2, p)) |
((u4byte)p << 8) | ((u4byte) p << 8) |
((u4byte)p << 16) | ((u4byte) p << 16) |
((u4byte)ff_mult(3, p) << 24); ((u4byte) ff_mult(3, p) << 24);
ft_tab[0][i] = t; ft_tab[0][i] = t;
ft_tab[1][i] = rotl(t, 8); ft_tab[1][i] = rotl(t, 8);
@ -219,15 +233,16 @@ gen_tabs(void)
#ifdef LARGE_TABLES #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[1][i] = rotl(t, 8);
il_tab[2][i] = rotl(t, 16); il_tab[2][i] = rotl(t, 16);
il_tab[3][i] = rotl(t, 24); il_tab[3][i] = rotl(t, 24);
#endif #endif
t = ((u4byte)ff_mult(14, p)) | t = ((u4byte) ff_mult(14, p)) |
((u4byte)ff_mult( 9, p) << 8) | ((u4byte) ff_mult(9, p) << 8) |
((u4byte)ff_mult(13, p) << 16) | ((u4byte) ff_mult(13, p) << 16) |
((u4byte)ff_mult(11, p) << 24); ((u4byte) ff_mult(11, p) << 24);
it_tab[0][i] = t; it_tab[0][i] = t;
it_tab[1][i] = rotl(t, 8); it_tab[1][i] = rotl(t, 8);
@ -286,49 +301,64 @@ do { t = ls_box(rotr(t, 8)) ^ rco_tab[i]; \
} while (0) } while (0)
rijndael_ctx * rijndael_ctx *
rijndael_set_key(rijndael_ctx *ctx, const u4byte *in_key, const u4byte key_len, rijndael_set_key(rijndael_ctx * ctx, const u4byte * in_key, const u4byte key_len,
int encrypt) int encrypt)
{ {
u4byte i, t, u, v, w; u4byte i,
t,
u,
v,
w;
u4byte *e_key = ctx->e_key; u4byte *e_key = ctx->e_key;
u4byte *d_key = ctx->d_key; u4byte *d_key = ctx->d_key;
ctx->decrypt = !encrypt; ctx->decrypt = !encrypt;
if(!tab_gen) if (!tab_gen)
gen_tabs(); gen_tabs();
ctx->k_len = (key_len + 31) / 32; 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[0] = io_swap(in_key[0]);
e_key[2] = io_swap(in_key[2]); e_key[3] = io_swap(in_key[3]); 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) { switch (ctx->k_len)
case 4: t = e_key[3]; {
for(i = 0; i < 10; ++i) case 4:
t = e_key[3];
for (i = 0; i < 10; ++i)
loop4(i); loop4(i);
break; break;
case 6: e_key[4] = io_swap(in_key[4]); t = e_key[5] = io_swap(in_key[5]); case 6:
for(i = 0; i < 8; ++i) 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); loop6(i);
break; break;
case 8: e_key[4] = io_swap(in_key[4]); e_key[5] = io_swap(in_key[5]); case 8:
e_key[6] = io_swap(in_key[6]); t = e_key[7] = io_swap(in_key[7]); e_key[4] = io_swap(in_key[4]);
for(i = 0; i < 7; ++i) 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); loop8(i);
break; break;
} }
if (!encrypt) { 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]; 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]); imix_col(d_key[i], e_key[i]);
} }
}
return ctx; return ctx;
} }
@ -349,11 +379,13 @@ rijndael_set_key(rijndael_ctx *ctx, const u4byte *in_key, const u4byte key_len,
f_rl(bo, bi, 3, k) f_rl(bo, bi, 3, k)
void void
rijndael_encrypt(rijndael_ctx *ctx, const u4byte *in_blk, u4byte *out_blk) rijndael_encrypt(rijndael_ctx * ctx, const u4byte * in_blk, u4byte * out_blk)
{ {
u4byte k_len = ctx->k_len; u4byte k_len = ctx->k_len;
u4byte *e_key = ctx->e_key; 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[0] = io_swap(in_blk[0]) ^ e_key[0];
b0[1] = io_swap(in_blk[1]) ^ e_key[1]; 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; kp = e_key + 4;
if(k_len > 6) { if (k_len > 6)
f_nround(b1, b0, kp); f_nround(b0, b1, kp); {
f_nround(b1, b0, kp);
f_nround(b0, b1, kp);
} }
if(k_len > 4) { 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(b1, b0, kp); f_nround(b0, b1, kp); f_nround(b0, b1, kp);
f_nround(b1, b0, kp); f_nround(b0, b1, kp); f_nround(b1, b0, kp);
f_nround(b1, b0, kp); f_nround(b0, b1, 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_lround(b0, b1, kp);
out_blk[0] = io_swap(b0[0]); out_blk[1] = io_swap(b0[1]); out_blk[0] = io_swap(b0[0]);
out_blk[2] = io_swap(b0[2]); out_blk[3] = io_swap(b0[3]); 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 */ /* decrypt a block of text */
@ -396,9 +439,11 @@ rijndael_encrypt(rijndael_ctx *ctx, const u4byte *in_blk, u4byte *out_blk)
i_rl(bo, bi, 3, k) i_rl(bo, bi, 3, k)
void void
rijndael_decrypt(rijndael_ctx *ctx, const u4byte *in_blk, u4byte *out_blk) 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 k_len = ctx->k_len;
u4byte *e_key = ctx->e_key; u4byte *e_key = ctx->e_key;
u4byte *d_key = ctx->d_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); kp = d_key + 4 * (k_len + 5);
if(k_len > 6) { if (k_len > 6)
i_nround(b1, b0, kp); i_nround(b0, b1, kp); {
i_nround(b1, b0, kp);
i_nround(b0, b1, kp);
} }
if(k_len > 4) { 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(b1, b0, kp); i_nround(b0, b1, kp); i_nround(b0, b1, kp);
i_nround(b1, b0, kp); i_nround(b0, b1, kp); i_nround(b1, b0, kp);
i_nround(b1, b0, kp); i_nround(b0, b1, 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_lround(b0, b1, kp);
out_blk[0] = io_swap(b0[0]); out_blk[1] = io_swap(b0[1]); out_blk[0] = io_swap(b0[0]);
out_blk[2] = io_swap(b0[2]); out_blk[3] = io_swap(b0[3]); out_blk[1] = io_swap(b0[1]);
out_blk[2] = io_swap(b0[2]);
out_blk[3] = io_swap(b0[3]);
} }
/* /*
@ -435,19 +491,24 @@ rijndael_decrypt(rijndael_ctx *ctx, const u4byte *in_blk, u4byte *out_blk)
* should be true for PX. -marko * 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; uint32 *k;
k = (uint32*)key;
k = (uint32 *) key;
rijndael_set_key(ctx, k, keybits, enc); 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; unsigned bs = 16;
uint32 *d; uint32 *d;
while (len >= bs) {
d = (uint32*)data; while (len >= bs)
{
d = (uint32 *) data;
rijndael_encrypt(ctx, d, d); rijndael_encrypt(ctx, d, d);
len -= bs; len -= bs;
@ -455,12 +516,15 @@ 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; unsigned bs = 16;
uint32 *d; uint32 *d;
while (len >= bs) {
d = (uint32*)data; while (len >= bs)
{
d = (uint32 *) data;
rijndael_decrypt(ctx, d, d); rijndael_decrypt(ctx, d, d);
len -= bs; len -= bs;
@ -468,42 +532,55 @@ 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 *iv = (uint32 *) iva;
uint32 *d = (uint32 *)data; uint32 *d = (uint32 *) data;
unsigned bs = 16; unsigned bs = 16;
while (len >= bs) { while (len >= bs)
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];
rijndael_encrypt(ctx, d, d); rijndael_encrypt(ctx, d, d);
iv = d; iv = d;
d += bs/4; d += bs / 4;
len -= bs; len -= bs;
} }
} }
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; uint32 *d = (uint32 *) data;
unsigned bs = 16; unsigned bs = 16;
uint32 buf[4], iv[4]; uint32 buf[4],
iv[4];
memcpy(iv, iva, bs); memcpy(iv, iva, bs);
while (len >= bs) { while (len >= bs)
buf[0] = d[0]; buf[1] = d[1]; {
buf[2] = d[2]; buf[3] = d[3]; buf[0] = d[0];
buf[1] = d[1];
buf[2] = d[2];
buf[3] = d[3];
rijndael_decrypt(ctx, buf, d); rijndael_decrypt(ctx, buf, d);
d[0] ^= iv[0]; d[1] ^= iv[1]; d[0] ^= iv[0];
d[2] ^= iv[2]; d[3] ^= iv[3]; d[1] ^= iv[1];
d[2] ^= iv[2];
d[3] ^= iv[3];
iv[0] = buf[0]; iv[1] = buf[1]; iv[0] = buf[0];
iv[2] = buf[2]; iv[3] = buf[3]; iv[1] = buf[1];
iv[2] = buf[2];
iv[3] = buf[3];
d += 4; d += 4;
len -= bs; len -= bs;
} }
@ -518,11 +595,14 @@ void aes_cbc_decrypt(rijndael_ctx *ctx, uint8 *iva, uint8 *data, unsigned len)
*/ */
#ifdef PRINT_TABS #ifdef PRINT_TABS
static void show256u8(char *name, uint8 *data) static void
show256u8(char *name, uint8 *data)
{ {
int i; int i;
printf("static const u1byte %s[256] = {\n ", name); printf("static const u1byte %s[256] = {\n ", name);
for (i = 0; i < 256; ) { for (i = 0; i < 256;)
{
printf("%u", pow_tab[i++]); printf("%u", pow_tab[i++]);
if (i < 256) if (i < 256)
printf(i % 16 ? ", " : ",\n "); 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); printf("static const u4byte %s[4][256] = {\n{\n ", name);
for (i = 0; i < 4; i++) { for (i = 0; i < 4; i++)
for (j = 0; j < 256; ) { {
for (j = 0; j < 256;)
{
printf("0x%08x", data[i][j]); printf("0x%08x", data[i][j]);
j++; j++;
if (j < 256) if (j < 256)
@ -547,7 +632,8 @@ static void show4x256u32(char *name, uint32 data[4][256])
printf("};\n\n"); printf("};\n\n");
} }
int main() int
main()
{ {
int i; int i;
char *hdr = "/* Generated by rijndael.c */\n\n"; char *hdr = "/* Generated by rijndael.c */\n\n";
@ -567,14 +653,15 @@ int main()
show4x256u32("il_tab", il_tab); show4x256u32("il_tab", il_tab);
#endif #endif
printf("static const u4byte rco_tab[10] = {\n "); 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]); printf("0x%08x", rco_tab[i]);
if (i < 9) printf(", "); if (i < 9)
if (i == 4) printf("\n "); printf(", ");
if (i == 4)
printf("\n ");
} }
printf("\n};\n\n"); printf("\n};\n\n");
return 0; return 0;
} }
#endif #endif

18
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 int16 s2byte; /* a 16 bit signed integer type */
typedef int32 s4byte; /* a 32 bit signed integer type */ typedef int32 s4byte; /* a 32 bit signed integer type */
typedef struct _rijndael_ctx { typedef struct _rijndael_ctx
{
u4byte k_len; u4byte k_len;
int decrypt; int decrypt;
u4byte e_key[64]; u4byte e_key[64];
@ -41,17 +42,16 @@ typedef struct _rijndael_ctx {
/* require endian conversions for big-endian architectures */ /* require endian conversions for big-endian architectures */
rijndael_ctx * rijndael_ctx *
rijndael_set_key (rijndael_ctx *, const u4byte *, const u4byte, int); rijndael_set_key(rijndael_ctx *, const u4byte *, const u4byte, int);
void rijndael_encrypt (rijndael_ctx *, const u4byte *, u4byte *); void rijndael_encrypt(rijndael_ctx *, const u4byte *, u4byte *);
void rijndael_decrypt (rijndael_ctx *, const u4byte *, u4byte *); void rijndael_decrypt(rijndael_ctx *, const u4byte *, u4byte *);
/* conventional interface */ /* conventional interface */
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);
void aes_ecb_encrypt(rijndael_ctx *ctx, uint8 *data, unsigned len); 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);
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);
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);
#endif /* _RIJNDAEL_H_ */ #endif /* _RIJNDAEL_H_ */

12
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 $ */ /* $KAME: sha1.c,v 1.3 2000/02/22 14:01:18 itojun Exp $ */
/* /*
@ -87,7 +87,7 @@ do { \
static void sha1_step(struct sha1_ctxt *); static void sha1_step(struct sha1_ctxt *);
static void static void
sha1_step(struct sha1_ctxt *ctxt) sha1_step(struct sha1_ctxt * ctxt)
{ {
uint32 a, uint32 a,
b, b,
@ -232,7 +232,7 @@ sha1_step(struct sha1_ctxt *ctxt)
/*------------------------------------------------------------*/ /*------------------------------------------------------------*/
void void
sha1_init(struct sha1_ctxt *ctxt) sha1_init(struct sha1_ctxt * ctxt)
{ {
bzero(ctxt, sizeof(struct sha1_ctxt)); bzero(ctxt, sizeof(struct sha1_ctxt));
H(0) = 0x67452301; H(0) = 0x67452301;
@ -243,7 +243,7 @@ sha1_init(struct sha1_ctxt *ctxt)
} }
void void
sha1_pad(struct sha1_ctxt *ctxt) sha1_pad(struct sha1_ctxt * ctxt)
{ {
size_t padlen; /* pad length in bytes */ size_t padlen; /* pad length in bytes */
size_t padstart; size_t padstart;
@ -286,7 +286,7 @@ sha1_pad(struct sha1_ctxt *ctxt)
} }
void void
sha1_loop(struct sha1_ctxt *ctxt, const uint8 *input0, size_t len) sha1_loop(struct sha1_ctxt * ctxt, const uint8 *input0, size_t len)
{ {
const uint8 *input; const uint8 *input;
size_t gaplen; size_t gaplen;
@ -314,7 +314,7 @@ sha1_loop(struct sha1_ctxt *ctxt, const uint8 *input0, size_t len)
} }
void void
sha1_result(struct sha1_ctxt *ctxt, uint8 *digest0) sha1_result(struct sha1_ctxt * ctxt, uint8 *digest0)
{ {
uint8 *digest; uint8 *digest;

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 $ */ /* $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 SHA1Final(x, y) sha1_result((y), (x))
#define SHA1_RESULTLEN (160/8) #define SHA1_RESULTLEN (160/8)
#endif /* _NETINET6_SHA1_H_ */ #endif /* _NETINET6_SHA1_H_ */

27
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 * Copyright (c) 2001 Tatsuo Ishii
* *
@ -65,7 +65,7 @@ pgstattuple(PG_FUNCTION_ARGS)
nblocks = RelationGetNumberOfBlocks(rel); nblocks = RelationGetNumberOfBlocks(rel);
scan = heap_beginscan(rel, false, SnapshotAny, 0, NULL); scan = heap_beginscan(rel, false, SnapshotAny, 0, NULL);
while ((tuple = heap_getnext(scan,0))) while ((tuple = heap_getnext(scan, 0)))
{ {
if (HeapTupleSatisfiesNow(tuple->t_data)) if (HeapTupleSatisfiesNow(tuple->t_data))
{ {
@ -83,14 +83,14 @@ pgstattuple(PG_FUNCTION_ARGS)
{ {
block = BlockIdGetBlockNumber(&tuple->t_self.ip_blkid); block = BlockIdGetBlockNumber(&tuple->t_self.ip_blkid);
buffer = ReadBuffer(rel, block); buffer = ReadBuffer(rel, block);
free_space += PageGetFreeSpace((Page)BufferGetPage(buffer)); free_space += PageGetFreeSpace((Page) BufferGetPage(buffer));
ReleaseBuffer(buffer); ReleaseBuffer(buffer);
} }
} }
heap_endscan(scan); heap_endscan(scan);
heap_close(rel, NoLock); heap_close(rel, NoLock);
table_len = (double)nblocks*BLCKSZ; table_len = (double) nblocks *BLCKSZ;
if (nblocks == 0) if (nblocks == 0)
{ {
@ -100,29 +100,30 @@ pgstattuple(PG_FUNCTION_ARGS)
} }
else else
{ {
tuple_percent = (double)tuple_len*100.0/table_len; tuple_percent = (double) tuple_len *100.0 / table_len;
dead_tuple_percent = (double)dead_tuple_len*100.0/table_len; dead_tuple_percent = (double) dead_tuple_len *100.0 / table_len;
free_percent = (double)free_space*100.0/table_len; free_percent = (double) free_space *100.0 / table_len;
} }
elog(NOTICE,"physical length: %.2fMB live tuples: %u (%.2fMB, %.2f%%) dead tuples: %u (%.2fMB, %.2f%%) free/reusable space: %.2fMB (%.2f%%) overhead: %.2f%%", elog(NOTICE, "physical length: %.2fMB live tuples: %u (%.2fMB, %.2f%%) dead tuples: %u (%.2fMB, %.2f%%) free/reusable space: %.2fMB (%.2f%%) overhead: %.2f%%",
table_len/1024/1024, /* phsical length in MB */ table_len / 1024 / 1024, /* phsical length in MB */
tuple_count, /* number of live tuples */ tuple_count, /* number of live tuples */
(double)tuple_len/1024/1024, /* live tuples in MB */ (double) tuple_len / 1024 / 1024, /* live tuples in MB */
tuple_percent, /* live tuples in % */ tuple_percent, /* live tuples in % */
dead_tuple_count, /* number of dead tuples */ dead_tuple_count, /* number of dead tuples */
(double)dead_tuple_len/1024/1024, /* dead tuples in MB */ (double) dead_tuple_len / 1024 / 1024, /* dead tuples in MB */
dead_tuple_percent, /* dead tuples in % */ 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 % */ free_percent, /* free/available space in % */
/* overhead in % */ /* overhead in % */
(nblocks == 0)?0.0: 100.0 (nblocks == 0) ? 0.0 : 100.0
- tuple_percent - tuple_percent
- dead_tuple_percent - dead_tuple_percent
- free_percent); - free_percent);

6
contrib/rserv/rserv.c
View File

@ -24,7 +24,6 @@ Datum _rserv_debug_(PG_FUNCTION_ARGS);
HeapTuple _rserv_log_(void); HeapTuple _rserv_log_(void);
int32 _rserv_sync_(int32); int32 _rserv_sync_(int32);
int32 _rserv_debug_(int32); int32 _rserv_debug_(int32);
#endif #endif
static int debug = 0; static int debug = 0;
@ -44,7 +43,7 @@ _rserv_log_()
char **args; /* argument: argnum */ char **args; /* argument: argnum */
Relation rel; /* triggered relation */ Relation rel; /* triggered relation */
HeapTuple tuple; /* tuple to return */ HeapTuple tuple; /* tuple to return */
HeapTuple newtuple = NULL;/* tuple to return */ HeapTuple newtuple = NULL; /* tuple to return */
TupleDesc tupdesc; /* tuple description */ TupleDesc tupdesc; /* tuple description */
int keynum; int keynum;
char *key; char *key;
@ -88,6 +87,7 @@ _rserv_log_()
newtuple = CurrentTriggerData->tg_newtuple; newtuple = CurrentTriggerData->tg_newtuple;
#ifndef PG_FUNCTION_INFO_V1 #ifndef PG_FUNCTION_INFO_V1
/* /*
* Setting CurrentTriggerData to NULL prevents direct calls to trigger * Setting CurrentTriggerData to NULL prevents direct calls to trigger
* functions in queries. Normally, trigger functions have to be called * functions in queries. Normally, trigger functions have to be called
@ -207,7 +207,6 @@ _rserv_sync_(int32 server)
{ {
#ifdef PG_FUNCTION_INFO_V1 #ifdef PG_FUNCTION_INFO_V1
int32 server = PG_GETARG_INT32(0); int32 server = PG_GETARG_INT32(0);
#endif #endif
char sql[8192]; char sql[8192];
char buf[8192]; char buf[8192];
@ -253,7 +252,6 @@ _rserv_debug_(int32 newval)
{ {
#ifdef PG_FUNCTION_INFO_V1 #ifdef PG_FUNCTION_INFO_V1
int32 newval = PG_GETARG_INT32(0); int32 newval = PG_GETARG_INT32(0);
#endif #endif
int32 oldval = debug; int32 oldval = debug;

341
contrib/rtree_gist/rtree_gist.c
View File

@ -7,7 +7,7 @@
* *
* *
* IDENTIFICATION * 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 $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -20,9 +20,9 @@
#include "utils/geo_decls.h" #include "utils/geo_decls.h"
#include "utils/elog.h" #include "utils/elog.h"
typedef Datum (*RDF)(PG_FUNCTION_ARGS); typedef Datum (*RDF) (PG_FUNCTION_ARGS);
typedef Datum (*BINARY_UNION)(Datum, Datum, int*); typedef Datum (*BINARY_UNION) (Datum, Datum, int *);
typedef float (*SIZE_BOX)(Datum); typedef float (*SIZE_BOX) (Datum);
/* /*
** box ops ** box ops
@ -42,7 +42,7 @@ Datum gbox_penalty(PG_FUNCTION_ARGS);
Datum gbox_same(PG_FUNCTION_ARGS); Datum gbox_same(PG_FUNCTION_ARGS);
static bool gbox_leaf_consistent(BOX *key, BOX *query, StrategyNumber strategy); static bool gbox_leaf_consistent(BOX *key, BOX *query, StrategyNumber strategy);
static float size_box( Datum box ); static float size_box(Datum box);
/* /*
** Polygon ops ** Polygon ops
@ -75,15 +75,15 @@ Datum rtree_decompress(PG_FUNCTION_ARGS);
Datum Datum
gbox_consistent(PG_FUNCTION_ARGS) gbox_consistent(PG_FUNCTION_ARGS)
{ {
GISTENTRY *entry = (GISTENTRY*) PG_GETARG_POINTER(0); GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
BOX *query = (BOX*) PG_GETARG_POINTER(1); BOX *query = (BOX *) PG_GETARG_POINTER(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
/* /*
** if entry is not leaf, use gbox_internal_consistent, * * if entry is not leaf, use gbox_internal_consistent, * else use
** else use gbox_leaf_consistent * gbox_leaf_consistent
*/ */
if ( ! (DatumGetPointer(entry->key) != NULL && query) ) if (!(DatumGetPointer(entry->key) != NULL && query))
PG_RETURN_BOOL(FALSE); PG_RETURN_BOOL(FALSE);
if (GIST_LEAF(entry)) if (GIST_LEAF(entry))
@ -100,25 +100,28 @@ gbox_consistent(PG_FUNCTION_ARGS)
Datum Datum
gbox_union(PG_FUNCTION_ARGS) gbox_union(PG_FUNCTION_ARGS)
{ {
bytea *entryvec = (bytea*) PG_GETARG_POINTER(0); bytea *entryvec = (bytea *) PG_GETARG_POINTER(0);
int *sizep = (int*) PG_GETARG_POINTER(1); int *sizep = (int *) PG_GETARG_POINTER(1);
int numranges, i; int numranges,
BOX *cur, *pageunion; i;
BOX *cur,
*pageunion;
numranges = (VARSIZE(entryvec) - VARHDRSZ)/sizeof(GISTENTRY); numranges = (VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY);
pageunion = (BOX *)palloc( sizeof(BOX) ); pageunion = (BOX *) palloc(sizeof(BOX));
cur = DatumGetBoxP( ((GISTENTRY *) VARDATA(entryvec))[0].key ); cur = DatumGetBoxP(((GISTENTRY *) VARDATA(entryvec))[0].key);
memcpy( (void*)pageunion, (void*)cur, sizeof( BOX ) ); 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 ) cur = DatumGetBoxP(((GISTENTRY *) VARDATA(entryvec))[i].key);
if (pageunion->high.x < cur->high.x)
pageunion->high.x = cur->high.x; pageunion->high.x = cur->high.x;
if ( pageunion->low.x > cur->low.x ) if (pageunion->low.x > cur->low.x)
pageunion->low.x = cur->low.x; pageunion->low.x = cur->low.x;
if ( pageunion->high.y < cur->high.y ) if (pageunion->high.y < cur->high.y)
pageunion->high.y = cur->high.y; pageunion->high.y = cur->high.y;
if ( pageunion->low.y > cur->low.y ) if (pageunion->low.y > cur->low.y)
pageunion->low.y = cur->low.y; pageunion->low.y = cur->low.y;
} }
*sizep = sizeof(BOX); *sizep = sizeof(BOX);
@ -143,17 +146,18 @@ gbox_compress(PG_FUNCTION_ARGS)
Datum Datum
gbox_penalty(PG_FUNCTION_ARGS) gbox_penalty(PG_FUNCTION_ARGS)
{ {
GISTENTRY *origentry = (GISTENTRY*) PG_GETARG_POINTER(0); GISTENTRY *origentry = (GISTENTRY *) PG_GETARG_POINTER(0);
GISTENTRY *newentry = (GISTENTRY*) PG_GETARG_POINTER(1); GISTENTRY *newentry = (GISTENTRY *) PG_GETARG_POINTER(1);
float *result = (float*) PG_GETARG_POINTER(2); float *result = (float *) PG_GETARG_POINTER(2);
Datum ud; Datum ud;
float tmp1; float tmp1;
ud = DirectFunctionCall2(rt_box_union, origentry->key, newentry->key); ud = DirectFunctionCall2(rt_box_union, origentry->key, newentry->key);
tmp1 = size_box( ud ); tmp1 = size_box(ud);
if (DatumGetPointer(ud) != NULL) pfree(DatumGetPointer(ud)); if (DatumGetPointer(ud) != NULL)
pfree(DatumGetPointer(ud));
*result = tmp1 - size_box( origentry->key ); *result = tmp1 - size_box(origentry->key);
PG_RETURN_POINTER(result); PG_RETURN_POINTER(result);
} }
@ -165,72 +169,100 @@ gbox_penalty(PG_FUNCTION_ARGS)
Datum Datum
gbox_picksplit(PG_FUNCTION_ARGS) gbox_picksplit(PG_FUNCTION_ARGS)
{ {
bytea *entryvec = (bytea*)PG_GETARG_POINTER(0); bytea *entryvec = (bytea *) PG_GETARG_POINTER(0);
GIST_SPLITVEC *v = (GIST_SPLITVEC*)PG_GETARG_POINTER(1); GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1);
OffsetNumber i; OffsetNumber i;
OffsetNumber *listL, *listR, *listB, *listT; OffsetNumber *listL,
BOX *unionL,*unionR,*unionB,*unionT; *listR,
int posL, posR, posB, posT; *listB,
*listT;
BOX *unionL,
*unionR,
*unionB,
*unionT;
int posL,
posR,
posB,
posT;
BOX pageunion; BOX pageunion;
BOX *cur; BOX *cur;
char direction=' '; char direction = ' ';
bool allisequal=true; bool allisequal = true;
OffsetNumber maxoff; OffsetNumber maxoff;
int nbytes; int nbytes;
posL = posR = posB = posT = 0; posL = posR = posB = posT = 0;
maxoff = ((VARSIZE(entryvec) - VARHDRSZ)/sizeof(GISTENTRY)) - 1; maxoff = ((VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY)) - 1;
cur = DatumGetBoxP( ((GISTENTRY *) VARDATA(entryvec))[FirstOffsetNumber].key ); cur = DatumGetBoxP(((GISTENTRY *) VARDATA(entryvec))[FirstOffsetNumber].key);
memcpy( (void*)&pageunion, (void*)cur, sizeof( BOX ) ); memcpy((void *) &pageunion, (void *) cur, sizeof(BOX));
/* find MBR */ /* 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 ) cur = DatumGetBoxP(((GISTENTRY *) VARDATA(entryvec))[i].key);
{ allisequal=false; pageunion.high.x = cur->high.x; } if (pageunion.high.x < cur->high.x)
if ( pageunion.low.x > cur->low.x ) {
{ allisequal=false; pageunion.low.x = cur->low.x; } allisequal = false;
if ( pageunion.high.y < cur->high.y ) pageunion.high.x = cur->high.x;
{ allisequal=false; pageunion.high.y = cur->high.y; } }
if ( pageunion.low.y > cur->low.y ) if (pageunion.low.x > cur->low.x)
{ allisequal=false; pageunion.low.y = cur->low.y; } {
allisequal = false;
pageunion.low.x = cur->low.x;
}
if (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;
}
} }
nbytes = (maxoff + 2) * sizeof(OffsetNumber); nbytes = (maxoff + 2) * sizeof(OffsetNumber);
listL = (OffsetNumber*)palloc( nbytes ); listL = (OffsetNumber *) palloc(nbytes);
listR = (OffsetNumber*)palloc( nbytes ); listR = (OffsetNumber *) palloc(nbytes);
unionL = (BOX*)palloc( sizeof(BOX) ); unionL = (BOX *) palloc(sizeof(BOX));
unionR = (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 ) { cur = DatumGetBoxP(((GISTENTRY *) VARDATA(entryvec))[OffsetNumberNext(FirstOffsetNumber)].key);
if (memcmp((void *) cur, (void *) &pageunion, sizeof(BOX)) == 0)
{
v->spl_left = listL; v->spl_left = listL;
v->spl_right = listR; v->spl_right = listR;
v->spl_nleft = v->spl_nright = 0; v->spl_nleft = v->spl_nright = 0;
memcpy( (void*)unionL, (void*)&pageunion, sizeof( BOX ) ); memcpy((void *) unionL, (void *) &pageunion, sizeof(BOX));
memcpy( (void*)unionR, (void*)&pageunion, sizeof( BOX ) ); memcpy((void *) unionR, (void *) &pageunion, sizeof(BOX));
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) { for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
if (i <= (maxoff - FirstOffsetNumber + 1)/2) { {
v->spl_left[ v->spl_nleft ] = i; if (i <= (maxoff - FirstOffsetNumber + 1) / 2)
{
v->spl_left[v->spl_nleft] = i;
v->spl_nleft++; v->spl_nleft++;
} else { }
v->spl_right[ v->spl_nright ] = i; else
{
v->spl_right[v->spl_nright] = i;
v->spl_nright++; v->spl_nright++;
} }
} }
v->spl_ldatum = BoxPGetDatum( unionL ); v->spl_ldatum = BoxPGetDatum(unionL);
v->spl_rdatum = BoxPGetDatum( unionR ); v->spl_rdatum = BoxPGetDatum(unionR);
PG_RETURN_POINTER( v ); PG_RETURN_POINTER(v);
} }
} }
listB = (OffsetNumber*)palloc( nbytes ); listB = (OffsetNumber *) palloc(nbytes);
listT = (OffsetNumber*)palloc( nbytes ); listT = (OffsetNumber *) palloc(nbytes);
unionB = (BOX*)palloc( sizeof(BOX) ); unionB = (BOX *) palloc(sizeof(BOX));
unionT = (BOX*)palloc( sizeof(BOX) ); unionT = (BOX *) palloc(sizeof(BOX));
#define ADDLIST( list, unionD, pos ) do { \ #define ADDLIST( list, unionD, pos ) do { \
if ( pos ) { \ if ( pos ) { \
@ -245,65 +277,75 @@ gbox_picksplit(PG_FUNCTION_ARGS)
(pos)++; \ (pos)++; \
} while(0) } 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 ) cur = DatumGetBoxP(((GISTENTRY *) VARDATA(entryvec))[i].key);
ADDLIST( listL, unionL, posL ); if (cur->low.x - pageunion.low.x < pageunion.high.x - cur->high.x)
ADDLIST(listL, unionL, posL);
else else
ADDLIST( listR, unionR, posR ); ADDLIST(listR, unionR, posR);
if ( cur->low.y - pageunion.low.y < pageunion.high.y - cur->high.y ) if (cur->low.y - pageunion.low.y < pageunion.high.y - cur->high.y)
ADDLIST( listB, unionB, posB ); ADDLIST(listB, unionB, posB);
else else
ADDLIST( listT, unionT, posT ); ADDLIST(listT, unionT, posT);
} }
/* which split more optimal? */ /* which split more optimal? */
if ( Max( posL, posR ) < Max( posB, posT ) ) { if (Max(posL, posR) < Max(posB, posT))
direction = 'x'; direction = 'x';
} else if ( Max( posL, posR ) > Max( posB, posT ) ) { else if (Max(posL, posR) > Max(posB, posT))
direction = 'y'; direction = 'y';
} else { else
{
Datum interLR = DirectFunctionCall2(rt_box_inter, Datum interLR = DirectFunctionCall2(rt_box_inter,
BoxPGetDatum(unionL), BoxPGetDatum(unionL),
BoxPGetDatum(unionR)); BoxPGetDatum(unionR));
Datum interBT = DirectFunctionCall2(rt_box_inter, Datum interBT = DirectFunctionCall2(rt_box_inter,
BoxPGetDatum(unionB), BoxPGetDatum(unionB),
BoxPGetDatum(unionT)); BoxPGetDatum(unionT));
float sizeLR, sizeBT; float sizeLR,
sizeBT;
sizeLR = size_box( interLR ); sizeLR = size_box(interLR);
sizeBT = size_box( interBT ); sizeBT = size_box(interBT);
if ( sizeLR < sizeBT ) if (sizeLR < sizeBT)
direction = 'x'; direction = 'x';
else else
direction = 'y'; direction = 'y';
} }
if ( direction == 'x' ) { if (direction == 'x')
pfree( unionB ); pfree( listB ); {
pfree( unionT ); pfree( listT ); pfree(unionB);
pfree(listB);
pfree(unionT);
pfree(listT);
v->spl_left = listL; v->spl_left = listL;
v->spl_right = listR; v->spl_right = listR;
v->spl_nleft = posL; v->spl_nleft = posL;
v->spl_nright = posR; v->spl_nright = posR;
v->spl_ldatum = BoxPGetDatum( unionL ); v->spl_ldatum = BoxPGetDatum(unionL);
v->spl_rdatum = BoxPGetDatum( unionR ); v->spl_rdatum = BoxPGetDatum(unionR);
} else { }
pfree( unionR ); pfree( listR ); else
pfree( unionL ); pfree( listL ); {
pfree(unionR);
pfree(listR);
pfree(unionL);
pfree(listL);
v->spl_left = listB; v->spl_left = listB;
v->spl_right = listT; v->spl_right = listT;
v->spl_nleft = posB; v->spl_nleft = posB;
v->spl_nright = posT; v->spl_nright = posT;
v->spl_ldatum = BoxPGetDatum( unionB ); v->spl_ldatum = BoxPGetDatum(unionB);
v->spl_rdatum = BoxPGetDatum( unionT ); v->spl_rdatum = BoxPGetDatum(unionT);
} }
PG_RETURN_POINTER (v); PG_RETURN_POINTER(v);
} }
/* /*
@ -312,13 +354,14 @@ gbox_picksplit(PG_FUNCTION_ARGS)
Datum Datum
gbox_same(PG_FUNCTION_ARGS) gbox_same(PG_FUNCTION_ARGS)
{ {
BOX *b1 = (BOX*) PG_GETARG_POINTER(0); BOX *b1 = (BOX *) PG_GETARG_POINTER(0);
BOX *b2 = (BOX*) PG_GETARG_POINTER(1); BOX *b2 = (BOX *) PG_GETARG_POINTER(1);
bool *result = (bool*) PG_GETARG_POINTER(2); bool *result = (bool *) PG_GETARG_POINTER(2);
if ( b1 && b2 )
*result = DatumGetBool( DirectFunctionCall2( box_same, PointerGetDatum(b1), PointerGetDatum(b2)) ); if (b1 && b2)
*result = DatumGetBool(DirectFunctionCall2(box_same, PointerGetDatum(b1), PointerGetDatum(b2)));
else else
*result = ( b1==NULL && b2==NULL ) ? TRUE : FALSE; *result = (b1 == NULL && b2 == NULL) ? TRUE : FALSE;
PG_RETURN_POINTER(result); PG_RETURN_POINTER(result);
} }
@ -332,46 +375,50 @@ gbox_leaf_consistent(BOX *key,
{ {
bool retval; bool retval;
switch(strategy) { switch (strategy)
{
case RTLeftStrategyNumber: case RTLeftStrategyNumber:
retval = DatumGetBool( DirectFunctionCall2( box_left, PointerGetDatum(key), PointerGetDatum(query) ) ); retval = DatumGetBool(DirectFunctionCall2(box_left, PointerGetDatum(key), PointerGetDatum(query)));
break; break;
case RTOverLeftStrategyNumber: case RTOverLeftStrategyNumber:
retval = DatumGetBool( DirectFunctionCall2( box_overleft, PointerGetDatum(key), PointerGetDatum(query) ) ); retval = DatumGetBool(DirectFunctionCall2(box_overleft, PointerGetDatum(key), PointerGetDatum(query)));
break; break;
case RTOverlapStrategyNumber: case RTOverlapStrategyNumber:
retval = DatumGetBool( DirectFunctionCall2( box_overlap, PointerGetDatum(key), PointerGetDatum(query) ) ); retval = DatumGetBool(DirectFunctionCall2(box_overlap, PointerGetDatum(key), PointerGetDatum(query)));
break; break;
case RTOverRightStrategyNumber: case RTOverRightStrategyNumber:
retval = DatumGetBool( DirectFunctionCall2( box_overright, PointerGetDatum(key), PointerGetDatum(query) ) ); retval = DatumGetBool(DirectFunctionCall2(box_overright, PointerGetDatum(key), PointerGetDatum(query)));
break; break;
case RTRightStrategyNumber: case RTRightStrategyNumber:
retval = DatumGetBool( DirectFunctionCall2( box_right, PointerGetDatum(key), PointerGetDatum(query) ) ); retval = DatumGetBool(DirectFunctionCall2(box_right, PointerGetDatum(key), PointerGetDatum(query)));
break; break;
case RTSameStrategyNumber: case RTSameStrategyNumber:
retval = DatumGetBool( DirectFunctionCall2( box_same, PointerGetDatum(key), PointerGetDatum(query) ) ); retval = DatumGetBool(DirectFunctionCall2(box_same, PointerGetDatum(key), PointerGetDatum(query)));
break; break;
case RTContainsStrategyNumber: case RTContainsStrategyNumber:
retval = DatumGetBool( DirectFunctionCall2( box_contain, PointerGetDatum(key), PointerGetDatum(query) ) ); retval = DatumGetBool(DirectFunctionCall2(box_contain, PointerGetDatum(key), PointerGetDatum(query)));
break; break;
case RTContainedByStrategyNumber: case RTContainedByStrategyNumber:
retval = DatumGetBool( DirectFunctionCall2( box_contained, PointerGetDatum(key), PointerGetDatum(query) ) ); retval = DatumGetBool(DirectFunctionCall2(box_contained, PointerGetDatum(key), PointerGetDatum(query)));
break; break;
default: default:
retval = FALSE; retval = FALSE;
} }
return(retval); return (retval);
} }
static float static float
size_box( Datum box ) { size_box(Datum box)
if ( DatumGetPointer(box) != NULL ) { {
if (DatumGetPointer(box) != NULL)
{
float size; float size;
DirectFunctionCall2( rt_box_size, DirectFunctionCall2(rt_box_size,
box, PointerGetDatum( &size ) ); box, PointerGetDatum(&size));
return size; return size;
} else }
else
return 0.0; return 0.0;
} }
@ -382,55 +429,60 @@ size_box( Datum box ) {
Datum Datum
gpoly_compress(PG_FUNCTION_ARGS) gpoly_compress(PG_FUNCTION_ARGS)
{ {
GISTENTRY *entry=(GISTENTRY*)PG_GETARG_POINTER(0); GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
GISTENTRY *retval; GISTENTRY *retval;
if ( entry->leafkey) { if (entry->leafkey)
{
retval = palloc(sizeof(GISTENTRY)); retval = palloc(sizeof(GISTENTRY));
if ( DatumGetPointer(entry->key) != NULL ) { if (DatumGetPointer(entry->key) != NULL)
{
POLYGON *in; POLYGON *in;
BOX *r; BOX *r;
in = (POLYGON *) PG_DETOAST_DATUM(entry->key); in = (POLYGON *) PG_DETOAST_DATUM(entry->key);
r = (BOX *) palloc( sizeof(BOX) ); r = (BOX *) palloc(sizeof(BOX));
memcpy( (void*)r, (void*)&(in->boundbox), sizeof(BOX) ); memcpy((void *) r, (void *) &(in->boundbox), sizeof(BOX));
if ( in != (POLYGON *) DatumGetPointer(entry->key) ) if (in != (POLYGON *) DatumGetPointer(entry->key))
pfree( in ); pfree(in);
gistentryinit(*retval, PointerGetDatum(r), gistentryinit(*retval, PointerGetDatum(r),
entry->rel, entry->page, entry->rel, entry->page,
entry->offset, sizeof(BOX), FALSE); entry->offset, sizeof(BOX), FALSE);
} else { }
else
{
gistentryinit(*retval, (Datum) 0, gistentryinit(*retval, (Datum) 0,
entry->rel, entry->page, entry->rel, entry->page,
entry->offset, 0,FALSE); entry->offset, 0, FALSE);
} }
} else { }
else
retval = entry; retval = entry;
} PG_RETURN_POINTER(retval);
PG_RETURN_POINTER( retval );
} }
Datum Datum
gpoly_consistent(PG_FUNCTION_ARGS) gpoly_consistent(PG_FUNCTION_ARGS)
{ {
GISTENTRY *entry = (GISTENTRY*) PG_GETARG_POINTER(0); GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
POLYGON *query = (POLYGON*)PG_DETOAST_DATUM( PG_GETARG_POINTER(1) ); POLYGON *query = (POLYGON *) PG_DETOAST_DATUM(PG_GETARG_POINTER(1));
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
bool result; bool result;
/* /*
** if entry is not leaf, use gbox_internal_consistent, * * if entry is not leaf, use gbox_internal_consistent, * else use
** else use gbox_leaf_consistent * gbox_leaf_consistent
*/ */
if ( ! (DatumGetPointer(entry->key) != NULL && query) ) if (!(DatumGetPointer(entry->key) != NULL && query))
PG_RETURN_BOOL(FALSE); PG_RETURN_BOOL(FALSE);
result = rtree_internal_consistent((BOX *) DatumGetPointer(entry->key), result = rtree_internal_consistent((BOX *) DatumGetPointer(entry->key),
&(query->boundbox), strategy); &(query->boundbox), strategy);
PG_FREE_IF_COPY(query,1); PG_FREE_IF_COPY(query, 1);
PG_RETURN_BOOL( result ); PG_RETURN_BOOL(result);
} }
/***************************************** /*****************************************
@ -444,29 +496,30 @@ rtree_internal_consistent(BOX *key,
{ {
bool retval; bool retval;
switch(strategy) { switch (strategy)
{
case RTLeftStrategyNumber: case RTLeftStrategyNumber:
case RTOverLeftStrategyNumber: case RTOverLeftStrategyNumber:
retval = DatumGetBool( DirectFunctionCall2( box_overleft, PointerGetDatum(key), PointerGetDatum(query) ) ); retval = DatumGetBool(DirectFunctionCall2(box_overleft, PointerGetDatum(key), PointerGetDatum(query)));
break; break;
case RTOverlapStrategyNumber: case RTOverlapStrategyNumber:
retval = DatumGetBool( DirectFunctionCall2( box_overlap, PointerGetDatum(key), PointerGetDatum(query) ) ); retval = DatumGetBool(DirectFunctionCall2(box_overlap, PointerGetDatum(key), PointerGetDatum(query)));
break; break;
case RTOverRightStrategyNumber: case RTOverRightStrategyNumber:
case RTRightStrategyNumber: case RTRightStrategyNumber:
retval = DatumGetBool( DirectFunctionCall2( box_right, PointerGetDatum(key), PointerGetDatum(query) ) ); retval = DatumGetBool(DirectFunctionCall2(box_right, PointerGetDatum(key), PointerGetDatum(query)));
break; break;
case RTSameStrategyNumber: case RTSameStrategyNumber:
case RTContainsStrategyNumber: case RTContainsStrategyNumber:
retval = DatumGetBool( DirectFunctionCall2( box_contain, PointerGetDatum(key), PointerGetDatum(query) ) ); retval = DatumGetBool(DirectFunctionCall2(box_contain, PointerGetDatum(key), PointerGetDatum(query)));
break; break;
case RTContainedByStrategyNumber: case RTContainedByStrategyNumber:
retval = DatumGetBool( DirectFunctionCall2( box_overlap, PointerGetDatum(key), PointerGetDatum(query) ) ); retval = DatumGetBool(DirectFunctionCall2(box_overlap, PointerGetDatum(key), PointerGetDatum(query)));
break; break;
default: default:
retval = FALSE; retval = FALSE;
} }
return(retval); return (retval);
} }
/* /*

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) if (seg->lower == seg->upper && seg->l_ext == seg->u_ext)
{ {
/* /*
* indicates that this interval was built by seg_in off a single * indicates that this interval was built by seg_in off a single
* point * point
@ -219,7 +218,6 @@ gseg_consistent(GISTENTRY *entry,
SEG * query, SEG * query,
StrategyNumber strategy) StrategyNumber strategy)
{ {
/* /*
* * if entry is not leaf, use gseg_internal_consistent, * else use * * if entry is not leaf, use gseg_internal_consistent, * else use
* gseg_leaf_consistent * gseg_leaf_consistent
@ -415,7 +413,6 @@ gseg_picksplit(bytea *entryvec,
maxoff = OffsetNumberNext(maxoff); maxoff = OffsetNumberNext(maxoff);
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
{ {
/* /*
* If we've already decided where to place this item, just put it * 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 * on the right list. Otherwise, we need to figure out which page
@ -757,7 +754,6 @@ seg_size(SEG * a)
int32 int32
seg_cmp(SEG * a, SEG * b) seg_cmp(SEG * a, SEG * b)
{ {
/* /*
* First compare on lower boundary position * First compare on lower boundary position
*/ */
@ -968,7 +964,6 @@ restore(char *result, float val, int n)
{ {
if (abs(exp) <= 4) if (abs(exp) <= 4)
{ {
/* /*
* remove the decimal point from the mantyssa and write the * remove the decimal point from the mantyssa and write the
* digits to the buf array * digits to the buf array
@ -989,7 +984,6 @@ restore(char *result, float val, int n)
{ {
if (dp - 10 + exp >= n) if (dp - 10 + exp >= n)
{ {
/* /*
* the decimal point is behind the last significant * the decimal point is behind the last significant
* digit; the digits in between must be converted to * digit; the digits in between must be converted to

7
contrib/spi/refint.c
View File

@ -52,7 +52,7 @@ check_primary_key(PG_FUNCTION_ARGS)
HeapTuple tuple = NULL; /* tuple to return */ HeapTuple tuple = NULL; /* tuple to return */
TupleDesc tupdesc; /* tuple description */ TupleDesc tupdesc; /* tuple description */
EPlan *plan; /* prepared plan */ EPlan *plan; /* prepared plan */
Oid *argtypes = NULL;/* key types to prepare execution plan */ Oid *argtypes = NULL; /* key types to prepare execution plan */
bool isnull; /* to know is some column NULL or not */ bool isnull; /* to know is some column NULL or not */
char ident[2 * NAMEDATALEN]; /* to identify myself */ char ident[2 * NAMEDATALEN]; /* to identify myself */
int ret; int ret;
@ -235,10 +235,10 @@ check_foreign_key(PG_FUNCTION_ARGS)
char *relname; /* referencing relation name */ char *relname; /* referencing relation name */
Relation rel; /* triggered relation */ Relation rel; /* triggered relation */
HeapTuple trigtuple = NULL; /* tuple to being changed */ HeapTuple trigtuple = NULL; /* tuple to being changed */
HeapTuple newtuple = NULL;/* tuple to return */ HeapTuple newtuple = NULL; /* tuple to return */
TupleDesc tupdesc; /* tuple description */ TupleDesc tupdesc; /* tuple description */
EPlan *plan; /* prepared plan(s) */ EPlan *plan; /* prepared plan(s) */
Oid *argtypes = NULL;/* key types to prepare execution plan */ Oid *argtypes = NULL; /* key types to prepare execution plan */
bool isnull; /* to know is some column NULL or not */ bool isnull; /* to know is some column NULL or not */
bool isequal = true; /* are keys in both tuples equal (in bool isequal = true; /* are keys in both tuples equal (in
* UPDATE) */ * UPDATE) */
@ -537,7 +537,6 @@ check_foreign_key(PG_FUNCTION_ARGS)
*/ */
for (r = 0; r < nrefs; r++) for (r = 0; r < nrefs; r++)
{ {
/* /*
* For 'R'estrict we may to execute plan for one tuple only, for * For 'R'estrict we may to execute plan for one tuple only, for
* other actions - for all tuples. * 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)); return (string_input(str, 1, 0, NULL));
} }
#endif #endif
/* end of file */ /* end of file */

1
contrib/string/string_io.h
View File

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

18
contrib/tsearch/crc32.c
View File

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

3
contrib/tsearch/crc32.h
View File

@ -2,9 +2,8 @@
#define _CRC32_H #define _CRC32_H
/* Returns crc32 of data block */ /* Returns crc32 of data block */
extern unsigned int crc32_sz(char * buf, int size); extern unsigned int crc32_sz(char *buf, int size);
/* Returns crc32 of null-terminated string */ /* Returns crc32 of null-terminated string */
#define crc32(buf) crc32_sz((buf),strlen(buf)) #define crc32(buf) crc32_sz((buf),strlen(buf))
#endif #endif

2
contrib/tsearch/deflex.h
View File

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

7
contrib/tsearch/gistidx.h
View File

@ -9,7 +9,8 @@
* signature defines * signature defines
*/ */
#define BITBYTE 8 #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 SIGLEN ( sizeof(int4)*SIGLENINT )
#define SIGLENBIT (SIGLEN*BITBYTE) #define SIGLENBIT (SIGLEN*BITBYTE)
@ -40,7 +41,8 @@ typedef char *BITVECP;
/* /*
* type of index key * type of index key
*/ */
typedef struct { typedef struct
{
int4 len; int4 len;
int4 flag; int4 flag;
char data[1]; char data[1];
@ -61,4 +63,3 @@ typedef struct {
#define GETARR(x) ( (int4*)( (char*)x+GTHDRSIZE ) ) #define GETARR(x) ( (int4*)( (char*)x+GTHDRSIZE ) )
#define ARRNELEM(x) ( ( ((GISTTYPE*)x)->len - GTHDRSIZE )/sizeof(int4) ) #define ARRNELEM(x) ( ( ((GISTTYPE*)x)->len - GTHDRSIZE )/sizeof(int4) )
#endif #endif

124
contrib/tsearch/morph.c
View File

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

2
contrib/tsearch/morph.h
View File

@ -3,7 +3,7 @@
void initmorph(void); void initmorph(void);
char* lemmatize( char* word, int *len, int type ); char *lemmatize(char *word, int *len, int type);
bool is_stoptype(int type); bool is_stoptype(int type);
#endif #endif

5
contrib/tsearch/parser.h
View File

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

500
contrib/tsearch/query.c
View File

@ -32,13 +32,16 @@
PG_FUNCTION_INFO_V1(mqtxt_in); PG_FUNCTION_INFO_V1(mqtxt_in);
Datum mqtxt_in(PG_FUNCTION_ARGS); Datum mqtxt_in(PG_FUNCTION_ARGS);
PG_FUNCTION_INFO_V1(qtxt_in); PG_FUNCTION_INFO_V1(qtxt_in);
Datum qtxt_in(PG_FUNCTION_ARGS); Datum qtxt_in(PG_FUNCTION_ARGS);
PG_FUNCTION_INFO_V1(qtxt_out); PG_FUNCTION_INFO_V1(qtxt_out);
Datum qtxt_out(PG_FUNCTION_ARGS); Datum qtxt_out(PG_FUNCTION_ARGS);
PG_FUNCTION_INFO_V1(execqtxt); PG_FUNCTION_INFO_V1(execqtxt);
Datum execqtxt(PG_FUNCTION_ARGS); Datum execqtxt(PG_FUNCTION_ARGS);
PG_FUNCTION_INFO_V1(rexecqtxt); PG_FUNCTION_INFO_V1(rexecqtxt);
Datum rexecqtxt(PG_FUNCTION_ARGS); Datum rexecqtxt(PG_FUNCTION_ARGS);
@ -62,7 +65,8 @@ Datum querytree(PG_FUNCTION_ARGS);
* node of query tree, also used * node of query tree, also used
* for storing polish notation in parser * for storing polish notation in parser
*/ */
typedef struct NODE { typedef struct NODE
{
int4 type; int4 type;
int4 val; int4 val;
int2 distance; int2 distance;
@ -70,11 +74,12 @@ typedef struct NODE {
struct NODE *next; struct NODE *next;
} NODE; } NODE;
typedef struct { typedef struct
{
char *buf; char *buf;
int4 state; int4 state;
int4 count; int4 count;
/* reverse polish notation in list (for temprorary usage)*/ /* reverse polish notation in list (for temprorary usage) */
NODE *str; NODE *str;
/* number in str */ /* number in str */
int4 num; int4 num;
@ -93,43 +98,57 @@ typedef struct {
* get token from query string * get token from query string
*/ */
static int4 static int4
gettoken_query( QPRS_STATE* state, int4* val, int4* lenval, char** strval ) { gettoken_query(QPRS_STATE * state, int4 *val, int4 *lenval, char **strval)
while(1) { {
switch(state->state) { while (1)
{
switch (state->state)
{
case WAITOPERAND: case WAITOPERAND:
if ( *(state->buf) == '!' ) { if (*(state->buf) == '!')
{
(state->buf)++; (state->buf)++;
*val = (int4)'!'; *val = (int4) '!';
return OPR; return OPR;
} else if ( *(state->buf) == '(' ) { }
else if (*(state->buf) == '(')
{
state->count++; state->count++;
(state->buf)++; (state->buf)++;
return OPEN; return OPEN;
} else if ( *(state->buf) != ' ' ) { }
else if (*(state->buf) != ' ')
{
state->valstate.prsbuf = state->buf; state->valstate.prsbuf = state->buf;
state->state = WAITOPERATOR; state->state = WAITOPERATOR;
if ( gettoken_txtidx( &(state->valstate) ) ) { if (gettoken_txtidx(&(state->valstate)))
{
*strval = state->valstate.word; *strval = state->valstate.word;
*lenval = state->valstate.curpos - state->valstate.word; *lenval = state->valstate.curpos - state->valstate.word;
state->buf = state->valstate.prsbuf; state->buf = state->valstate.prsbuf;
return VAL; return VAL;
} else }
else
elog(ERROR, "No operand"); elog(ERROR, "No operand");
} }
break; break;
case WAITOPERATOR: case WAITOPERATOR:
if ( *(state->buf) == '&' || *(state->buf) == '|' ) { if (*(state->buf) == '&' || *(state->buf) == '|')
{
state->state = WAITOPERAND; state->state = WAITOPERAND;
*val = (int4) *(state->buf); *val = (int4) *(state->buf);
(state->buf)++; (state->buf)++;
return OPR; return OPR;
} else if ( *(state->buf) == ')' ) { }
else if (*(state->buf) == ')')
{
(state->buf)++; (state->buf)++;
state->count--; state->count--;
return ( state->count <0 ) ? ERR : CLOSE; return (state->count < 0) ? ERR : CLOSE;
} else if ( *(state->buf) == '\0' ) { }
return ( state->count ) ? ERR : END; else if (*(state->buf) == '\0')
} else if ( *(state->buf) != ' ' ) return (state->count) ? ERR : END;
else if (*(state->buf) != ' ')
return ERR; return ERR;
break; break;
default: default:
@ -145,16 +164,18 @@ gettoken_query( QPRS_STATE* state, int4* val, int4* lenval, char** strval ) {
* push new one in polish notation reverse view * push new one in polish notation reverse view
*/ */
static void 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; NODE *tmp = (NODE *) palloc(sizeof(NODE));
tmp->val =val;
if ( distance>0xffff ) tmp->type = type;
elog(ERROR,"Value is too big"); tmp->val = val;
if ( lenval > 0xffff ) if (distance > 0xffff)
elog(ERROR,"Operand is too long"); elog(ERROR, "Value is too big");
tmp->distance=distance; if (lenval > 0xffff)
tmp->length=lenval; elog(ERROR, "Operand is too long");
tmp->distance = distance;
tmp->length = lenval;
tmp->next = state->str; tmp->next = state->str;
state->str = tmp; state->str = tmp;
state->num++; state->num++;
@ -164,20 +185,23 @@ pushquery( QPRS_STATE *state, int4 type, int4 val, int4 distance, int4 lenval) {
* This function is used for query_txt parsing * This function is used for query_txt parsing
*/ */
static void 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 ) {
if (lenval > 0xffff)
elog(ERROR, "Word is too long"); elog(ERROR, "Word is too long");
pushquery(state, type, crc32_sz( (uint8*)strval, lenval ), pushquery(state, type, crc32_sz((uint8 *) strval, lenval),
state->curop - state->op, 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; int4 tmp = state->curop - state->op;
state->lenop *= 2; state->lenop *= 2;
state->op = (char*)repalloc( (void*)state->op, state->lenop ); state->op = (char *) repalloc((void *) state->op, state->lenop);
state->curop = state->op + tmp; state->curop = state->op + tmp;
} }
memcpy( (void*)state->curop, (void*)strval, lenval ); memcpy((void *) state->curop, (void *) strval, lenval);
state->curop += lenval; state->curop += lenval;
*(state->curop) = '\0'; *(state->curop) = '\0';
state->curop++; state->curop++;
@ -189,27 +213,33 @@ pushval_asis(QPRS_STATE *state, int type, char* strval, int lenval) {
* This function is used for mquery_txt parsing * This function is used for mquery_txt parsing
*/ */
static void static void
pushval_morph(QPRS_STATE *state, int typeval, char* strval, int lenval) { pushval_morph(QPRS_STATE * state, int typeval, char *strval, int lenval)
int4 type, lenlemm; {
int4 type,
lenlemm;
int4 count = 0; int4 count = 0;
char *lemm; char *lemm;
start_parse_str( strval, lenval ); start_parse_str(strval, lenval);
while( (type=tsearch_yylex()) != 0 ) { while ((type = tsearch_yylex()) != 0)
if ( tokenlen>0xffff ) { {
if (tokenlen > 0xffff)
{
end_parse(); end_parse();
elog(ERROR, "Word is too long"); elog(ERROR, "Word is too long");
} }
lenlemm = tokenlen; lenlemm = tokenlen;
lemm = lemmatize( token, &lenlemm, type ); lemm = lemmatize(token, &lenlemm, type);
if ( lemm ) { if (lemm)
pushval_asis(state,VAL,lemm,lenlemm); {
if ( lemm != token ) pfree(lemm); pushval_asis(state, VAL, lemm, lenlemm);
} else { if (lemm != token)
pushval_asis(state,VALTRUE,0,0); pfree(lemm);
} }
if ( count ) else
pushquery(state, OPR, (int4)'&', 0,0); pushval_asis(state, VALTRUE, 0, 0);
if (count)
pushquery(state, OPR, (int4) '&', 0, 0);
count++; count++;
} }
end_parse(); end_parse();
@ -220,63 +250,74 @@ pushval_morph(QPRS_STATE *state, int typeval, char* strval, int lenval) {
* make polish notaion of query * make polish notaion of query
*/ */
static int4 static int4
makepol(QPRS_STATE *state, void (*pushval)(QPRS_STATE*,int,char*,int)) { makepol(QPRS_STATE * state, void (*pushval) (QPRS_STATE *, int, char *, int))
int4 val,type; {
int4 val,
type;
int4 lenval; int4 lenval;
char *strval; char *strval;
int4 stack[STACKDEPTH]; int4 stack[STACKDEPTH];
int4 lenstack=0; int4 lenstack = 0;
while( (type=gettoken_query(state, &val, &lenval, &strval))!=END ) { while ((type = gettoken_query(state, &val, &lenval, &strval)) != END)
switch(type) { {
switch (type)
{
case VAL: case VAL:
(*pushval)(state, VAL, strval, lenval); (*pushval) (state, VAL, strval, lenval);
while ( lenstack && (stack[ lenstack-1 ] == (int4)'&' || while (lenstack && (stack[lenstack - 1] == (int4) '&' ||
stack[ lenstack-1 ] == (int4)'!') ) { stack[lenstack - 1] == (int4) '!'))
{
lenstack--; lenstack--;
pushquery(state, OPR, stack[ lenstack ], 0,0); pushquery(state, OPR, stack[lenstack], 0, 0);
} }
break; break;
case OPR: case OPR:
if ( lenstack && val == (int4) '|' ) { if (lenstack && val == (int4) '|')
pushquery(state, OPR, val, 0,0); pushquery(state, OPR, val, 0, 0);
} else { else
if ( lenstack == STACKDEPTH ) {
elog(ERROR,"Stack too short"); if (lenstack == STACKDEPTH)
stack[ lenstack ] = val; elog(ERROR, "Stack too short");
stack[lenstack] = val;
lenstack++; lenstack++;
} }
break; break;
case OPEN: case OPEN:
if ( makepol( state, pushval ) == ERR ) return ERR; if (makepol(state, pushval) == ERR)
if ( lenstack && (stack[ lenstack-1 ] == (int4)'&' || return ERR;
stack[ lenstack-1 ] == (int4)'!') ) { if (lenstack && (stack[lenstack - 1] == (int4) '&' ||
stack[lenstack - 1] == (int4) '!'))
{
lenstack--; lenstack--;
pushquery(state, OPR, stack[ lenstack ], 0,0); pushquery(state, OPR, stack[lenstack], 0, 0);
} }
break; break;
case CLOSE: case CLOSE:
while ( lenstack ) { while (lenstack)
{
lenstack--; lenstack--;
pushquery(state, OPR, stack[ lenstack ], 0,0); pushquery(state, OPR, stack[lenstack], 0, 0);
}; };
return END; return END;
break; break;
case ERR: case ERR:
default: default:
elog(ERROR,"Syntax error"); elog(ERROR, "Syntax error");
return ERR; return ERR;
} }
} }
while (lenstack) { while (lenstack)
{
lenstack--; lenstack--;
pushquery(state, OPR, stack[ lenstack ],0,0); pushquery(state, OPR, stack[lenstack], 0, 0);
}; };
return END; return END;
} }
typedef struct { typedef struct
{
WordEntry *arrb; WordEntry *arrb;
WordEntry *arre; WordEntry *arre;
char *values; char *values;
@ -287,31 +328,34 @@ typedef struct {
* compare 2 string values * compare 2 string values
*/ */
static int4 static int4
ValCompare( CHKVAL *chkval, WordEntry *ptr, ITEM *item ) { ValCompare(CHKVAL * chkval, WordEntry * ptr, ITEM * item)
if ( ptr->len == item->length ) {
if (ptr->len == item->length)
return strncmp( return strncmp(
&(chkval->values[ ptr->pos ]), &(chkval->values[ptr->pos]),
&(chkval->operand[item->distance]), &(chkval->operand[item->distance]),
item->length ); item->length);
return ( ptr->len > item->length ) ? 1 : -1; return (ptr->len > item->length) ? 1 : -1;
} }
/* /*
* is there value 'val' in array or not ? * is there value 'val' in array or not ?
*/ */
static bool 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 *StopLow = ((CHKVAL *) checkval)->arrb;
WordEntry *StopHigh = ((CHKVAL *) checkval)->arre;
WordEntry *StopMiddle; WordEntry *StopMiddle;
int difference; int difference;
/* Loop invariant: StopLow <= val < StopHigh */ /* Loop invariant: StopLow <= val < StopHigh */
while (StopLow < StopHigh) { while (StopLow < StopHigh)
{
StopMiddle = StopLow + (StopHigh - StopLow) / 2; StopMiddle = StopLow + (StopHigh - StopLow) / 2;
difference = ValCompare((CHKVAL*)checkval, StopMiddle, val); difference = ValCompare((CHKVAL *) checkval, StopMiddle, val);
if (difference == 0) if (difference == 0)
return (true); return (true);
else if (difference < 0) else if (difference < 0)
@ -327,20 +371,26 @@ checkcondition_str( void *checkval, ITEM* val ) {
* check for boolean condition * check for boolean condition
*/ */
bool bool
execute( ITEM* curitem, void *checkval, bool calcnot, bool (*chkcond)(void *checkval, ITEM *val )) { execute(ITEM * curitem, void *checkval, bool calcnot, bool (*chkcond) (void *checkval, ITEM * val))
if ( curitem->type == VAL ) { {
return (*chkcond)( checkval, curitem ); if (curitem->type == VAL)
} else if ( curitem->val == (int4)'!' ) { return (*chkcond) (checkval, curitem);
return ( calcnot ) ? else if (curitem->val == (int4) '!')
( ( execute(curitem + 1, checkval, calcnot, chkcond) ) ? false : true ) {
return (calcnot) ?
((execute(curitem + 1, checkval, calcnot, chkcond)) ? false : true)
: true; : true;
} else if ( curitem->val == (int4)'&' ) { }
if ( execute(curitem + curitem->left, checkval, calcnot, chkcond) ) else if (curitem->val == (int4) '&')
{
if (execute(curitem + curitem->left, checkval, calcnot, chkcond))
return execute(curitem + 1, checkval, calcnot, chkcond); return execute(curitem + 1, checkval, calcnot, chkcond);
else else
return false; return false;
} else { /* |-operator */ }
if ( execute(curitem + curitem->left, checkval, calcnot, chkcond) ) else
{ /* |-operator */
if (execute(curitem + curitem->left, checkval, calcnot, chkcond))
return true; return true;
else else
return execute(curitem + 1, checkval, calcnot, chkcond); return execute(curitem + 1, checkval, calcnot, chkcond);
@ -352,7 +402,8 @@ execute( ITEM* curitem, void *checkval, bool calcnot, bool (*chkcond)(void *chec
* boolean operations * boolean operations
*/ */
Datum Datum
rexecqtxt(PG_FUNCTION_ARGS) { rexecqtxt(PG_FUNCTION_ARGS)
{
return DirectFunctionCall2( return DirectFunctionCall2(
execqtxt, execqtxt,
PG_GETARG_DATUM(1), PG_GETARG_DATUM(1),
@ -361,22 +412,24 @@ rexecqtxt(PG_FUNCTION_ARGS) {
} }
Datum 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))); txtidx *val = (txtidx *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0)));
QUERYTYPE *query = (QUERYTYPE *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(1)));
CHKVAL chkval; CHKVAL chkval;
bool result; bool result;
if ( ! val->size ) { if (!val->size)
PG_FREE_IF_COPY(val,0); {
PG_FREE_IF_COPY(query,1); PG_FREE_IF_COPY(val, 0);
PG_RETURN_BOOL( false ); PG_FREE_IF_COPY(query, 1);
PG_RETURN_BOOL(false);
} }
chkval.arrb = ARRPTR(val); chkval.arrb = ARRPTR(val);
chkval.arre = chkval.arrb + val->size; chkval.arre = chkval.arrb + val->size;
chkval.values = STRPTR(val); chkval.values = STRPTR(val);
chkval.operand = GETOPERAND( query ); chkval.operand = GETOPERAND(query);
result = execute( result = execute(
GETQUERY(query), GETQUERY(query),
&chkval, &chkval,
@ -384,34 +437,41 @@ execqtxt(PG_FUNCTION_ARGS) {
checkcondition_str checkcondition_str
); );
PG_FREE_IF_COPY(val,0); PG_FREE_IF_COPY(val, 0);
PG_FREE_IF_COPY(query,1); PG_FREE_IF_COPY(query, 1);
PG_RETURN_BOOL( result ); PG_RETURN_BOOL(result);
} }
/* /*
* find left operand in polish notation view * find left operand in polish notation view
*/ */
static void static void
findoprnd( ITEM *ptr, int4 *pos ) { findoprnd(ITEM * ptr, int4 *pos)
{
#ifdef BS_DEBUG #ifdef BS_DEBUG
elog(NOTICE, ( ptr[*pos].type == OPR ) ? elog(NOTICE, (ptr[*pos].type == OPR) ?
"%d %c" : "%d %d ", *pos, ptr[*pos].val ); "%d %c" : "%d %d ", *pos, ptr[*pos].val);
#endif #endif
if ( ptr[*pos].type == VAL || ptr[*pos].type == VALTRUE ) { if (ptr[*pos].type == VAL || ptr[*pos].type == VALTRUE)
{
ptr[*pos].left = 0; ptr[*pos].left = 0;
(*pos)++; (*pos)++;
} else if ( ptr[*pos].val == (int4)'!' ) { }
else if (ptr[*pos].val == (int4) '!')
{
ptr[*pos].left = 1; ptr[*pos].left = 1;
(*pos)++; (*pos)++;
findoprnd( ptr, pos ); findoprnd(ptr, pos);
} else { }
else
{
ITEM *curitem = &ptr[*pos]; ITEM *curitem = &ptr[*pos];
int4 tmp = *pos; int4 tmp = *pos;
(*pos)++; (*pos)++;
findoprnd(ptr,pos); findoprnd(ptr, pos);
curitem->left = *pos - tmp; curitem->left = *pos - tmp;
findoprnd(ptr,pos); findoprnd(ptr, pos);
} }
} }
@ -419,16 +479,20 @@ findoprnd( ITEM *ptr, int4 *pos ) {
/* /*
* input * 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; QPRS_STATE state;
int4 i; int4 i;
QUERYTYPE *query; QUERYTYPE *query;
int4 commonlen; int4 commonlen;
ITEM *ptr; ITEM *ptr;
NODE *tmp; NODE *tmp;
int4 pos=0; int4 pos = 0;
#ifdef BS_DEBUG #ifdef BS_DEBUG
char pbuf[16384],*cur; char pbuf[16384],
*cur;
#endif #endif
/* init state */ /* init state */
@ -436,62 +500,64 @@ static QUERYTYPE *queryin(char *buf, void (*pushval)(QPRS_STATE*,int,char*,int)
state.state = WAITOPERAND; state.state = WAITOPERAND;
state.count = 0; state.count = 0;
state.num = 0; state.num = 0;
state.str=NULL; state.str = NULL;
/* init value parser's state */ /* init value parser's state */
state.valstate.oprisdelim = true; state.valstate.oprisdelim = true;
state.valstate.len=32; state.valstate.len = 32;
state.valstate.word = (char*)palloc( state.valstate.len ); state.valstate.word = (char *) palloc(state.valstate.len);
/* init list of operand */ /* init list of operand */
state.sumlen=0; state.sumlen = 0;
state.lenop=64; state.lenop = 64;
state.curop = state.op = (char*)palloc( state.lenop ); state.curop = state.op = (char *) palloc(state.lenop);
*(state.curop) = '\0'; *(state.curop) = '\0';
/* parse query & make polish notation (postfix, but in reverse order) */ /* parse query & make polish notation (postfix, but in reverse order) */
makepol( &state, pushval ); makepol(&state, pushval);
pfree( state.valstate.word ); pfree(state.valstate.word);
if (!state.num) if (!state.num)
elog( ERROR,"Empty query"); elog(ERROR, "Empty query");
/* make finish struct */ /* make finish struct */
commonlen = COMPUTESIZE(state.num, state.sumlen); commonlen = COMPUTESIZE(state.num, state.sumlen);
query = (QUERYTYPE*) palloc( commonlen ); query = (QUERYTYPE *) palloc(commonlen);
query->len = commonlen; query->len = commonlen;
query->size = state.num; query->size = state.num;
ptr = GETQUERY(query); ptr = GETQUERY(query);
/* set item in polish notation */ /* 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].type = state.str->type;
ptr[i].val = state.str->val; ptr[i].val = state.str->val;
ptr[i].distance = state.str->distance; ptr[i].distance = state.str->distance;
ptr[i].length = state.str->length; ptr[i].length = state.str->length;
tmp = state.str->next; tmp = state.str->next;
pfree( state.str ); pfree(state.str);
state.str = tmp; state.str = tmp;
} }
/* set user friendly-operand view */ /* set user friendly-operand view */
memcpy( (void*)GETOPERAND(query), (void*)state.op, state.sumlen ); memcpy((void *) GETOPERAND(query), (void *) state.op, state.sumlen);
pfree( state.op ); pfree(state.op);
/* set left operand's position for every operator */ /* set left operand's position for every operator */
pos = 0; pos = 0;
findoprnd( ptr, &pos ); findoprnd(ptr, &pos);
#ifdef BS_DEBUG #ifdef BS_DEBUG
cur = pbuf; cur = pbuf;
*cur = '\0'; *cur = '\0';
for( i=0;i<query->size;i++ ) { for (i = 0; i < query->size; i++)
if ( ptr[i].type == OPR ) {
if (ptr[i].type == OPR)
sprintf(cur, "%c(%d) ", ptr[i].val, ptr[i].left); sprintf(cur, "%c(%d) ", ptr[i].val, ptr[i].left);
else else
sprintf(cur, "%d(%s) ", ptr[i].val, GETOPERAND(query) + ptr[i].distance ); sprintf(cur, "%d(%s) ", ptr[i].val, GETOPERAND(query) + ptr[i].distance);
cur = strchr(cur,'\0'); cur = strchr(cur, '\0');
} }
elog(NOTICE,"POR: %s", pbuf); elog(NOTICE, "POR: %s", pbuf);
#endif #endif
return query; return query;
@ -501,53 +567,60 @@ static QUERYTYPE *queryin(char *buf, void (*pushval)(QPRS_STATE*,int,char*,int)
* in without morphology * in without morphology
*/ */
Datum Datum
qtxt_in(PG_FUNCTION_ARGS) { qtxt_in(PG_FUNCTION_ARGS)
PG_RETURN_POINTER( queryin((char*)PG_GETARG_POINTER(0),pushval_asis) ); {
PG_RETURN_POINTER(queryin((char *) PG_GETARG_POINTER(0), pushval_asis));
} }
/* /*
* in with morphology * in with morphology
*/ */
Datum Datum
mqtxt_in(PG_FUNCTION_ARGS) { mqtxt_in(PG_FUNCTION_ARGS)
{
QUERYTYPE *query; QUERYTYPE *query;
ITEM* res; ITEM *res;
int4 len; int4 len;
#ifdef BS_DEBUG #ifdef BS_DEBUG
ITEM *ptr; ITEM *ptr;
int4 i; int4 i;
char pbuf[16384],*cur; char pbuf[16384],
*cur;
#endif #endif
initmorph(); initmorph();
query = queryin((char*)PG_GETARG_POINTER(0),pushval_morph); query = queryin((char *) PG_GETARG_POINTER(0), pushval_morph);
res = clean_fakeval( GETQUERY(query), &len ); res = clean_fakeval(GETQUERY(query), &len);
if ( ! res ) { if (!res)
{
pfree(query); pfree(query);
PG_RETURN_NULL(); PG_RETURN_NULL();
} }
memcpy( (void*)GETQUERY(query), (void*)res, len*sizeof(ITEM) ); memcpy((void *) GETQUERY(query), (void *) res, len * sizeof(ITEM));
#ifdef BS_DEBUG #ifdef BS_DEBUG
cur = pbuf; cur = pbuf;
*cur = '\0'; *cur = '\0';
ptr = GETQUERY(query); ptr = GETQUERY(query);
for( i=0;i<len;i++ ) { for (i = 0; i < len; i++)
if ( ptr[i].type == OPR ) {
if (ptr[i].type == OPR)
sprintf(cur, "%c(%d) ", ptr[i].val, ptr[i].left); sprintf(cur, "%c(%d) ", ptr[i].val, ptr[i].left);
else else
sprintf(cur, "%d(%s) ", ptr[i].val, GETOPERAND(query) + ptr[i].distance ); sprintf(cur, "%d(%s) ", ptr[i].val, GETOPERAND(query) + ptr[i].distance);
cur = strchr(cur,'\0'); cur = strchr(cur, '\0');
} }
elog(NOTICE,"POR: %s", pbuf); elog(NOTICE, "POR: %s", pbuf);
#endif #endif
pfree(res); pfree(res);
PG_RETURN_POINTER( query ); PG_RETURN_POINTER(query);
} }
/* /*
* out function * out function
*/ */
typedef struct { typedef struct
{
ITEM *curpol; ITEM *curpol;
char *buf; char *buf;
char *cur; char *cur;
@ -569,94 +642,113 @@ while( ( inf->cur - inf->buf ) + addsize + 1 >= inf->buflen ) \
* infix (human-readable) view * infix (human-readable) view
*/ */
static void static void
infix(INFIX *in, bool first) { infix(INFIX * in, bool first)
if ( in->curpol->type == VAL ) { {
if (in->curpol->type == VAL)
{
char *op = in->op + in->curpol->distance; char *op = in->op + in->curpol->distance;
RESIZEBUF(in, in->curpol->length*2 + 2);
*(in->cur) = '\''; in->cur++; RESIZEBUF(in, in->curpol->length * 2 + 2);
while( *op ) { *(in->cur) = '\'';
if ( *op == '\'' ) { in->cur++;
*(in->cur) = '\\'; in->cur++; while (*op)
{
if (*op == '\'')
{
*(in->cur) = '\\';
in->cur++;
} }
*(in->cur) = *op; *(in->cur) = *op;
op++; in->cur++; op++;
in->cur++;
} }
*(in->cur) = '\''; in->cur++; *(in->cur) = '\'';
in->cur++;
*(in->cur) = '\0'; *(in->cur) = '\0';
in->curpol++; in->curpol++;
} else if ( in->curpol->val == (int4)'!' ) { }
else if (in->curpol->val == (int4) '!')
{
bool isopr = false; bool isopr = false;
RESIZEBUF(in, 1); RESIZEBUF(in, 1);
*(in->cur) = '!'; *(in->cur) = '!';
in->cur++; in->cur++;
*(in->cur) = '\0'; *(in->cur) = '\0';
in->curpol++; in->curpol++;
if ( in->curpol->type == OPR ) { if (in->curpol->type == OPR)
{
isopr = true; isopr = true;
RESIZEBUF(in, 2); RESIZEBUF(in, 2);
sprintf(in->cur, "( "); sprintf(in->cur, "( ");
in->cur = strchr( in->cur, '\0' ); in->cur = strchr(in->cur, '\0');
} }
infix( in, isopr ); infix(in, isopr);
if ( isopr ) { if (isopr)
{
RESIZEBUF(in, 2); RESIZEBUF(in, 2);
sprintf(in->cur, " )"); sprintf(in->cur, " )");
in->cur = strchr( in->cur, '\0' ); in->cur = strchr(in->cur, '\0');
} }
} else { }
else
{
int4 op = in->curpol->val; int4 op = in->curpol->val;
INFIX nrm; INFIX nrm;
in->curpol++; in->curpol++;
if ( op == (int4)'|' && ! first) { if (op == (int4) '|' && !first)
{
RESIZEBUF(in, 2); RESIZEBUF(in, 2);
sprintf(in->cur, "( "); sprintf(in->cur, "( ");
in->cur = strchr( in->cur, '\0' ); in->cur = strchr(in->cur, '\0');
} }
nrm.curpol = in->curpol; nrm.curpol = in->curpol;
nrm.op = in->op; nrm.op = in->op;
nrm.buflen = 16; nrm.buflen = 16;
nrm.cur = nrm.buf = (char*)palloc( sizeof(char) * nrm.buflen ); nrm.cur = nrm.buf = (char *) palloc(sizeof(char) * nrm.buflen);
/* get right operand */ /* get right operand */
infix( &nrm, false ); infix(&nrm, false);
/* get & print left operand */ /* get & print left operand */
in->curpol = nrm.curpol; in->curpol = nrm.curpol;
infix( in, false ); infix(in, false);
/* print operator & right operand*/ /* print operator & right operand */
RESIZEBUF(in, 3 + (nrm.cur - nrm.buf) ); RESIZEBUF(in, 3 + (nrm.cur - nrm.buf));
sprintf(in->cur, " %c %s", op, nrm.buf); sprintf(in->cur, " %c %s", op, nrm.buf);
in->cur = strchr( in->cur, '\0' ); in->cur = strchr(in->cur, '\0');
pfree( nrm.buf ); pfree(nrm.buf);
if ( op == (int4)'|' && ! first) { if (op == (int4) '|' && !first)
{
RESIZEBUF(in, 2); RESIZEBUF(in, 2);
sprintf(in->cur, " )"); sprintf(in->cur, " )");
in->cur = strchr( in->cur, '\0' ); in->cur = strchr(in->cur, '\0');
} }
} }
} }
Datum Datum
qtxt_out(PG_FUNCTION_ARGS) { qtxt_out(PG_FUNCTION_ARGS)
QUERYTYPE *query = (QUERYTYPE*)DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0))); {
QUERYTYPE *query = (QUERYTYPE *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0)));
INFIX nrm; INFIX nrm;
if ( query->size == 0 ) if (query->size == 0)
elog(ERROR,"Empty"); elog(ERROR, "Empty");
nrm.curpol = GETQUERY(query); nrm.curpol = GETQUERY(query);
nrm.buflen = 32; nrm.buflen = 32;
nrm.cur = nrm.buf = (char*)palloc( sizeof(char) * nrm.buflen ); nrm.cur = nrm.buf = (char *) palloc(sizeof(char) * nrm.buflen);
*(nrm.cur) = '\0'; *(nrm.cur) = '\0';
nrm.op = GETOPERAND(query); nrm.op = GETOPERAND(query);
infix( &nrm, true ); infix(&nrm, true);
PG_FREE_IF_COPY(query,0); PG_FREE_IF_COPY(query, 0);
PG_RETURN_POINTER( nrm.buf ); PG_RETURN_POINTER(nrm.buf);
} }
/* /*
@ -664,38 +756,42 @@ qtxt_out(PG_FUNCTION_ARGS) {
* which will be executed in non-leaf pages in index * which will be executed in non-leaf pages in index
*/ */
Datum Datum
querytree(PG_FUNCTION_ARGS) { querytree(PG_FUNCTION_ARGS)
QUERYTYPE *query = (QUERYTYPE*)DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0))); {
QUERYTYPE *query = (QUERYTYPE *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0)));
INFIX nrm; INFIX nrm;
text *res; text *res;
ITEM *q; ITEM *q;
int4 len; int4 len;
if ( query->size == 0 ) if (query->size == 0)
elog(ERROR,"Empty"); elog(ERROR, "Empty");
q = clean_NOT(GETQUERY(query), &len); q = clean_NOT(GETQUERY(query), &len);
if ( ! q ) { if (!q)
res = (text*) palloc( 1 + VARHDRSZ ); {
res = (text *) palloc(1 + VARHDRSZ);
VARATT_SIZEP(res) = 1 + VARHDRSZ; VARATT_SIZEP(res) = 1 + VARHDRSZ;
*((char*)VARDATA(res)) = 'T'; *((char *) VARDATA(res)) = 'T';
} else { }
else
{
nrm.curpol = q; nrm.curpol = q;
nrm.buflen = 32; nrm.buflen = 32;
nrm.cur = nrm.buf = (char*)palloc( sizeof(char) * nrm.buflen ); nrm.cur = nrm.buf = (char *) palloc(sizeof(char) * nrm.buflen);
*(nrm.cur) = '\0'; *(nrm.cur) = '\0';
nrm.op = GETOPERAND(query); nrm.op = GETOPERAND(query);
infix( &nrm, true ); infix(&nrm, true);
res = (text*) palloc( nrm.cur-nrm.buf + VARHDRSZ ); res = (text *) palloc(nrm.cur - nrm.buf + VARHDRSZ);
VARATT_SIZEP(res) = nrm.cur-nrm.buf + VARHDRSZ; VARATT_SIZEP(res) = nrm.cur - nrm.buf + VARHDRSZ;
strncpy( VARDATA(res), nrm.buf, nrm.cur-nrm.buf ); strncpy(VARDATA(res), nrm.buf, nrm.cur - nrm.buf);
pfree(q); pfree(q);
} }
PG_FREE_IF_COPY(query,0); PG_FREE_IF_COPY(query, 0);
PG_RETURN_POINTER( res ); PG_RETURN_POINTER(res);
} }

10
contrib/tsearch/query.h
View File

@ -9,7 +9,8 @@
* item in polish notation with back link * item in polish notation with back link
* to left operand * to left operand
*/ */
typedef struct ITEM { typedef struct ITEM
{
int2 type; int2 type;
int2 left; int2 left;
int4 val; int4 val;
@ -22,7 +23,8 @@ typedef struct ITEM {
*Storage: *Storage:
* (len)(size)(array of ITEM)(array of operand in user-friendly form) * (len)(size)(array of ITEM)(array of operand in user-friendly form)
*/ */
typedef struct { typedef struct
{
int4 len; int4 len;
int4 size; int4 size;
char data[1]; char data[1];
@ -44,6 +46,6 @@ typedef struct {
#define VALTRUE 6 /* for stop words */ #define VALTRUE 6 /* for stop words */
#define VALFALSE 7 #define VALFALSE 7
bool execute( ITEM* curitem, void *checkval, bool execute(ITEM * curitem, void *checkval,
bool calcnot, bool (*chkcond)(void *checkval, ITEM* val )); bool calcnot, bool (*chkcond) (void *checkval, ITEM * val));
#endif #endif

224
contrib/tsearch/rewrite.c
View File

@ -19,49 +19,60 @@
#include "query.h" #include "query.h"
#include "rewrite.h" #include "rewrite.h"
typedef struct NODE { typedef struct NODE
{
struct NODE *left; struct NODE *left;
struct NODE *right; struct NODE *right;
ITEM* valnode; ITEM *valnode;
} NODE; } NODE;
/* /*
* make query tree from plain view of query * make query tree from plain view of query
*/ */
static NODE* static NODE *
maketree(ITEM *in) { maketree(ITEM * in)
NODE *node = (NODE*)palloc(sizeof(NODE)); {
NODE *node = (NODE *) palloc(sizeof(NODE));
node->valnode = in; node->valnode = in;
node->right = node->left = NULL; node->right = node->left = NULL;
if ( in->type == OPR ) { if (in->type == OPR)
node->right = maketree( in + 1 ); {
if ( in->val != (int4)'!' ) node->right = maketree(in + 1);
node->left = maketree( in + in->left ); if (in->val != (int4) '!')
node->left = maketree(in + in->left);
} }
return node; return node;
} }
typedef struct { typedef struct
ITEM* ptr; {
ITEM *ptr;
int4 len; int4 len;
int4 cur; int4 cur;
} PLAINTREE; } PLAINTREE;
static void static void
plainnode(PLAINTREE *state, NODE* node) { plainnode(PLAINTREE * state, NODE * node)
if ( state->cur == state->len ) { {
if (state->cur == state->len)
{
state->len *= 2; state->len *= 2;
state->ptr=(ITEM*)repalloc( (void*)state->ptr, state->len*sizeof(ITEM) ); state->ptr = (ITEM *) repalloc((void *) state->ptr, state->len * sizeof(ITEM));
} }
memcpy( (void*)&(state->ptr[state->cur]), (void*)node->valnode, 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++; state->cur++;
} else if ( node->valnode->val == (int4)'!' ) { else if (node->valnode->val == (int4) '!')
state->ptr[state->cur].left=1; {
state->ptr[state->cur].left = 1;
state->cur++; state->cur++;
plainnode(state, node->right); plainnode(state, node->right);
} else { }
else
{
int4 cur = state->cur; int4 cur = state->cur;
state->cur++; state->cur++;
plainnode(state, node->right); plainnode(state, node->right);
state->ptr[cur].left = state->cur - cur; state->ptr[cur].left = state->cur - cur;
@ -73,27 +84,34 @@ plainnode(PLAINTREE *state, NODE* node) {
/* /*
* make plain view of tree from 'normal' view of tree * make plain view of tree from 'normal' view of tree
*/ */
static ITEM* static ITEM *
plaintree(NODE *root, int4 *len) { plaintree(NODE * root, int4 *len)
{
PLAINTREE pl; PLAINTREE pl;
pl.cur=0;
pl.len=16; pl.cur = 0;
if ( root && (root->valnode->type == VAL || root->valnode->type == OPR) ) { pl.len = 16;
pl.ptr = (ITEM*)palloc( pl.len*sizeof(ITEM) ); if (root && (root->valnode->type == VAL || root->valnode->type == OPR))
{
pl.ptr = (ITEM *) palloc(pl.len * sizeof(ITEM));
plainnode(&pl, root); plainnode(&pl, root);
} else {
pl.ptr = NULL;
} }
else
pl.ptr = NULL;
*len = pl.cur; *len = pl.cur;
return pl.ptr; return pl.ptr;
} }
static void static void
freetree(NODE *node) { freetree(NODE * node)
if ( !node ) return; {
if ( node->left ) freetree(node->left); if (!node)
if ( node->right ) freetree(node->right); return;
pfree( node ); if (node->left)
freetree(node->left);
if (node->right)
freetree(node->right);
pfree(node);
} }
/* /*
@ -102,34 +120,46 @@ freetree(NODE *node) {
* other case, such view is used with search in index. * other case, such view is used with search in index.
* Operator ! always return TRUE * Operator ! always return TRUE
*/ */
static NODE* static NODE *
clean_NOT_intree( NODE* node ) { clean_NOT_intree(NODE * node)
if ( node->valnode->type == VAL ) {
if (node->valnode->type == VAL)
return node; return node;
if ( node->valnode->val == (int4)'!' ) { if (node->valnode->val == (int4) '!')
{
freetree(node); freetree(node);
return NULL; return NULL;
} }
/* operator & or | */ /* 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 ) { if ((node->left = clean_NOT_intree(node->left)) == NULL ||
(node->right = clean_NOT_intree(node->right)) == NULL)
{
freetree(node); freetree(node);
return NULL; return NULL;
} }
} else { }
else
{
NODE *res = node; NODE *res = node;
node->left=clean_NOT_intree(node->left);
node->right=clean_NOT_intree(node->right); node->left = clean_NOT_intree(node->left);
if ( node->left == NULL && node->right == NULL ) { node->right = clean_NOT_intree(node->right);
if (node->left == NULL && node->right == NULL)
{
pfree(node); pfree(node);
res = NULL; res = NULL;
} else if ( node->left == NULL ) { }
else if (node->left == NULL)
{
res = node->right; res = node->right;
pfree(node); pfree(node);
} else if ( node->right == NULL ) { }
else if (node->right == NULL)
{
res = node->left; res = node->left;
pfree(node); pfree(node);
} }
@ -138,9 +168,11 @@ clean_NOT_intree( NODE* node ) {
return node; return node;
} }
ITEM* ITEM *
clean_NOT(ITEM* ptr, int4 *len) { clean_NOT(ITEM * ptr, int4 *len)
NODE *root = maketree( ptr ); {
NODE *root = maketree(ptr);
return plaintree(clean_NOT_intree(root), len); return plaintree(clean_NOT_intree(root), len);
} }
@ -152,61 +184,87 @@ clean_NOT(ITEM* ptr, int4 *len) {
* Clean query tree from values which is always in * Clean query tree from values which is always in
* text (stopword) * text (stopword)
*/ */
static NODE* static NODE *
clean_fakeval_intree( NODE* node, char *result ) { clean_fakeval_intree(NODE * node, char *result)
char lresult = V_UNKNOWN, rresult = V_UNKNOWN; {
if ( node->valnode->type == VAL ) char lresult = V_UNKNOWN,
rresult = V_UNKNOWN;
if (node->valnode->type == VAL)
return node; return node;
else if ( node->valnode->type == VALTRUE ) { else if (node->valnode->type == VALTRUE)
pfree( node ); {
pfree(node);
*result = V_TRUE; *result = V_TRUE;
return NULL; return NULL;
} }
if ( node->valnode->val == (int4)'!' ) { if (node->valnode->val == (int4) '!')
node->right = clean_fakeval_intree( node->right, &rresult ); {
if ( ! node->right ) { node->right = clean_fakeval_intree(node->right, &rresult);
*result = ( rresult == V_TRUE ) ? V_FALSE : V_TRUE; if (!node->right)
{
*result = (rresult == V_TRUE) ? V_FALSE : V_TRUE;
freetree(node); freetree(node);
return NULL; return NULL;
} }
} else if ( node->valnode->val == (int4)'|' ) { }
else if (node->valnode->val == (int4) '|')
{
NODE *res = node; NODE *res = node;
node->left =clean_fakeval_intree(node->left, &lresult);
node->right=clean_fakeval_intree(node->right,&rresult); node->left = clean_fakeval_intree(node->left, &lresult);
if ( lresult == V_TRUE || rresult == V_TRUE ) { node->right = clean_fakeval_intree(node->right, &rresult);
if (lresult == V_TRUE || rresult == V_TRUE)
{
freetree(node); freetree(node);
*result=V_TRUE; *result = V_TRUE;
return NULL; return NULL;
} else if ( lresult == V_FALSE && rresult == V_FALSE ) { }
else if (lresult == V_FALSE && rresult == V_FALSE)
{
freetree(node); freetree(node);
*result=V_FALSE; *result = V_FALSE;
return NULL; return NULL;
} else if ( lresult == V_FALSE ) { }
else if (lresult == V_FALSE)
{
res = node->right; res = node->right;
pfree(node); pfree(node);
} else if ( rresult == V_FALSE ) { }
else if (rresult == V_FALSE)
{
res = node->left; res = node->left;
pfree(node); pfree(node);
} }
return res; return res;
} else { }
else
{
NODE *res = node; NODE *res = node;
node->left =clean_fakeval_intree(node->left, &lresult);
node->right=clean_fakeval_intree(node->right,&rresult); node->left = clean_fakeval_intree(node->left, &lresult);
if ( lresult == V_FALSE || rresult == V_FALSE ) { node->right = clean_fakeval_intree(node->right, &rresult);
if (lresult == V_FALSE || rresult == V_FALSE)
{
freetree(node); freetree(node);
*result=V_FALSE; *result = V_FALSE;
return NULL; return NULL;
} else if ( lresult == V_TRUE && rresult == V_TRUE ) { }
else if (lresult == V_TRUE && rresult == V_TRUE)
{
freetree(node); freetree(node);
*result=V_TRUE; *result = V_TRUE;
return NULL; return NULL;
} else if ( lresult == V_TRUE ) { }
else if (lresult == V_TRUE)
{
res = node->right; res = node->right;
pfree(node); pfree(node);
} else if ( rresult == V_TRUE ) { }
else if (rresult == V_TRUE)
{
res = node->left; res = node->left;
pfree(node); pfree(node);
} }
@ -215,20 +273,20 @@ clean_fakeval_intree( NODE* node, char *result ) {
return node; return node;
} }
ITEM* ITEM *
clean_fakeval(ITEM* ptr, int4 *len) { clean_fakeval(ITEM * ptr, int4 *len)
NODE *root = maketree( ptr ); {
NODE *root = maketree(ptr);
char result = V_UNKNOWN; char result = V_UNKNOWN;
NODE *resroot; NODE *resroot;
resroot = clean_fakeval_intree(root, &result); resroot = clean_fakeval_intree(root, &result);
if ( result != V_UNKNOWN ) { if (result != V_UNKNOWN)
elog(ERROR,"Your query contained only stopword(s), ignored"); {
elog(ERROR, "Your query contained only stopword(s), ignored");
*len = 0; *len = 0;
return NULL; return NULL;
} }
return plaintree(resroot, len); return plaintree(resroot, len);
} }

5
contrib/tsearch/rewrite.h
View File

@ -1,7 +1,6 @@
#ifndef __REWRITE_H__ #ifndef __REWRITE_H__
#define __REWRITE_H__ #define __REWRITE_H__
ITEM* clean_NOT(ITEM* ptr, int4 *len); ITEM *clean_NOT(ITEM * ptr, int4 *len);
ITEM* clean_fakeval(ITEM* ptr, int4 *len); ITEM *clean_fakeval(ITEM * ptr, int4 *len);
#endif #endif

427
contrib/tsearch/txtidx.c
View File

@ -28,6 +28,7 @@
PG_FUNCTION_INFO_V1(txtidx_in); PG_FUNCTION_INFO_V1(txtidx_in);
Datum txtidx_in(PG_FUNCTION_ARGS); Datum txtidx_in(PG_FUNCTION_ARGS);
PG_FUNCTION_INFO_V1(txtidx_out); PG_FUNCTION_INFO_V1(txtidx_out);
Datum txtidx_out(PG_FUNCTION_ARGS); Datum txtidx_out(PG_FUNCTION_ARGS);
@ -45,33 +46,39 @@ Datum txtidxsize(PG_FUNCTION_ARGS);
*/ */
static char *BufferStr; static char *BufferStr;
static int static int
compareentry( const void * a, const void * b ) { compareentry(const void *a, const void *b)
if ( ((WordEntry*)a)->len == ((WordEntry*)b)->len ) { {
if (((WordEntry *) a)->len == ((WordEntry *) b)->len)
{
return strncmp( return strncmp(
&BufferStr[((WordEntry*)a)->pos], &BufferStr[((WordEntry *) a)->pos],
&BufferStr[((WordEntry*)b)->pos], &BufferStr[((WordEntry *) b)->pos],
((WordEntry*)b)->len ); ((WordEntry *) b)->len);
} }
return ( ((WordEntry*)a)->len > ((WordEntry*)b)->len ) ? 1 : -1; return (((WordEntry *) a)->len > ((WordEntry *) b)->len) ? 1 : -1;
} }
static int static int
uniqueentry( WordEntry* a, int4 l, char *buf, int4 *outbuflen ) { uniqueentry(WordEntry * a, int4 l, char *buf, int4 *outbuflen)
WordEntry *ptr, *res; {
WordEntry *ptr,
*res;
res = a; res = a;
*outbuflen = res->len; *outbuflen = res->len;
if ( l == 1 ) if (l == 1)
return l; return l;
ptr = a+1; ptr = a + 1;
BufferStr = buf; BufferStr = buf;
qsort((void*)a, l, sizeof(int4), compareentry ); qsort((void *) a, l, sizeof(int4), compareentry);
*outbuflen = res->len; *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 ) ) { if (!(ptr->len == res->len &&
strncmp(&buf[ptr->pos], &buf[res->pos], res->len) == 0))
{
res++; res++;
res->len = ptr->len; res->len = ptr->len;
res->pos = ptr->pos; res->pos = ptr->pos;
@ -100,73 +107,97 @@ do { \
} while (0) } while (0)
int4 int4
gettoken_txtidx( TI_IN_STATE *state ) { gettoken_txtidx(TI_IN_STATE * state)
{
int4 oldstate = 0; int4 oldstate = 0;
state->curpos = state->word; state->curpos = state->word;
state->state = WAITWORD; state->state = WAITWORD;
while( 1 ) { while (1)
if ( state->state == WAITWORD ) { {
if ( *(state->prsbuf) == '\0' ) { if (state->state == WAITWORD)
{
if (*(state->prsbuf) == '\0')
return 0; return 0;
} else if ( *(state->prsbuf) == '\'' ) { else if (*(state->prsbuf) == '\'')
state->state = WAITENDCMPLX; state->state = WAITENDCMPLX;
} else if ( *(state->prsbuf) == '\\' ) { else if (*(state->prsbuf) == '\\')
{
state->state = WAITNEXTCHAR; state->state = WAITNEXTCHAR;
oldstate = WAITENDWORD; oldstate = WAITENDWORD;
} else if ( state->oprisdelim && ISOPERATOR( *(state->prsbuf) ) ) { }
else if (state->oprisdelim && ISOPERATOR(*(state->prsbuf)))
elog(ERROR, "Syntax error"); elog(ERROR, "Syntax error");
} else if ( *(state->prsbuf) != ' ' ) { else if (*(state->prsbuf) != ' ')
{
*(state->curpos) = *(state->prsbuf); *(state->curpos) = *(state->prsbuf);
state->curpos++; state->curpos++;
state->state = WAITENDWORD; state->state = WAITENDWORD;
} }
} else if ( state->state == WAITNEXTCHAR ) { }
if ( *(state->prsbuf) == '\0' ) { else if (state->state == WAITNEXTCHAR)
elog(ERROR,"There is no escaped character"); {
} else { if (*(state->prsbuf) == '\0')
elog(ERROR, "There is no escaped character");
else
{
RESIZEPRSBUF; RESIZEPRSBUF;
*(state->curpos) = *(state->prsbuf); *(state->curpos) = *(state->prsbuf);
state->curpos++; state->curpos++;
state->state = oldstate; state->state = oldstate;
} }
} else if ( state->state == WAITENDWORD ) { }
if ( *(state->prsbuf) == '\\' ) { else if (state->state == WAITENDWORD)
{
if (*(state->prsbuf) == '\\')
{
state->state = WAITNEXTCHAR; state->state = WAITNEXTCHAR;
oldstate = WAITENDWORD; 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; RESIZEPRSBUF;
if ( state->curpos == state->word ) if (state->curpos == state->word)
elog(ERROR, "Syntax error"); elog(ERROR, "Syntax error");
*(state->curpos) = '\0'; *(state->curpos) = '\0';
return 1; return 1;
} else { }
else
{
RESIZEPRSBUF; RESIZEPRSBUF;
*(state->curpos) = *(state->prsbuf); *(state->curpos) = *(state->prsbuf);
state->curpos++; state->curpos++;
} }
} else if ( state->state == WAITENDCMPLX ) { }
if ( *(state->prsbuf) == '\'' ) { else if (state->state == WAITENDCMPLX)
{
if (*(state->prsbuf) == '\'')
{
RESIZEPRSBUF; RESIZEPRSBUF;
*(state->curpos) = '\0'; *(state->curpos) = '\0';
if ( state->curpos == state->word ) if (state->curpos == state->word)
elog(ERROR, "Syntax error"); elog(ERROR, "Syntax error");
state->prsbuf++; state->prsbuf++;
return 1; return 1;
} else if ( *(state->prsbuf) == '\\' ) { }
else if (*(state->prsbuf) == '\\')
{
state->state = WAITNEXTCHAR; state->state = WAITNEXTCHAR;
oldstate = WAITENDCMPLX; oldstate = WAITENDCMPLX;
} else if ( *(state->prsbuf) == '\0' ) { }
elog(ERROR,"Syntax error"); else if (*(state->prsbuf) == '\0')
} else { elog(ERROR, "Syntax error");
else
{
RESIZEPRSBUF; RESIZEPRSBUF;
*(state->curpos) = *(state->prsbuf); *(state->curpos) = *(state->prsbuf);
state->curpos++; state->curpos++;
} }
} else {
elog(ERROR, "Inner bug :(");
} }
else
elog(ERROR, "Inner bug :(");
state->prsbuf++; state->prsbuf++;
} }
@ -174,92 +205,111 @@ gettoken_txtidx( TI_IN_STATE *state ) {
} }
Datum Datum
txtidx_in(PG_FUNCTION_ARGS) { txtidx_in(PG_FUNCTION_ARGS)
char *buf = (char*)PG_GETARG_POINTER(0); {
char *buf = (char *) PG_GETARG_POINTER(0);
TI_IN_STATE state; TI_IN_STATE state;
WordEntry *arr; WordEntry *arr;
int4 len=0, totallen = 64; int4 len = 0,
totallen = 64;
txtidx *in; txtidx *in;
char *tmpbuf, *cur; char *tmpbuf,
int4 i,buflen = 256; *cur;
int4 i,
buflen = 256;
state.prsbuf = buf; state.prsbuf = buf;
state.len=32; state.len = 32;
state.word = (char*)palloc( state.len ); state.word = (char *) palloc(state.len);
state.oprisdelim = false; state.oprisdelim = false;
arr = (WordEntry*)palloc( sizeof(WordEntry) * totallen ); arr = (WordEntry *) palloc(sizeof(WordEntry) * totallen);
cur = tmpbuf = (char*)palloc( buflen ); cur = tmpbuf = (char *) palloc(buflen);
while( gettoken_txtidx( &state ) ) { while (gettoken_txtidx(&state))
if ( len == totallen ) { {
if (len == totallen)
{
totallen *= 2; totallen *= 2;
arr = (WordEntry*)repalloc( (void*)arr, sizeof(int4)*totallen ); 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; {
int4 dist = cur - tmpbuf;
buflen *= 2; buflen *= 2;
tmpbuf = (char*)repalloc( (void*)tmpbuf, buflen ); tmpbuf = (char *) repalloc((void *) tmpbuf, buflen);
cur = tmpbuf+dist; cur = tmpbuf + dist;
} }
if ( state.curpos - state.word > 0xffff ) if (state.curpos - state.word > 0xffff)
elog(ERROR,"Word is too long"); elog(ERROR, "Word is too long");
arr[len].len = state.curpos - state.word; arr[len].len = state.curpos - state.word;
if ( cur - tmpbuf > 0xffff ) if (cur - tmpbuf > 0xffff)
elog(ERROR,"Too long value"); elog(ERROR, "Too long value");
arr[len].pos = cur - tmpbuf; arr[len].pos = cur - tmpbuf;
memcpy( (void*)cur, (void*)state.word, arr[len].len ); memcpy((void *) cur, (void *) state.word, arr[len].len);
cur += arr[len].len; cur += arr[len].len;
len++; len++;
} }
pfree(state.word); pfree(state.word);
if ( !len ) if (!len)
elog(ERROR,"Void value"); elog(ERROR, "Void value");
len = uniqueentry( arr, len, tmpbuf, &buflen ); len = uniqueentry(arr, len, tmpbuf, &buflen);
totallen = CALCDATASIZE( len, buflen ); totallen = CALCDATASIZE(len, buflen);
in = (txtidx*)palloc( totallen ); in = (txtidx *) palloc(totallen);
in->len = totallen; in->len = totallen;
in->size = len; in->size = len;
cur = STRPTR(in); 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 ); {
memcpy((void *) cur, (void *) &tmpbuf[arr[i].pos], arr[i].len);
arr[i].pos = cur - STRPTR(in); arr[i].pos = cur - STRPTR(in);
cur += arr[i].len; cur += arr[i].len;
} }
pfree(tmpbuf); pfree(tmpbuf);
memcpy( (void*)ARRPTR(in), (void*)arr, sizeof(int4)*len ); memcpy((void *) ARRPTR(in), (void *) arr, sizeof(int4) * len);
pfree( arr ); pfree(arr);
PG_RETURN_POINTER( in ); PG_RETURN_POINTER(in);
} }
Datum Datum
txtidxsize(PG_FUNCTION_ARGS) { txtidxsize(PG_FUNCTION_ARGS)
txtidx *in=(txtidx*)DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0))); {
txtidx *in = (txtidx *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0)));
int4 ret = in->size; int4 ret = in->size;
PG_FREE_IF_COPY(in,0);
PG_RETURN_INT32( ret ); PG_FREE_IF_COPY(in, 0);
PG_RETURN_INT32(ret);
} }
Datum Datum
txtidx_out(PG_FUNCTION_ARGS) { txtidx_out(PG_FUNCTION_ARGS)
txtidx *out=(txtidx*)DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0))); {
txtidx *out = (txtidx *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0)));
char *outbuf; 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); WordEntry *ptr = ARRPTR(out);
char *curin, *curout; char *curin,
*curout;
curout = outbuf = (char*) palloc( lenbuf ); curout = outbuf = (char *) palloc(lenbuf);
for(i=0;i<out->size;i++) { for (i = 0; i < out->size; i++)
{
curin = STRPTR(out) + ptr->pos; curin = STRPTR(out) + ptr->pos;
if ( i!= 0 ) if (i != 0)
*curout++ = ' '; *curout++ = ' ';
*curout++ = '\''; *curout++ = '\'';
j = ptr->len; j = ptr->len;
while( j-- ) { while (j--)
if ( *curin == '\'' ) { {
if (*curin == '\'')
{
int4 pos = curout - outbuf; int4 pos = curout - outbuf;
outbuf = (char*)repalloc((void*)outbuf, ++lenbuf );
outbuf = (char *) repalloc((void *) outbuf, ++lenbuf);
curout = outbuf + pos; curout = outbuf + pos;
*curout++ = '\\'; *curout++ = '\\';
} }
@ -268,17 +318,19 @@ txtidx_out(PG_FUNCTION_ARGS) {
*curout++ = '\''; *curout++ = '\'';
ptr++; ptr++;
} }
outbuf[ lenbuf-1 ] = '\0'; outbuf[lenbuf - 1] = '\0';
PG_FREE_IF_COPY(out,0); PG_FREE_IF_COPY(out, 0);
PG_RETURN_POINTER( outbuf ); PG_RETURN_POINTER(outbuf);
} }
typedef struct { typedef struct
{
uint16 len; uint16 len;
char* word; char *word;
} WORD; } WORD;
typedef struct { typedef struct
{
WORD *words; WORD *words;
int4 lenwords; int4 lenwords;
int4 curwords; int4 curwords;
@ -288,38 +340,49 @@ typedef struct {
* Parse text to lexems * Parse text to lexems
*/ */
static void static void
parsetext( PRSTEXT *prs, char *buf, int4 buflen ) { parsetext(PRSTEXT * prs, char *buf, int4 buflen)
int type,lenlemm; {
char *ptr,*ptrw; int type,
lenlemm;
char *ptr,
*ptrw;
char *lemm; char *lemm;
start_parse_str( buf, buflen ); start_parse_str(buf, buflen);
while( (type=tsearch_yylex()) != 0 ) { while ((type = tsearch_yylex()) != 0)
if ( prs->curwords == prs->lenwords ) { {
if (prs->curwords == prs->lenwords)
{
prs->lenwords *= 2; prs->lenwords *= 2;
prs->words = (WORD*)repalloc( (void*)prs->words, prs->lenwords * sizeof(WORD) ); prs->words = (WORD *) repalloc((void *) prs->words, prs->lenwords * sizeof(WORD));
} }
if ( tokenlen>0xffff ) { if (tokenlen > 0xffff)
{
end_parse(); end_parse();
elog(ERROR, "Word is too long"); elog(ERROR, "Word is too long");
} }
lenlemm = tokenlen; lenlemm = tokenlen;
lemm = lemmatize( token, &lenlemm, type ); lemm = lemmatize(token, &lenlemm, type);
if ( ! lemm ) if (!lemm)
continue; continue;
if ( lemm != token ) { if (lemm != token)
prs->words[ prs->curwords ].len = lenlemm; {
prs->words[ prs->curwords ].word = lemm; prs->words[prs->curwords].len = lenlemm;
} else { prs->words[prs->curwords].word = lemm;
prs->words[ prs->curwords ].len = lenlemm; }
ptrw = prs->words[ prs->curwords ].word = (char*)palloc( lenlemm ); else
{
prs->words[prs->curwords].len = lenlemm;
ptrw = prs->words[prs->curwords].word = (char *) palloc(lenlemm);
ptr = token; ptr = token;
while( ptr-token < lenlemm ) { while (ptr - token < lenlemm)
*ptrw = tolower( (unsigned char) *ptr ); {
ptr++; ptrw++; *ptrw = tolower((unsigned char) *ptr);
ptr++;
ptrw++;
} }
} }
prs->curwords++; prs->curwords++;
@ -328,36 +391,41 @@ parsetext( PRSTEXT *prs, char *buf, int4 buflen ) {
} }
static int static int
compareWORD( const void * a, const void * b ) { compareWORD(const void *a, const void *b)
if ( ((WORD*)a)->len == ((WORD*)b)->len ) {
if (((WORD *) a)->len == ((WORD *) b)->len)
return strncmp( return strncmp(
((WORD*)a)->word, ((WORD *) a)->word,
((WORD*)b)->word, ((WORD *) b)->word,
((WORD*)b)->len ); ((WORD *) b)->len);
return ( ((WORD*)a)->len > ((WORD*)b)->len ) ? 1 : -1; return (((WORD *) a)->len > ((WORD *) b)->len) ? 1 : -1;
} }
static int static int
uniqueWORD( WORD* a, int4 l ) { uniqueWORD(WORD * a, int4 l)
WORD *ptr, *res; {
WORD *ptr,
*res;
if ( l == 1 ) if (l == 1)
return l; return l;
res = a; res = a;
ptr = a + 1; ptr = a + 1;
qsort((void*)a, l, sizeof(WORD), compareWORD ); 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 ) ) { if (!(ptr->len == res->len &&
strncmp(ptr->word, res->word, res->len) == 0))
{
res++; res++;
res->len = ptr->len; res->len = ptr->len;
res->word = ptr->word; res->word = ptr->word;
} else {
pfree(ptr->word);
} }
else
pfree(ptr->word);
ptr++; ptr++;
} }
@ -368,30 +436,35 @@ uniqueWORD( WORD* a, int4 l ) {
* make value of txtidx * make value of txtidx
*/ */
static txtidx * static txtidx *
makevalue( PRSTEXT *prs ) { makevalue(PRSTEXT * prs)
int4 i, lenstr=0, totallen; {
int4 i,
lenstr = 0,
totallen;
txtidx *in; txtidx *in;
WordEntry *ptr; WordEntry *ptr;
char *str,*cur; char *str,
*cur;
prs->curwords = uniqueWORD( prs->words, prs->curwords ); prs->curwords = uniqueWORD(prs->words, prs->curwords);
for(i=0;i<prs->curwords;i++) for (i = 0; i < prs->curwords; i++)
lenstr += prs->words[i].len; lenstr += prs->words[i].len;
totallen = CALCDATASIZE( prs->curwords, lenstr ); totallen = CALCDATASIZE(prs->curwords, lenstr);
in = (txtidx*)palloc( totallen ); in = (txtidx *) palloc(totallen);
in->len = totallen; in->len = totallen;
in->size = prs->curwords; in->size = prs->curwords;
ptr = ARRPTR(in); ptr = ARRPTR(in);
cur = str = STRPTR(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; ptr->len = prs->words[i].len;
if ( cur-str > 0xffff ) if (cur - str > 0xffff)
elog(ERROR,"Value is too big"); elog(ERROR, "Value is too big");
ptr->pos = cur-str; ptr->pos = cur - str;
ptr++; ptr++;
memcpy( (void*)cur, (void*)prs->words[i].word, prs->words[i].len ); memcpy((void *) cur, (void *) prs->words[i].word, prs->words[i].len);
pfree(prs->words[i].word); pfree(prs->words[i].word);
cur += prs->words[i].len; cur += prs->words[i].len;
} }
@ -400,22 +473,24 @@ makevalue( PRSTEXT *prs ) {
} }
Datum Datum
txt2txtidx(PG_FUNCTION_ARGS) { txt2txtidx(PG_FUNCTION_ARGS)
text *in = (text*)DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0))); {
text *in = (text *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0)));
PRSTEXT prs; PRSTEXT prs;
txtidx *out = NULL; txtidx *out = NULL;
prs.lenwords = 32; prs.lenwords = 32;
prs.curwords = 0; prs.curwords = 0;
prs.words = (WORD*)palloc(sizeof(WORD)*prs.lenwords); prs.words = (WORD *) palloc(sizeof(WORD) * prs.lenwords);
initmorph(); initmorph();
parsetext( &prs, VARDATA(in), VARSIZE(in) - VARHDRSZ ); parsetext(&prs, VARDATA(in), VARSIZE(in) - VARHDRSZ);
PG_FREE_IF_COPY(in,0); PG_FREE_IF_COPY(in, 0);
if ( prs.curwords ) { if (prs.curwords)
out = makevalue( &prs ); {
PG_RETURN_POINTER( out ); out = makevalue(&prs);
PG_RETURN_POINTER(out);
} }
pfree(prs.words); pfree(prs.words);
PG_RETURN_NULL(); PG_RETURN_NULL();
@ -425,14 +500,16 @@ txt2txtidx(PG_FUNCTION_ARGS) {
* Trigger * Trigger
*/ */
Datum Datum
tsearch(PG_FUNCTION_ARGS) { tsearch(PG_FUNCTION_ARGS)
{
TriggerData *trigdata; TriggerData *trigdata;
Trigger *trigger; Trigger *trigger;
Relation rel; Relation rel;
HeapTuple rettuple = NULL; HeapTuple rettuple = NULL;
int numidxattr,i; int numidxattr,
i;
PRSTEXT prs; PRSTEXT prs;
Datum datum = (Datum)0; Datum datum = (Datum) 0;
if (!CALLED_AS_TRIGGER(fcinfo)) if (!CALLED_AS_TRIGGER(fcinfo))
@ -454,57 +531,63 @@ tsearch(PG_FUNCTION_ARGS) {
trigger = trigdata->tg_trigger; trigger = trigdata->tg_trigger;
rel = trigdata->tg_relation; rel = trigdata->tg_relation;
if ( trigger->tgnargs < 2 ) if (trigger->tgnargs < 2)
elog(ERROR,"TSearch: format tsearch(txtidx_field, text_field1,...)"); elog(ERROR, "TSearch: format tsearch(txtidx_field, text_field1,...)");
numidxattr = SPI_fnumber(rel->rd_att, trigger->tgargs[0]); numidxattr = SPI_fnumber(rel->rd_att, trigger->tgargs[0]);
if ( numidxattr < 0 ) if (numidxattr < 0)
elog(ERROR,"TSearch: Can not find txtidx_field"); elog(ERROR, "TSearch: Can not find txtidx_field");
prs.lenwords = 32; prs.lenwords = 32;
prs.curwords = 0; prs.curwords = 0;
prs.words = (WORD*)palloc(sizeof(WORD)*prs.lenwords); prs.words = (WORD *) palloc(sizeof(WORD) * prs.lenwords);
initmorph(); initmorph();
/* find all words in indexable column */ /* find all words in indexable column */
for(i=1; i<trigger->tgnargs; i++) { for (i = 1; i < trigger->tgnargs; i++)
{
int4 numattr; int4 numattr;
text *txt_toasted, *txt; text *txt_toasted,
*txt;
bool isnull; bool isnull;
Oid oidtype; Oid oidtype;
numattr = SPI_fnumber(rel->rd_att, trigger->tgargs[i]); numattr = SPI_fnumber(rel->rd_att, trigger->tgargs[i]);
oidtype = SPI_gettypeid(rel->rd_att, numattr); 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]); elog(NOTICE, "TSearch: can not find field '%s'", trigger->tgargs[i]);
continue; continue;
} }
txt_toasted = (text*)DatumGetPointer( SPI_getbinval(rettuple, rel->rd_att, numattr, &isnull ) ); txt_toasted = (text *) DatumGetPointer(SPI_getbinval(rettuple, rel->rd_att, numattr, &isnull));
if ( isnull ) if (isnull)
continue; continue;
txt = (text*)DatumGetPointer( PG_DETOAST_DATUM( PointerGetDatum ( txt_toasted ) ) ); txt = (text *) DatumGetPointer(PG_DETOAST_DATUM(PointerGetDatum(txt_toasted)));
parsetext( &prs, VARDATA(txt), VARSIZE(txt) - VARHDRSZ ); parsetext(&prs, VARDATA(txt), VARSIZE(txt) - VARHDRSZ);
if ( txt != txt_toasted ) if (txt != txt_toasted)
pfree(txt); pfree(txt);
} }
/* make txtidx value */ /* make txtidx value */
if (prs.curwords) { if (prs.curwords)
datum = PointerGetDatum( makevalue( &prs ) ); {
rettuple = SPI_modifytuple( rel, rettuple, 1, &numidxattr, datum = PointerGetDatum(makevalue(&prs));
&datum, NULL ); rettuple = SPI_modifytuple(rel, rettuple, 1, &numidxattr,
&datum, NULL);
pfree(DatumGetPointer(datum)); pfree(DatumGetPointer(datum));
} else { }
else
{
char nulls = 'n'; char nulls = 'n';
pfree( prs.words );
rettuple = SPI_modifytuple( rel, rettuple, 1, &numidxattr, pfree(prs.words);
&datum, &nulls ); rettuple = SPI_modifytuple(rel, rettuple, 1, &numidxattr,
&datum, &nulls);
} }
if (rettuple == NULL) if (rettuple == NULL)
elog(ERROR, "TSearch: %d returned by SPI_modifytuple", SPI_result); elog(ERROR, "TSearch: %d returned by SPI_modifytuple", SPI_result);
return PointerGetDatum( rettuple ); return PointerGetDatum(rettuple);
} }

13
contrib/tsearch/txtidx.h
View File

@ -14,12 +14,14 @@
#include "utils/builtins.h" #include "utils/builtins.h"
#include "storage/bufpage.h" #include "storage/bufpage.h"
typedef struct { typedef struct
{
uint16 len; uint16 len;
uint16 pos; uint16 pos;
} WordEntry; } WordEntry;
typedef struct { typedef struct
{
int4 len; int4 len;
int4 size; int4 size;
char data[1]; char data[1];
@ -31,7 +33,8 @@ typedef struct {
#define STRPTR(x) ( (char*)x + DATAHDRSIZE + ( sizeof(WordEntry) * ((txtidx*)x)->size ) ) #define STRPTR(x) ( (char*)x + DATAHDRSIZE + ( sizeof(WordEntry) * ((txtidx*)x)->size ) )
#define STRSIZE(x) ( ((txtidx*)x)->len - 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 *prsbuf;
char *word; char *word;
char *curpos; char *curpos;
@ -40,7 +43,5 @@ typedef struct {
bool oprisdelim; bool oprisdelim;
} TI_IN_STATE; } TI_IN_STATE;
int4 gettoken_txtidx( TI_IN_STATE *state ); int4 gettoken_txtidx(TI_IN_STATE * state);
#endif #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_lock_oid(Oid oid);
int user_write_unlock_oid(Oid oid); int user_write_unlock_oid(Oid oid);
int user_unlock_all(void); int user_unlock_all(void);
#endif #endif
/* /*

241
contrib/xml/pgxml.c
View File

@ -14,32 +14,39 @@ XML_Memory_Handling_Suite mhs;
/* passthrough functions (palloc is a macro) */ /* passthrough functions (palloc is a macro) */
static void *pgxml_palloc(size_t size) static void *
pgxml_palloc(size_t size)
{ {
return palloc(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); return repalloc(ptr, size);
} }
static void pgxml_pfree(void *ptr) static void
pgxml_pfree(void *ptr)
{ {
return pfree(ptr); return pfree(ptr);
} }
static void pgxml_mhs_init() static void
pgxml_mhs_init()
{ {
mhs.malloc_fcn = pgxml_palloc; mhs.malloc_fcn = pgxml_palloc;
mhs.realloc_fcn = pgxml_repalloc; mhs.realloc_fcn = pgxml_repalloc;
mhs.free_fcn = pgxml_pfree; 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 */ /* Returns true if document is well-formed */
@ -51,23 +58,27 @@ pgxml_parse(PG_FUNCTION_ARGS)
{ {
/* called as pgxml_parse(document) */ /* called as pgxml_parse(document) */
XML_Parser p; XML_Parser p;
text *t = PG_GETARG_TEXT_P(0); /*document buffer */ text *t = PG_GETARG_TEXT_P(0); /* document buffer */
int32 docsize = VARSIZE(t) - VARHDRSZ; int32 docsize = VARSIZE(t) - VARHDRSZ;
pgxml_mhs_init(); pgxml_mhs_init();
pgxml_handler_init(); pgxml_handler_init();
p = XML_ParserCreate_MM(NULL,&mhs,NULL); p = XML_ParserCreate_MM(NULL, &mhs, NULL);
if (! p) { if (!p)
{
elog(ERROR, "pgxml: Could not create expat parser"); elog(ERROR, "pgxml: Could not create expat parser");
PG_RETURN_NULL(); /* seems appropriate if we couldn't parse */ PG_RETURN_NULL(); /* seems appropriate if we couldn't parse */
} }
if (! XML_Parse(p, (char *)VARDATA(t) , docsize, 1)) { 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))); */ * elog(NOTICE, "Parse error at line %d:%s",
* XML_GetCurrentLineNumber(p),
* XML_ErrorString(XML_GetErrorCode(p)));
*/
XML_ParserFree(p); XML_ParserFree(p);
PG_RETURN_BOOL(false); PG_RETURN_BOOL(false);
} }
@ -86,7 +97,8 @@ pgxml_parse(PG_FUNCTION_ARGS)
in various ways. 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; XPath_Results *xpr;
char *res; char *res;
@ -95,28 +107,28 @@ static XPath_Results *build_xpath_results(text *doc, text *pathstr)
int32 docsize; int32 docsize;
xpr = (XPath_Results *) palloc((sizeof(XPath_Results))); xpr = (XPath_Results *) palloc((sizeof(XPath_Results)));
memset((void *)xpr, 0, sizeof(XPath_Results)); memset((void *) xpr, 0, sizeof(XPath_Results));
xpr->rescount=0; xpr->rescount = 0;
docsize=VARSIZE(doc)-VARHDRSZ; docsize = VARSIZE(doc) - VARHDRSZ;
/* res isn't going to be the real return type, it is just a buffer */ /* res isn't going to be the real return type, it is just a buffer */
res = (char *) palloc(docsize); res = (char *) palloc(docsize);
memset((void *)res, 0, docsize); memset((void *) res, 0, docsize);
xpr->resbuf = res; xpr->resbuf = res;
udata = (pgxml_udata *) palloc((sizeof(pgxml_udata))); udata = (pgxml_udata *) palloc((sizeof(pgxml_udata)));
memset((void *)udata,0,sizeof(pgxml_udata)); memset((void *) udata, 0, sizeof(pgxml_udata));
udata->currentpath[0]='\0'; udata->currentpath[0] = '\0';
udata->textgrab=0; udata->textgrab = 0;
udata->path= (char *) palloc(VARSIZE(pathstr)); udata->path = (char *) palloc(VARSIZE(pathstr));
memcpy(udata->path, VARDATA(pathstr), VARSIZE(pathstr)-VARHDRSZ); memcpy(udata->path, VARDATA(pathstr), VARSIZE(pathstr) - VARHDRSZ);
udata->path[VARSIZE(pathstr)-VARHDRSZ]='\0'; udata->path[VARSIZE(pathstr) - VARHDRSZ] = '\0';
udata->resptr = res; udata->resptr = res;
udata->reslen = 0; udata->reslen = 0;
@ -126,8 +138,9 @@ static XPath_Results *build_xpath_results(text *doc, text *pathstr)
/* Now fire up the parser */ /* Now fire up the parser */
pgxml_mhs_init(); pgxml_mhs_init();
p = XML_ParserCreate_MM(NULL,&mhs,NULL); p = XML_ParserCreate_MM(NULL, &mhs, NULL);
if (! p) { if (!p)
{
elog(ERROR, "pgxml: Could not create expat parser"); elog(ERROR, "pgxml: Could not create expat parser");
pfree(xpr); pfree(xpr);
pfree(udata->path); pfree(udata->path);
@ -135,17 +148,20 @@ static XPath_Results *build_xpath_results(text *doc, text *pathstr)
pfree(res); pfree(res);
return NULL; return NULL;
} }
XML_SetUserData(p, (void *)udata); XML_SetUserData(p, (void *) udata);
/* Set the handlers */ /* Set the handlers */
XML_SetElementHandler(p, pgxml_starthandler, pgxml_endhandler); XML_SetElementHandler(p, pgxml_starthandler, pgxml_endhandler);
XML_SetCharacterDataHandler(p, pgxml_charhandler); XML_SetCharacterDataHandler(p, pgxml_charhandler);
if (! XML_Parse(p, (char *)VARDATA(doc) , docsize, 1)) { 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))); */ * elog(NOTICE, "Parse error at line %d:%s",
* XML_GetCurrentLineNumber(p),
* XML_ErrorString(XML_GetErrorCode(p)));
*/
XML_ParserFree(p); XML_ParserFree(p);
pfree(xpr); pfree(xpr);
pfree(udata->path); pfree(udata->path);
@ -166,34 +182,32 @@ PG_FUNCTION_INFO_V1(pgxml_xpath);
Datum Datum
pgxml_xpath(PG_FUNCTION_ARGS) pgxml_xpath(PG_FUNCTION_ARGS)
{ {
/* called as pgxml_xpath(document,pathstr, index) for the moment*/ /* called as pgxml_xpath(document,pathstr, index) for the moment */
XPath_Results *xpresults; XPath_Results *xpresults;
text *restext; text *restext;
text *t = PG_GETARG_TEXT_P(0); /*document buffer */ text *t = PG_GETARG_TEXT_P(0); /* document buffer */
text *t2= PG_GETARG_TEXT_P(1); text *t2 = PG_GETARG_TEXT_P(1);
int32 ind = PG_GETARG_INT32(2) - 1; int32 ind = PG_GETARG_INT32(2) - 1;
xpresults = build_xpath_results(t,t2); 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) */ if (xpresults == NULL) /* parse error (not WF or parser failure) */
{
PG_RETURN_NULL(); PG_RETURN_NULL();
}
if (ind >= (xpresults->rescount)) if (ind >= (xpresults->rescount))
{
PG_RETURN_NULL(); PG_RETURN_NULL();
}
restext = (text *) palloc(xpresults->reslens[ind]+VARHDRSZ); restext = (text *) palloc(xpresults->reslens[ind] + VARHDRSZ);
memcpy(VARDATA(restext),xpresults->results[ind],xpresults->reslens[ind]); memcpy(VARDATA(restext), xpresults->results[ind], xpresults->reslens[ind]);
VARATT_SIZEP(restext) = xpresults->reslens[ind]+VARHDRSZ; VARATT_SIZEP(restext) = xpresults->reslens[ind] + VARHDRSZ;
pfree(xpresults->resbuf); pfree(xpresults->resbuf);
pfree(xpresults); pfree(xpresults);
@ -202,109 +216,132 @@ pgxml_xpath(PG_FUNCTION_ARGS)
} }
static void pgxml_pathcompare(void *userData) static void
pgxml_pathcompare(void *userData)
{ {
char *matchpos; char *matchpos;
matchpos=strstr(UD->currentpath, UD->path); matchpos = strstr(UD->currentpath, UD->path);
if (matchpos == NULL) { /* Should we have more logic here ? */ if (matchpos == NULL)
if (UD->textgrab) { { /* Should we have more logic here ? */
UD->textgrab=0; if (UD->textgrab)
{
UD->textgrab = 0;
pgxml_finalisegrabbedtext(userData); pgxml_finalisegrabbedtext(userData);
} }
return; 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! */
if ((matchpos + strlen(UD->path))[0]=='\0') /*
* 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 ((UD->path)[0] == '/')
if (matchpos == UD->currentpath) { {
UD->textgrab=1; if (matchpos == UD->currentpath)
} UD->textgrab = 1;
} else {
if ((matchpos-1)[0]=='/') {
UD->textgrab=1;
} }
else
{
if ((matchpos - 1)[0] == '/')
UD->textgrab = 1;
} }
} }
} }
static void pgxml_starthandler(void *userData, const XML_Char *name, static void
const XML_Char **atts) pgxml_starthandler(void *userData, const XML_Char * name,
const XML_Char ** atts)
{ {
char sepstr[]="/"; char sepstr[] = "/";
if ((strlen(name)+strlen(UD->currentpath))>MAXPATHLENGTH-2) { if ((strlen(name) + strlen(UD->currentpath)) > MAXPATHLENGTH - 2)
elog(NOTICE,"Path too long"); elog(NOTICE, "Path too long");
} else { else
strncat(UD->currentpath,sepstr,1); {
strncat(UD->currentpath, sepstr, 1);
strcat(UD->currentpath, name); strcat(UD->currentpath, name);
} }
if (UD->textgrab) 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 {
pgxml_pathcompare(userData);
} }
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; char *sepptr;
sepptr=strrchr(UD->currentpath,'/'); sepptr = strrchr(UD->currentpath, '/');
if (sepptr==NULL) { if (sepptr == NULL)
elog(ERROR,"There's a problem..."); {
sepptr=UD->currentpath; 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); {
elog(NOTICE, "Wanted [%s], got [%s]", sepptr, name);
/* unmatched entry, so do nothing */ /* unmatched entry, so do nothing */
} else { }
sepptr[0]='\0'; /* Chop that element off the end */ else
{
sepptr[0] = '\0'; /* Chop that element off the end */
} }
if (UD->textgrab) { if (UD->textgrab)
pgxml_pathcompare(userData); 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 (UD->textgrab)
if (len>0) { {
memcpy(UD->resptr,s,len); if (len > 0)
{
memcpy(UD->resptr, s, len);
UD->resptr += len; UD->resptr += len;
UD->reslen += len; UD->reslen += len;
} }
} }
} }
/* Should I be using PG list types here? */ /* 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. */ /* In res/reslen, we have a single result. */
UD->xpres->results[UD->xpres->rescount]= UD->resptr - UD->reslen; UD->xpres->results[UD->xpres->rescount] = UD->resptr - UD->reslen;
UD->xpres->reslens[UD->xpres->rescount]= UD->reslen; UD->xpres->reslens[UD->xpres->rescount] = UD->reslen;
UD->reslen=0; UD->reslen = 0;
UD->xpres->rescount++; 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
*/
} }

34
contrib/xml/pgxml.h
View File

@ -7,10 +7,10 @@ static void pgxml_mhs_init();
static void pgxml_handler_init(); static void pgxml_handler_init();
Datum pgxml_parse(PG_FUNCTION_ARGS); Datum pgxml_parse(PG_FUNCTION_ARGS);
Datum pgxml_xpath(PG_FUNCTION_ARGS); Datum pgxml_xpath(PG_FUNCTION_ARGS);
static void pgxml_starthandler(void *userData, const XML_Char *name, static void pgxml_starthandler(void *userData, const XML_Char * name,
const XML_Char **atts); const XML_Char ** atts);
static void pgxml_endhandler(void *userData, const XML_Char *name); static void pgxml_endhandler(void *userData, const XML_Char * name);
static void pgxml_charhandler(void *userData, const XML_Char *s, int len); static void pgxml_charhandler(void *userData, const XML_Char * s, int len);
static void pgxml_pathcompare(void *userData); static void pgxml_pathcompare(void *userData);
static void pgxml_finalisegrabbedtext(void *userData); static void pgxml_finalisegrabbedtext(void *userData);
@ -18,7 +18,8 @@ static void pgxml_finalisegrabbedtext(void *userData);
#define MAXRESULTS 100 #define MAXRESULTS 100
typedef struct { typedef struct
{
int rescount; int rescount;
char *results[MAXRESULTS]; char *results[MAXRESULTS];
int32 reslens[MAXRESULTS]; int32 reslens[MAXRESULTS];
@ -27,7 +28,8 @@ typedef struct {
typedef struct { typedef struct
{
char currentpath[MAXPATHLENGTH]; char currentpath[MAXPATHLENGTH];
char *path; char *path;
int textgrab; int textgrab;
@ -38,23 +40,3 @@ typedef struct {
#define UD ((pgxml_udata *) userData) #define UD ((pgxml_udata *) userData)

150
contrib/xml/pgxml_dom.c
View File

@ -15,12 +15,12 @@
static void *pgxml_palloc(size_t size); static void *pgxml_palloc(size_t size);
static void *pgxml_repalloc(void *ptr, size_t size); static void *pgxml_repalloc(void *ptr, size_t size);
static void pgxml_pfree(void *ptr); static void pgxml_pfree(void *ptr);
static char *pgxml_pstrdup(const char* string); static char *pgxml_pstrdup(const char *string);
static void pgxml_parser_init(); static void pgxml_parser_init();
static xmlChar *pgxmlNodeSetToText(xmlNodeSetPtr nodeset, xmlDocPtr doc, static xmlChar *pgxmlNodeSetToText(xmlNodeSetPtr nodeset, xmlDocPtr doc,
xmlChar *toptagname, xmlChar *septagname, xmlChar * toptagname, xmlChar * septagname,
int format); int format);
static xmlChar *pgxml_texttoxmlchar(text *textstring); static xmlChar *pgxml_texttoxmlchar(text *textstring);
@ -32,30 +32,37 @@ Datum pgxml_xpath(PG_FUNCTION_ARGS);
/* memory handling passthrough functions (e.g. palloc, pstrdup are /* memory handling passthrough functions (e.g. palloc, pstrdup are
currently macros, and the others might become so...) */ 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); 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); return repalloc(ptr, size);
} }
static void pgxml_pfree(void *ptr) static void
pgxml_pfree(void *ptr)
{ {
return pfree(ptr); return pfree(ptr);
} }
static char *pgxml_pstrdup(const char *string) static char *
pgxml_pstrdup(const char *string)
{ {
return pstrdup(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); xmlMemSetup(pgxml_pfree, pgxml_palloc, pgxml_repalloc, pgxml_pstrdup);
xmlInitParser(); xmlInitParser();
@ -72,13 +79,14 @@ pgxml_parse(PG_FUNCTION_ARGS)
{ {
/* called as pgxml_parse(document) */ /* called as pgxml_parse(document) */
xmlDocPtr doctree; xmlDocPtr doctree;
text *t = PG_GETARG_TEXT_P(0); /*document buffer */ text *t = PG_GETARG_TEXT_P(0); /* document buffer */
int32 docsize = VARSIZE(t) - VARHDRSZ; int32 docsize = VARSIZE(t) - VARHDRSZ;
pgxml_parser_init(); pgxml_parser_init();
doctree = xmlParseMemory((char *) VARDATA(t), docsize); doctree = xmlParseMemory((char *) VARDATA(t), docsize);
if (doctree == NULL) { if (doctree == NULL)
{
/* xmlCleanupParser(); */ /* xmlCleanupParser(); */
PG_RETURN_BOOL(false); /* i.e. not well-formed */ PG_RETURN_BOOL(false); /* i.e. not well-formed */
} }
@ -88,15 +96,19 @@ pgxml_parse(PG_FUNCTION_ARGS)
} }
static xmlChar static xmlChar
*pgxmlNodeSetToText(xmlNodeSetPtr nodeset, *
pgxmlNodeSetToText(xmlNodeSetPtr nodeset,
xmlDocPtr doc, xmlDocPtr doc,
xmlChar *toptagname, xmlChar * toptagname,
xmlChar *septagname, xmlChar * septagname,
int format) int format)
{ {
/* Function translates a nodeset into a text representation */ /* 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> */ /* each representation is surrounded by <tagname> ... </tagname> */
/* if format==0, add a newline between nodes?? */ /* if format==0, add a newline between nodes?? */
@ -104,51 +116,58 @@ static xmlChar
xmlChar *result; xmlChar *result;
int i; int i;
buf =xmlBufferCreate(); buf = xmlBufferCreate();
if ((toptagname != NULL) && (xmlStrlen(toptagname)>0)) { if ((toptagname != NULL) && (xmlStrlen(toptagname) > 0))
xmlBufferWriteChar(buf,"<"); {
xmlBufferWriteCHAR(buf,toptagname); xmlBufferWriteChar(buf, "<");
xmlBufferWriteChar(buf,">"); xmlBufferWriteCHAR(buf, toptagname);
xmlBufferWriteChar(buf, ">");
} }
if (nodeset != NULL) { if (nodeset != NULL)
for (i=0; i < nodeset->nodeNr; i++) { {
if ((septagname != NULL) && (xmlStrlen(septagname)>0)) { for (i = 0; i < nodeset->nodeNr; i++)
xmlBufferWriteChar(buf,"<"); {
xmlBufferWriteCHAR(buf,septagname); if ((septagname != NULL) && (xmlStrlen(septagname) > 0))
xmlBufferWriteChar(buf,">"); {
xmlBufferWriteChar(buf, "<");
xmlBufferWriteCHAR(buf, septagname);
xmlBufferWriteChar(buf, ">");
} }
xmlNodeDump(buf, doc, nodeset->nodeTab[i],1,(format==2)); 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, "</");
xmlBufferWriteChar(buf,">"); xmlBufferWriteCHAR(buf, septagname);
} xmlBufferWriteChar(buf, ">");
if (format) {
xmlBufferWriteChar(buf,"\n");
} }
if (format)
xmlBufferWriteChar(buf, "\n");
} }
} }
if ((toptagname != NULL) && (xmlStrlen(toptagname)>0)) { if ((toptagname != NULL) && (xmlStrlen(toptagname) > 0))
xmlBufferWriteChar(buf,"</"); {
xmlBufferWriteCHAR(buf,toptagname); xmlBufferWriteChar(buf, "</");
xmlBufferWriteChar(buf,">"); xmlBufferWriteCHAR(buf, toptagname);
xmlBufferWriteChar(buf, ">");
} }
result = xmlStrdup(buf->content); result = xmlStrdup(buf->content);
xmlBufferFree(buf); xmlBufferFree(buf);
return result; return result;
} }
static xmlChar *pgxml_texttoxmlchar(text *textstring) { static xmlChar *
pgxml_texttoxmlchar(text *textstring)
{
xmlChar *res; xmlChar *res;
int32 txsize; int32 txsize;
txsize=VARSIZE(textstring)-VARHDRSZ; txsize = VARSIZE(textstring) - VARHDRSZ;
res = (xmlChar *) palloc(txsize+1); res = (xmlChar *) palloc(txsize + 1);
memcpy((char *)res, VARDATA(textstring), txsize); memcpy((char *) res, VARDATA(textstring), txsize);
res[txsize]='\0'; res[txsize] = '\0';
return res; return res;
} }
@ -161,13 +180,18 @@ pgxml_xpath(PG_FUNCTION_ARGS)
xmlDocPtr doctree; xmlDocPtr doctree;
xmlXPathContextPtr ctxt; xmlXPathContextPtr ctxt;
xmlXPathObjectPtr res; xmlXPathObjectPtr res;
xmlChar *xpath, *xpresstr, *toptag, *septag; xmlChar *xpath,
*xpresstr,
*toptag,
*septag;
xmlXPathCompExprPtr comppath; xmlXPathCompExprPtr comppath;
int32 docsize,ressize; int32 docsize,
text *t, *xpres; ressize;
text *t,
*xpres;
t = PG_GETARG_TEXT_P(0); /*document buffer */ t = PG_GETARG_TEXT_P(0); /* document buffer */
xpath = pgxml_texttoxmlchar(PG_GETARG_TEXT_P(1)); /* XPath expression */ xpath = pgxml_texttoxmlchar(PG_GETARG_TEXT_P(1)); /* XPath expression */
toptag = pgxml_texttoxmlchar(PG_GETARG_TEXT_P(2)); toptag = pgxml_texttoxmlchar(PG_GETARG_TEXT_P(2));
septag = pgxml_texttoxmlchar(PG_GETARG_TEXT_P(3)); septag = pgxml_texttoxmlchar(PG_GETARG_TEXT_P(3));
@ -177,7 +201,8 @@ pgxml_xpath(PG_FUNCTION_ARGS)
pgxml_parser_init(); pgxml_parser_init();
doctree = xmlParseMemory((char *) VARDATA(t), docsize); doctree = xmlParseMemory((char *) VARDATA(t), docsize);
if (doctree == NULL) { /* not well-formed */ if (doctree == NULL)
{ /* not well-formed */
PG_RETURN_NULL(); PG_RETURN_NULL();
} }
@ -186,7 +211,8 @@ pgxml_xpath(PG_FUNCTION_ARGS)
/* compile the path */ /* compile the path */
comppath = xmlXPathCompile(xpath); comppath = xmlXPathCompile(xpath);
if (comppath == NULL) { if (comppath == NULL)
{
elog(NOTICE, "XPath syntax error"); elog(NOTICE, "XPath syntax error");
xmlFreeDoc(doctree); xmlFreeDoc(doctree);
pfree((void *) xpath); pfree((void *) xpath);
@ -194,17 +220,19 @@ pgxml_xpath(PG_FUNCTION_ARGS)
} }
/* Now evaluate the path expression. */ /* Now evaluate the path expression. */
res = xmlXPathCompiledEval(comppath,ctxt); res = xmlXPathCompiledEval(comppath, ctxt);
xmlXPathFreeCompExpr(comppath); xmlXPathFreeCompExpr(comppath);
if (res==NULL) { if (res == NULL)
{
xmlFreeDoc(doctree); xmlFreeDoc(doctree);
pfree((void *)xpath); pfree((void *) xpath);
PG_RETURN_NULL(); /* seems appropriate */ PG_RETURN_NULL(); /* seems appropriate */
} }
/* now we dump this node, ?surrounding by tags? */ /* now we dump this node, ?surrounding by tags? */
/* To do this, we look first at the type */ /* To do this, we look first at the type */
switch(res->type) { switch (res->type)
{
case XPATH_NODESET: case XPATH_NODESET:
xpresstr = pgxmlNodeSetToText(res->nodesetval, xpresstr = pgxmlNodeSetToText(res->nodesetval,
doctree, doctree,
@ -214,16 +242,16 @@ pgxml_xpath(PG_FUNCTION_ARGS)
xpresstr = xmlStrdup(res->stringval); xpresstr = xmlStrdup(res->stringval);
break; break;
default: default:
elog(NOTICE,"Unsupported XQuery result: %d",res->type); elog(NOTICE, "Unsupported XQuery result: %d", res->type);
xpresstr = xmlStrdup("<unsupported/>"); xpresstr = xmlStrdup("<unsupported/>");
} }
/* Now convert this result back to text */ /* Now convert this result back to text */
ressize = strlen(xpresstr); ressize = strlen(xpresstr);
xpres = (text *) palloc(ressize+VARHDRSZ); xpres = (text *) palloc(ressize + VARHDRSZ);
memcpy(VARDATA(xpres),xpresstr,ressize); memcpy(VARDATA(xpres), xpresstr, ressize);
VARATT_SIZEP(xpres)=ressize + VARHDRSZ; VARATT_SIZEP(xpres) = ressize + VARHDRSZ;
/* Free various storage */ /* Free various storage */
xmlFreeDoc(doctree); xmlFreeDoc(doctree);
@ -232,7 +260,3 @@ pgxml_xpath(PG_FUNCTION_ARGS)
PG_RETURN_TEXT_P(xpres); PG_RETURN_TEXT_P(xpres);
} }

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

@ -9,7 +9,7 @@
* *
* *
* IDENTIFICATION * 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 * NOTES
* The old interface functions have been converted to macros * The old interface functions have been converted to macros
@ -241,7 +241,6 @@ nocachegetattr(HeapTuple tuple,
} }
else else
{ {
/* /*
* there's a null somewhere in the tuple * there's a null somewhere in the tuple
*/ */
@ -347,7 +346,6 @@ nocachegetattr(HeapTuple tuple,
(HeapTupleNoNulls(tuple) || !att_isnull(j, bp)) && (HeapTupleNoNulls(tuple) || !att_isnull(j, bp)) &&
(HeapTupleAllFixed(tuple) || att[j]->attlen > 0)); j++) (HeapTupleAllFixed(tuple) || att[j]->attlen > 0)); j++)
{ {
/* /*
* Fix me when going to a machine with more than a four-byte * Fix me when going to a machine with more than a four-byte
* word! * word!
@ -546,7 +544,6 @@ heap_deformtuple(HeapTuple tuple,
nulls[i] = ' '; nulls[i] = ' ';
} }
} }
#endif #endif
/* ---------------- /* ----------------

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

@ -9,7 +9,7 @@
* *
* *
* IDENTIFICATION * 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 #ifdef TOAST_INDEX_HACK
Datum untoasted_value[INDEX_MAX_KEYS]; Datum untoasted_value[INDEX_MAX_KEYS];
bool untoasted_free[INDEX_MAX_KEYS]; bool untoasted_free[INDEX_MAX_KEYS];
#endif #endif
if (numberOfAttributes > INDEX_MAX_KEYS) if (numberOfAttributes > INDEX_MAX_KEYS)
@ -338,7 +337,6 @@ nocache_index_getattr(IndexTuple tup,
for (; j <= attnum; j++) for (; j <= attnum; j++)
{ {
/* /*
* Fix me when going to a machine with more than a four-byte * Fix me when going to a machine with more than a four-byte
* word! * word!

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

@ -9,7 +9,7 @@
* *
* *
* IDENTIFICATION * 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; continue;
if (OidIsValid(thisState->typoutput)) if (OidIsValid(thisState->typoutput))
{ {
/* /*
* If we have a toasted datum, forcibly detoast it here to * If we have a toasted datum, forcibly detoast it here to
* avoid memory leakage inside the type's output routine. * 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, if (getTypeOutputInfo(typeinfo->attrs[i]->atttypid,
&typoutput, &typelem, &typisvarlena)) &typoutput, &typelem, &typisvarlena))
{ {
/* /*
* If we have a toasted datum, forcibly detoast it here to * If we have a toasted datum, forcibly detoast it here to
* avoid memory leakage inside the type's output routine. * 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 */ /* send # of bytes, and opaque data */
if (thisState->typisvarlena) if (thisState->typisvarlena)
{ {
/* /*
* If we have a toasted datum, must detoast before sending. * If we have a toasted datum, must detoast before sending.
*/ */

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

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * 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 * NOTES
* some of the executor utility code such as "ExecTypeFromTL" should be * 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]; Form_pg_attribute attr2 = tupdesc2->attrs[i];
/* /*
* We do not need to check every single field here: we can disregard * We do not need to check every single field here: we can
* attrelid, attnum (it was used to place the row in the attrs array) * disregard attrelid, attnum (it was used to place the row in the
* and everything derived from the column datatype. * attrs array) and everything derived from the column datatype.
*/ */
if (strcmp(NameStr(attr1->attname), NameStr(attr2->attname)) != 0) if (strcmp(NameStr(attr1->attname), NameStr(attr2->attname)) != 0)
return false; return false;
@ -399,7 +399,6 @@ TupleDescInitEntry(TupleDesc desc,
0, 0, 0); 0, 0, 0);
if (!HeapTupleIsValid(tuple)) if (!HeapTupleIsValid(tuple))
{ {
/* /*
* here type info does not exist yet so we just fill the attribute * here type info does not exist yet so we just fill the attribute
* with dummy information and return false. * with dummy information and return false.
@ -585,7 +584,6 @@ BuildDescForRelation(List *schema, char *relname)
typenameTypeId(typename), typenameTypeId(typename),
atttypmod, attdim, attisset)) atttypmod, attdim, attisset))
{ {
/* /*
* if TupleDescInitEntry() fails, it means there is no type in * if TupleDescInitEntry() fails, it means there is no type in
* the system catalogs. So now we check if the type name * the system catalogs. So now we check if the type name

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

File diff suppressed because it is too large Load Diff

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

@ -8,7 +8,7 @@
* Portions Copyright (c) 1994, Regents of the University of California * Portions Copyright (c) 1994, Regents of the University of California
* *
* IDENTIFICATION * 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 $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -251,7 +251,7 @@ gistindex_keytest(IndexTuple tuple,
if (key[0].sk_flags & SK_ISNULL) if (key[0].sk_flags & SK_ISNULL)
return false; return false;
*/ */
gistdentryinit(giststate, key[0].sk_attno-1, &de, gistdentryinit(giststate, key[0].sk_attno - 1, &de,
datum, r, p, offset, datum, r, p, offset,
IndexTupleSize(tuple) - sizeof(IndexTupleData), IndexTupleSize(tuple) - sizeof(IndexTupleData),
FALSE, isNull); FALSE, isNull);
@ -271,9 +271,9 @@ gistindex_keytest(IndexTuple tuple,
ObjectIdGetDatum(key[0].sk_procedure)); ObjectIdGetDatum(key[0].sk_procedure));
} }
if ( de.key != datum && ! isAttByVal( giststate, key[0].sk_attno-1 ) ) if (de.key != datum && !isAttByVal(giststate, key[0].sk_attno - 1))
if ( DatumGetPointer(de.key) != NULL ) if (DatumGetPointer(de.key) != NULL)
pfree( DatumGetPointer(de.key) ); pfree(DatumGetPointer(de.key));
if (DatumGetBool(test) == !!(key[0].sk_flags & SK_NEGATE)) if (DatumGetBool(test) == !!(key[0].sk_flags & SK_NEGATE))
return false; return false;

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

@ -8,7 +8,7 @@
* Portions Copyright (c) 1994, Regents of the University of California * Portions Copyright (c) 1994, Regents of the University of California
* *
* IDENTIFICATION * 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 $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -112,7 +112,7 @@ gistrescan(PG_FUNCTION_ARGS)
s->keyData[i].sk_procedure s->keyData[i].sk_procedure
= RelationGetGISTStrategy(s->relation, s->keyData[i].sk_attno, = RelationGetGISTStrategy(s->relation, s->keyData[i].sk_attno,
s->keyData[i].sk_procedure); s->keyData[i].sk_procedure);
s->keyData[i].sk_func = p->giststate->consistentFn[s->keyData[i].sk_attno-1]; s->keyData[i].sk_func = p->giststate->consistentFn[s->keyData[i].sk_attno - 1];
} }
} }
else else
@ -143,7 +143,7 @@ gistrescan(PG_FUNCTION_ARGS)
s->keyData[i].sk_procedure s->keyData[i].sk_procedure
= RelationGetGISTStrategy(s->relation, s->keyData[i].sk_attno, = RelationGetGISTStrategy(s->relation, s->keyData[i].sk_attno,
s->keyData[i].sk_procedure); s->keyData[i].sk_procedure);
s->keyData[i].sk_func = p->giststate->consistentFn[s->keyData[i].sk_attno-1]; s->keyData[i].sk_func = p->giststate->consistentFn[s->keyData[i].sk_attno - 1];
} }
} }
@ -234,8 +234,8 @@ gistendscan(PG_FUNCTION_ARGS)
{ {
gistfreestack(p->s_stack); gistfreestack(p->s_stack);
gistfreestack(p->s_markstk); gistfreestack(p->s_markstk);
if ( p->giststate != NULL ) if (p->giststate != NULL)
freeGISTstate( p->giststate ); freeGISTstate(p->giststate);
pfree(s->opaque); pfree(s->opaque);
} }
@ -383,7 +383,6 @@ adjustiptr(IndexScanDesc s,
} }
else else
{ {
/* /*
* remember that we're before the current * remember that we're before the current
* tuple * tuple

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

@ -8,7 +8,7 @@
* Portions Copyright (c) 1994, Regents of the University of California * Portions Copyright (c) 1994, Regents of the University of California
* *
* IDENTIFICATION * 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, return (RelationInvokeStrategy(r, &GISTEvaluationData, attnum, s,
left, right)); left, right));
} }
#endif #endif

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

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

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

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * 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) while (PageGetFreeSpace(page) < itemsz)
{ {
/* /*
* no space on this page; check for an overflow page * no space on this page; check for an overflow page
*/ */
if (BlockNumberIsValid(pageopaque->hasho_nextblkno)) if (BlockNumberIsValid(pageopaque->hasho_nextblkno))
{ {
/* /*
* ovfl page exists; go get it. if it doesn't have room, * ovfl page exists; go get it. if it doesn't have room,
* we'll find out next pass through the loop test above. * we'll find out next pass through the loop test above.
@ -152,7 +150,6 @@ _hash_insertonpg(Relation rel,
} }
else else
{ {
/* /*
* we're at the end of the bucket chain and we haven't found a * we're at the end of the bucket chain and we haven't found a
* page with enough room. allocate a new overflow page. * page with enough room. allocate a new overflow page.
@ -184,7 +181,6 @@ _hash_insertonpg(Relation rel,
if (res != NULL) if (res != NULL)
{ {
/* /*
* Increment the number of keys in the table. We switch lock * Increment the number of keys in the table. We switch lock
* access type just for a moment to allow greater accessibility to * 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 * 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 * NOTES
* Overflow pages look like ordinary relation pages. * Overflow pages look like ordinary relation pages.
@ -208,7 +208,6 @@ _hash_getovfladdr(Relation rel, Buffer *metabufp)
} }
else else
{ {
/* /*
* Free_bit addresses the last used bit. Bump it to address the * Free_bit addresses the last used bit. Bump it to address the
* first available bit. * first available bit.

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

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * 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 * NOTES
* Postgres hash pages look like ordinary relation pages. The opaque * Postgres hash pages look like ordinary relation pages. The opaque
@ -532,7 +532,6 @@ _hash_splitpage(Relation rel,
_hash_relbuf(rel, obuf, HASH_WRITE); _hash_relbuf(rel, obuf, HASH_WRITE);
if (!BlockNumberIsValid(oblkno)) if (!BlockNumberIsValid(oblkno))
{ {
/* /*
* the old bucket is completely empty; of course, the new * the old bucket is completely empty; of course, the new
* bucket will be as well, but since it's a base bucket page * bucket will be as well, but since it's a base bucket page
@ -559,7 +558,6 @@ _hash_splitpage(Relation rel,
omaxoffnum = PageGetMaxOffsetNumber(opage); omaxoffnum = PageGetMaxOffsetNumber(opage);
for (;;) for (;;)
{ {
/* /*
* at each iteration through this loop, each of these variables * at each iteration through this loop, each of these variables
* should be up-to-date: obuf opage oopaque ooffnum omaxoffnum * should be up-to-date: obuf opage oopaque ooffnum omaxoffnum
@ -572,7 +570,6 @@ _hash_splitpage(Relation rel,
oblkno = oopaque->hasho_nextblkno; oblkno = oopaque->hasho_nextblkno;
if (BlockNumberIsValid(oblkno)) if (BlockNumberIsValid(oblkno))
{ {
/* /*
* we ran out of tuples on this particular page, but we * we ran out of tuples on this particular page, but we
* have more overflow pages; re-init values. * have more overflow pages; re-init values.
@ -594,7 +591,6 @@ _hash_splitpage(Relation rel,
} }
else else
{ {
/* /*
* we're at the end of the bucket chain, so now we're * we're at the end of the bucket chain, so now we're
* really done with everything. before quitting, call * really done with everything. before quitting, call
@ -618,7 +614,6 @@ _hash_splitpage(Relation rel,
if (bucket == nbucket) if (bucket == nbucket)
{ {
/* /*
* insert the tuple into the new bucket. if it doesn't fit on * 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 * the current page in the new bucket, we must allocate a new
@ -695,7 +690,6 @@ _hash_splitpage(Relation rel,
} }
else else
{ {
/* /*
* the tuple stays on this page. we didn't move anything, so * the tuple stays on this page. we didn't move anything, so
* we didn't delete anything and therefore we don't have to * 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 * 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 || if (scankey == (ScanKey) NULL ||
(keyDatum = scankey[0].sk_argument) == (Datum) NULL) (keyDatum = scankey[0].sk_argument) == (Datum) NULL)
{ {
/* /*
* If the scankey argument is NULL, all tuples will satisfy the * If the scankey argument is NULL, all tuples will satisfy the
* scan so we start the scan at the first bucket (bucket 0). * 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 * 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, (StrategyTransformMap) HTNegateCommute,
HTEvaluationExpressions HTEvaluationExpressions
}; };
#endif #endif
/* ---------------------------------------------------------------- /* ----------------------------------------------------------------
@ -68,7 +67,6 @@ _hash_getstrat(Relation rel,
return strat; return strat;
} }
#endif #endif
#ifdef NOT_USED #ifdef NOT_USED
@ -82,5 +80,4 @@ _hash_invokestrat(Relation rel,
return (RelationInvokeStrategy(rel, &HTEvaluationData, attno, strat, return (RelationInvokeStrategy(rel, &HTEvaluationData, attno, strat,
left, right)); left, right));
} }
#endif #endif

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

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * 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 * INTERFACE ROUTINES
@ -350,7 +350,7 @@ heapgettup(Relation relation,
/* /*
* return NULL if we've exhausted all the pages * return NULL if we've exhausted all the pages
*/ */
if ((dir < 0) ? (page == 0) : (page+1 >= pages)) if ((dir < 0) ? (page == 0) : (page + 1 >= pages))
{ {
if (BufferIsValid(*buffer)) if (BufferIsValid(*buffer))
ReleaseBuffer(*buffer); ReleaseBuffer(*buffer);
@ -431,7 +431,6 @@ fastgetattr(HeapTuple tup, int attnum, TupleDesc tupleDesc,
) )
); );
} }
#endif /* defined(DISABLE_COMPLEX_MACRO) */ #endif /* defined(DISABLE_COMPLEX_MACRO) */
@ -1045,12 +1044,13 @@ heap_insert(Relation relation, HeapTuple tup)
if (relation->rd_rel->relhasoids) if (relation->rd_rel->relhasoids)
{ {
/* /*
* If the object id of this tuple has already been assigned, trust the * If the object id of this tuple has already been assigned, trust
* caller. There are a couple of ways this can happen. At initial db * the caller. There are a couple of ways this can happen. At
* creation, the backend program sets oids for tuples. When we define * initial db creation, the backend program sets oids for tuples.
* an index, we set the oid. Finally, in the future, we may allow * When we define an index, we set the oid. Finally, in the
* users to set their own object ids in order to support a persistent * future, we may allow users to set their own object ids in order
* object store (objects need to contain pointers to one another). * to support a persistent object store (objects need to contain
* pointers to one another).
*/ */
if (!OidIsValid(tup->t_data->t_oid)) if (!OidIsValid(tup->t_data->t_oid))
tup->t_data->t_oid = newoid(); 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 * Now, do we need a new page for the tuple, or not? This is a
* tricky since someone else could have added tuples to the page * bit tricky since someone else could have added tuples to the
* while we weren't looking. We have to recheck the available space * page while we weren't looking. We have to recheck the
* after reacquiring the buffer lock. But don't bother to do that * available space after reacquiring the buffer lock. But don't
* if the former amount of free space is still not enough; it's * bother to do that if the former amount of free space is still
* unlikely there's more free now than before. * 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 * 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 * buffer locks on both old and new pages. To avoid deadlock
* some other backend trying to get the same two locks in the other * against some other backend trying to get the same two locks in
* order, we must be consistent about the order we get the locks in. * the other order, we must be consistent about the order we get
* We use the rule "lock the lower-numbered page of the relation * the locks in. We use the rule "lock the lower-numbered page of
* first". To implement this, we must do RelationGetBufferForTuple * the relation first". To implement this, we must do
* while not holding the lock on the old page, and we must rely on it * RelationGetBufferForTuple while not holding the lock on the old
* to get the locks on both pages in the correct order. * page, and we must rely on it to get the locks on both pages in
* the correct order.
*/ */
if (newtupsize > pagefree) if (newtupsize > pagefree)
{ {
@ -1510,8 +1511,8 @@ l2:
{ {
/* /*
* Rats, it doesn't fit anymore. We must now unlock and * Rats, it doesn't fit anymore. We must now unlock and
* relock to avoid deadlock. Fortunately, this path should * relock to avoid deadlock. Fortunately, this path
* seldom be taken. * should seldom be taken.
*/ */
LockBuffer(buffer, BUFFER_LOCK_UNLOCK); LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
newbuf = RelationGetBufferForTuple(relation, newtup->t_len, newbuf = RelationGetBufferForTuple(relation, newtup->t_len,
@ -1534,9 +1535,9 @@ l2:
pgstat_count_heap_update(&relation->pgstat_info); pgstat_count_heap_update(&relation->pgstat_info);
/* /*
* At this point newbuf and buffer are both pinned and locked, * At this point newbuf and buffer are both pinned and locked, and
* and newbuf has enough space for the new tuple. If they are * newbuf has enough space for the new tuple. If they are the same
* the same buffer, only one pin is held. * buffer, only one pin is held.
*/ */
/* NO ELOG(ERROR) from here till changes are logged */ /* 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 * Note: xlhdr is declared to have adequate size and correct alignment
* for an xl_heap_header. However the two tids, if present at all, * 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; * 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; xl_heap_header hdr;
TransactionId tid1; TransactionId tid1;
TransactionId tid2; TransactionId tid2;
@ -1972,7 +1975,7 @@ heap_xlog_clean(bool redo, XLogRecPtr lsn, XLogRecord *record)
if (record->xl_len > SizeOfHeapClean) if (record->xl_len > SizeOfHeapClean)
{ {
OffsetNumber unbuf[BLCKSZ/sizeof(OffsetNumber)]; OffsetNumber unbuf[BLCKSZ / sizeof(OffsetNumber)];
OffsetNumber *unused = unbuf; OffsetNumber *unused = unbuf;
char *unend; char *unend;
ItemId lp; ItemId lp;
@ -2084,7 +2087,8 @@ heap_xlog_insert(bool redo, XLogRecPtr lsn, XLogRecord *record)
if (redo) if (redo)
{ {
struct { struct
{
HeapTupleHeaderData hdr; HeapTupleHeaderData hdr;
char data[MaxTupleSize]; char data[MaxTupleSize];
} tbuf; } tbuf;
@ -2251,7 +2255,8 @@ newsame:;
if (redo) if (redo)
{ {
struct { struct
{
HeapTupleHeaderData hdr; HeapTupleHeaderData hdr;
char data[MaxTupleSize]; char data[MaxTupleSize];
} tbuf; } tbuf;

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

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * 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) if (otherBuffer != InvalidBuffer)
otherBlock = BufferGetBlockNumber(otherBuffer); otherBlock = BufferGetBlockNumber(otherBuffer);
else 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 * 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 * 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 * 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 * 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 * loop, we must update the FSM with the correct amount of free space
* each page that proves not to be suitable.) If the FSM has no record of * on each page that proves not to be suitable.) If the FSM has no
* a page with enough free space, we give up and extend the relation. * record of a page with enough free space, we give up and extend the
* relation.
*/ */
targetBlock = relation->rd_targblock; targetBlock = relation->rd_targblock;
@ -137,6 +139,7 @@ RelationGetBufferForTuple(Relation relation, Size len,
* target. * target.
*/ */
targetBlock = GetPageWithFreeSpace(&relation->rd_node, len); targetBlock = GetPageWithFreeSpace(&relation->rd_node, len);
/* /*
* If the FSM knows nothing of the rel, try the last page before * 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 * we give up and extend. This avoids one-tuple-per-page syndrome
@ -154,9 +157,9 @@ RelationGetBufferForTuple(Relation relation, Size len,
while (targetBlock != InvalidBlockNumber) while (targetBlock != InvalidBlockNumber)
{ {
/* /*
* Read and exclusive-lock the target block, as well as the * Read and exclusive-lock the target block, as well as the other
* other block if one was given, taking suitable care with * block if one was given, taking suitable care with lock ordering
* lock ordering and the possibility they are the same block. * and the possibility they are the same block.
*/ */
if (otherBuffer == InvalidBuffer) if (otherBuffer == InvalidBuffer)
{ {
@ -184,9 +187,10 @@ RelationGetBufferForTuple(Relation relation, Size len,
LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE); LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
LockBuffer(otherBuffer, BUFFER_LOCK_EXCLUSIVE); LockBuffer(otherBuffer, BUFFER_LOCK_EXCLUSIVE);
} }
/* /*
* Now we can check to see if there's enough free space here. * Now we can check to see if there's enough free space here. If
* If so, we're done. * so, we're done.
*/ */
pageHeader = (Page) BufferGetPage(buffer); pageHeader = (Page) BufferGetPage(buffer);
pageFreeSpace = PageGetFreeSpace(pageHeader); pageFreeSpace = PageGetFreeSpace(pageHeader);
@ -196,22 +200,22 @@ RelationGetBufferForTuple(Relation relation, Size len,
relation->rd_targblock = targetBlock; relation->rd_targblock = targetBlock;
return buffer; return buffer;
} }
/* /*
* Not enough space, so we must give up our page locks and * Not enough space, so we must give up our page locks and pin (if
* pin (if any) and prepare to look elsewhere. We don't care * any) and prepare to look elsewhere. We don't care which order
* which order we unlock the two buffers in, so this can be * we unlock the two buffers in, so this can be slightly simpler
* slightly simpler than the code above. * than the code above.
*/ */
LockBuffer(buffer, BUFFER_LOCK_UNLOCK); LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
if (otherBuffer == InvalidBuffer) if (otherBuffer == InvalidBuffer)
{
ReleaseBuffer(buffer); ReleaseBuffer(buffer);
}
else if (otherBlock != targetBlock) else if (otherBlock != targetBlock)
{ {
LockBuffer(otherBuffer, BUFFER_LOCK_UNLOCK); LockBuffer(otherBuffer, BUFFER_LOCK_UNLOCK);
ReleaseBuffer(buffer); ReleaseBuffer(buffer);
} }
/* /*
* Update FSM as to condition of this page, and ask for another * Update FSM as to condition of this page, and ask for another
* page to try. * page to try.
@ -225,9 +229,9 @@ RelationGetBufferForTuple(Relation relation, Size len,
/* /*
* Have to extend the relation. * Have to extend the relation.
* *
* We have to use a lock to ensure no one else is extending the * We have to use a lock to ensure no one else is extending the rel at
* rel at the same time, else we will both try to initialize the * the same time, else we will both try to initialize the same new
* same new page. * page.
*/ */
if (!relation->rd_myxactonly) if (!relation->rd_myxactonly)
LockPage(relation, 0, ExclusiveLock); 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 * 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 * the only way to accurately determine how many blocks are in a
* relation. Is it worth keeping an accurate file length in shared * 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); buffer = ReadBuffer(relation, P_NEW);
/* /*
* Release the file-extension lock; it's now OK for someone else * Release the file-extension lock; it's now OK for someone else to
* to extend the relation some more. * extend the relation some more.
*/ */
if (!relation->rd_myxactonly) if (!relation->rd_myxactonly)
UnlockPage(relation, 0, ExclusiveLock); UnlockPage(relation, 0, ExclusiveLock);
/* /*
* We can be certain that locking the otherBuffer first is OK, * We can be certain that locking the otherBuffer first is OK, since
* since it must have a lower page number. * it must have a lower page number.
*/ */
if (otherBuffer != InvalidBuffer) if (otherBuffer != InvalidBuffer)
LockBuffer(otherBuffer, BUFFER_LOCK_EXCLUSIVE); LockBuffer(otherBuffer, BUFFER_LOCK_EXCLUSIVE);

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

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * 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 * NOTES
* initam should be moved someplace else. * initam should be moved someplace else.
@ -164,7 +164,6 @@ ResetHeapAccessStatistics()
time(&stats->local_reset_timestamp); time(&stats->local_reset_timestamp);
time(&stats->last_request_timestamp); time(&stats->last_request_timestamp);
} }
#endif #endif
#ifdef NOT_USED #ifdef NOT_USED
@ -200,7 +199,6 @@ GetHeapAccessStatistics()
return stats; return stats;
} }
#endif #endif
#ifdef NOT_USED #ifdef NOT_USED
@ -211,7 +209,6 @@ GetHeapAccessStatistics()
void void
PrintHeapAccessStatistics(HeapAccessStatistics stats) PrintHeapAccessStatistics(HeapAccessStatistics stats)
{ {
/* /*
* return nothing if stats aren't valid * return nothing if stats aren't valid
*/ */
@ -302,7 +299,6 @@ PrintHeapAccessStatistics(HeapAccessStatistics stats)
printf("\n"); printf("\n");
} }
#endif #endif
#ifdef NOT_USED #ifdef NOT_USED
@ -317,7 +313,6 @@ PrintAndFreeHeapAccessStatistics(HeapAccessStatistics stats)
if (stats != NULL) if (stats != NULL)
pfree(stats); pfree(stats);
} }
#endif #endif
/* ---------------------------------------------------------------- /* ----------------------------------------------------------------
@ -331,7 +326,6 @@ PrintAndFreeHeapAccessStatistics(HeapAccessStatistics stats)
void void
initam(void) initam(void)
{ {
/* /*
* initialize heap statistics. * initialize heap statistics.
*/ */

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

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

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

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * 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 * NOTES
* many of the old access method routines have been turned into * 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 */ scan->flags = 0x0; /* XXX should have a symbolic name */
} }
#endif #endif

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

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * 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 * INTERFACE ROUTINES
* index_open - open an index relation by relationId * index_open - open an index relation by relationId
@ -241,9 +241,9 @@ index_beginscan(Relation relation,
pgstat_initstats(&scan->xs_pgstat_info, relation); pgstat_initstats(&scan->xs_pgstat_info, relation);
/* /*
* We want to look up the amgettuple procedure just once per scan, * We want to look up the amgettuple procedure just once per scan, not
* not once per index_getnext call. So do it here and save * once per index_getnext call. So do it here and save the fmgr info
* the fmgr info result in the scan descriptor. * result in the scan descriptor.
*/ */
GET_SCAN_PROCEDURE(beginscan, amgettuple); GET_SCAN_PROCEDURE(beginscan, amgettuple);
fmgr_info(procedure, &scan->fn_getnext); fmgr_info(procedure, &scan->fn_getnext);
@ -342,8 +342,8 @@ index_getnext(IndexScanDesc scan,
pgstat_count_index_scan(&scan->xs_pgstat_info); pgstat_count_index_scan(&scan->xs_pgstat_info);
/* /*
* have the am's gettuple proc do all the work. * have the am's gettuple proc do all the work. index_beginscan
* index_beginscan already set up fn_getnext. * already set up fn_getnext.
*/ */
result = (RetrieveIndexResult) result = (RetrieveIndexResult)
DatumGetPointer(FunctionCall2(&scan->fn_getnext, DatumGetPointer(FunctionCall2(&scan->fn_getnext,

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

@ -9,7 +9,7 @@
* *
* *
* IDENTIFICATION * 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; return true;
} }
#endif #endif
#ifdef NOT_USED #ifdef NOT_USED
@ -255,7 +254,6 @@ StrategyTermEvaluate(StrategyTerm term,
return result; return result;
} }
#endif #endif
/* ---------------- /* ----------------
@ -453,7 +451,6 @@ RelationInvokeStrategy(Relation relation,
/* not reached, just to make compiler happy */ /* not reached, just to make compiler happy */
return FALSE; return FALSE;
} }
#endif #endif
/* ---------------- /* ----------------
@ -562,7 +559,7 @@ IndexSupportInitialize(IndexStrategy indexStrategy,
{ {
tuple = SearchSysCache(AMPROCNUM, tuple = SearchSysCache(AMPROCNUM,
ObjectIdGetDatum(opclass), ObjectIdGetDatum(opclass),
Int16GetDatum(support+1), Int16GetDatum(support + 1),
0, 0); 0, 0);
if (HeapTupleIsValid(tuple)) if (HeapTupleIsValid(tuple))
{ {
@ -643,5 +640,4 @@ IndexStrategyDisplay(IndexStrategy indexStrategy,
} }
} }
} }
#endif /* defined(ISTRATDEBUG) */ #endif /* defined(ISTRATDEBUG) */

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

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * 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 * NOTES
* *

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

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * 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 $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -1100,7 +1100,7 @@ _bt_checksplitloc(FindSplitData *state, OffsetNumber firstright,
* If we are not on the leaf level, we will be able to discard the key * If we are not on the leaf level, we will be able to discard the key
* data from the first item that winds up on the right page. * data from the first item that winds up on the right page.
*/ */
if (! state->is_leaf) if (!state->is_leaf)
rightfree += (int) firstrightitemsz - rightfree += (int) firstrightitemsz -
(int) (MAXALIGN(sizeof(BTItemData)) + sizeof(ItemIdData)); (int) (MAXALIGN(sizeof(BTItemData)) + sizeof(ItemIdData));
@ -1115,7 +1115,8 @@ _bt_checksplitloc(FindSplitData *state, OffsetNumber firstright,
{ {
/* /*
* On a rightmost page, try to equalize right free space with * 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; delta = (2 * leftfree) - rightfree;
} }
@ -1618,7 +1619,6 @@ _bt_fixlevel(Relation rel, Buffer buf, BlockNumber limit)
for (;;) for (;;)
{ {
/* /*
* Read up to 2 more child pages and look for pointers to them in * Read up to 2 more child pages and look for pointers to them in
* *saved* parent page * *saved* parent page

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

@ -9,7 +9,7 @@
* *
* *
* IDENTIFICATION * 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 * NOTES
* Postgres btree pages look like ordinary relation pages. The opaque * 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) if (metad->btm_root == P_NONE)
{ {
/* /*
* Get, initialize, write, and leave a lock of the appropriate * Get, initialize, write, and leave a lock of the appropriate
* type on the new root page. Since this is the first page in * type on the new root page. Since this is the first page in
@ -209,7 +208,6 @@ _bt_getroot(Relation rel, int access)
} }
else else
{ {
/* /*
* Metadata initialized by someone else. In order to * Metadata initialized by someone else. In order to
* guarantee no deadlocks, we have to release the metadata * guarantee no deadlocks, we have to release the metadata
@ -237,7 +235,6 @@ _bt_getroot(Relation rel, int access)
if (!P_ISROOT(rootopaque)) if (!P_ISROOT(rootopaque))
{ {
/* /*
* It happened, but if root page splitter failed to create new * It happened, but if root page splitter failed to create new
* root page then we'll go in loop trying to call _bt_getroot * root page then we'll go in loop trying to call _bt_getroot
@ -402,7 +399,6 @@ _bt_wrtnorelbuf(Relation rel, Buffer buf)
void void
_bt_pageinit(Page page, Size size) _bt_pageinit(Page page, Size size)
{ {
/* /*
* Cargo_cult programming -- don't really need this to be zero, but * Cargo_cult programming -- don't really need this to be zero, but
* creating new pages is an infrequent occurrence and it makes me feel * 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 * Portions Copyright (c) 1994, Regents of the University of California
* *
* IDENTIFICATION * 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; bool haveDead;
Relation heapRel; Relation heapRel;
BTSpool *spool; BTSpool *spool;
/* /*
* spool2 is needed only when the index is an unique index. Dead * spool2 is needed only when the index is an unique index. Dead
* tuples are put into spool2 instead of spool in order to avoid * tuples are put into spool2 instead of spool in order to avoid
@ -134,6 +135,7 @@ btbuild(PG_FUNCTION_ARGS)
if (buildstate.usefast) if (buildstate.usefast)
{ {
buildstate.spool = _bt_spoolinit(index, indexInfo->ii_Unique); buildstate.spool = _bt_spoolinit(index, indexInfo->ii_Unique);
/* /*
* Different from spool, the uniqueness isn't checked for spool2. * Different from spool, the uniqueness isn't checked for spool2.
*/ */
@ -226,9 +228,9 @@ btbuildCallback(Relation index,
btitem = _bt_formitem(itup); btitem = _bt_formitem(itup);
/* /*
* if we are doing bottom-up btree build, we insert the index into * if we are doing bottom-up btree build, we insert the index into a
* a spool file for subsequent processing. otherwise, we insert * spool file for subsequent processing. otherwise, we insert into
* into the btree. * the btree.
*/ */
if (buildstate->usefast) if (buildstate->usefast)
{ {
@ -305,7 +307,6 @@ btgettuple(PG_FUNCTION_ARGS)
if (ItemPointerIsValid(&(scan->currentItemData))) if (ItemPointerIsValid(&(scan->currentItemData)))
{ {
/* /*
* Restore scan position using heap TID returned by previous call * Restore scan position using heap TID returned by previous call
* to btgettuple(). _bt_restscan() re-grabs the read lock on the * 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? */ #ifdef NOT_USED /* XXX surely it's wrong to ignore this? */
bool fromEnd = PG_GETARG_BOOL(1); bool fromEnd = PG_GETARG_BOOL(1);
#endif #endif
ScanKey scankey = (ScanKey) PG_GETARG_POINTER(2); ScanKey scankey = (ScanKey) PG_GETARG_POINTER(2);
ItemPointer iptr; ItemPointer iptr;
@ -559,15 +559,16 @@ btbulkdelete(PG_FUNCTION_ARGS)
num_index_tuples = 0; num_index_tuples = 0;
/* /*
* We use a standard IndexScanDesc scan object, but to speed up the loop, * We use a standard IndexScanDesc scan object, but to speed up the
* we skip most of the wrapper layers of index_getnext and instead call * loop, we skip most of the wrapper layers of index_getnext and
* _bt_step directly. This implies holding buffer lock on a target page * instead call _bt_step directly. This implies holding buffer lock
* throughout the loop over the page's tuples. Initially, we have a read * on a target page throughout the loop over the page's tuples.
* lock acquired by _bt_step when we stepped onto the page. If we find * Initially, we have a read lock acquired by _bt_step when we stepped
* a tuple we need to delete, we trade in the read lock for an exclusive * onto the page. If we find a tuple we need to delete, we trade in
* write lock; after that, we hold the write lock until we step off the * the read lock for an exclusive write lock; after that, we hold the
* page (fortunately, _bt_relbuf doesn't care which kind of lock it's * write lock until we step off the page (fortunately, _bt_relbuf
* releasing). This should minimize the amount of work needed per page. * 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); scan = index_beginscan(rel, false, 0, (ScanKey) NULL);
so = (BTScanOpaque) scan->opaque; so = (BTScanOpaque) scan->opaque;
@ -607,9 +608,10 @@ btbulkdelete(PG_FUNCTION_ARGS)
{ {
/* /*
* If this is first deletion on this page, trade in read * If this is first deletion on this page, trade in read
* lock for a really-exclusive write lock. Then, step back * lock for a really-exclusive write lock. Then, step
* one and re-examine the item, because someone else might * back one and re-examine the item, because someone else
* have inserted an item while we weren't holding the lock! * might have inserted an item while we weren't holding
* the lock!
*/ */
if (blkno != lockedBlock) if (blkno != lockedBlock)
{ {
@ -632,8 +634,8 @@ btbulkdelete(PG_FUNCTION_ARGS)
* We need to back up the scan one item so that the next * We need to back up the scan one item so that the next
* cycle will re-examine the same offnum on this page. * cycle will re-examine the same offnum on this page.
* *
* For now, just hack the current-item index. Will need * For now, just hack the current-item index. Will need to
* to be smarter when deletion includes removal of empty * be smarter when deletion includes removal of empty
* index pages. * index pages.
*/ */
current->ip_posid--; 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 * Portions Copyright (c) 1994, Regents of the University of California
* *
* IDENTIFICATION * 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 * 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 * 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 * greater than the scan key and we know that everything on later
* is less than or equal to scan key. * pages is less than or equal to scan key.
* *
* We could step forward in the latter case, but that'd be a waste of * 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 * 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 * Portions Copyright (c) 1994, Regents of the University of California
* *
* IDENTIFICATION * 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) if (pgspc < btisz || pgspc < state->btps_full)
{ {
/* /*
* Item won't fit on this page, or we feel the page is full enough * Item won't fit on this page, or we feel the page is full enough
* already. Finish off the page and write it out. * already. Finish off the page and write it out.
@ -544,7 +543,6 @@ _bt_load(Relation index, BTSpool *btspool, BTSpool *btspool2)
if (merge) if (merge)
{ {
/* /*
* Another BTSpool for dead tuples exists. Now we have to merge * Another BTSpool for dead tuples exists. Now we have to merge
* btspool and btspool2. * btspool and btspool2.

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

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * 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, return (RelationInvokeStrategy(rel, &BTEvaluationData, attno, strat,
left, right)); left, right));
} }
#endif #endif

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

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * 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 */ /* We can short-circuit most of the work if there's just one key */
if (numberOfKeys == 1) if (numberOfKeys == 1)
{ {
/* /*
* We don't use indices for 'A is null' and 'A is not null' * We don't use indices for 'A is null' and 'A is not null'
* currently and 'A < = > <> NULL' will always fail - so qual is * currently and 'A < = > <> NULL' will always fail - so qual is
@ -317,7 +316,6 @@ _bt_orderkeys(Relation relation, BTScanOpaque so)
} }
else else
{ {
/* /*
* No "=" for this key, so we're done with required keys * No "=" for this key, so we're done with required keys
*/ */

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

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

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

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * 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 else
{ {
/* /*
* remember that we're before the current * remember that we're before the current
* tuple * tuple

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