database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-11-12 05:01:15 +03:00
Code Activity

First stage of reclaiming memory in executor by resetting short-term

Browse Source 
memory contexts.  Currently, only leaks in expressions executed as
quals or projections are handled.  Clean up some old dead cruft in
executor while at it --- unused fields in state nodes, that sort of thing.
This commit is contained in:
Tom Lane
2000-07-12 02:37:39 +00:00
parent 46fb9c29e2
commit badce86a2c
53 changed files with 1536 additions and 1584 deletions
Download Patch File Download Diff File Expand all files Collapse all files

135
src/backend/utils/adt/datum.c
View File

@@ -1,13 +1,14 @@
/*-------------------------------------------------------------------------
*
* datum.c
* POSTGRES Datum (abstract data type) manipulation routines.
*
* Portions Copyright (c) 1996-2000, PostgreSQL, Inc
* Portions Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/utils/adt/datum.c,v 1.17 2000/01/26 05:57:13 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/utils/adt/datum.c,v 1.18 2000/07/12 02:37:19 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@@ -16,7 +17,7 @@
*
* A) if a type is "byVal" then all the information is stored in the
* Datum itself (i.e. no pointers involved!). In this case the
* length of the type is always greater than zero and less than
* length of the type is always greater than zero and not more than
* "sizeof(Datum)"
* B) if a type is not "byVal" and it has a fixed length, then
* the "Datum" always contain a pointer to a stream of bytes.
@@ -27,15 +28,19 @@
* This varlena structure has information about the actual length of this
* particular instance of the type and about its value.
*
* Note that we do not treat "toasted" datums specially; therefore what
* will be copied or compared is the compressed data or toast reference.
*/
#include "postgres.h"
#include "utils/datum.h"
/*-------------------------------------------------------------------------
* datumGetSize
*
* Find the "real" size of a datum, given the datum value,
* its type, whether it is a "by value", and its length.
* whether it is a "by value", and its length.
*
* To cut a long story short, usually the real size is equal to the
* type length, with the exception of variable length types which have
@@ -45,47 +50,31 @@
*-------------------------------------------------------------------------
*/
Size
datumGetSize(Datum value, Oid type, bool byVal, Size len)
datumGetSize(Datum value, bool typByVal, int typLen)
{
Size size;
struct varlena *s;
Size size = 0;
if (byVal)
if (typByVal)
{
if (len <= sizeof(Datum))
size = len;
else
{
elog(ERROR,
"datumGetSize: Error: type=%ld, byVaL with len=%d",
(long) type, len);
}
/* Pass-by-value types are always fixed-length */
Assert(typLen > 0 && typLen <= sizeof(Datum));
size = (Size) typLen;
}
else
{ /* not byValue */
if (len == -1)
{
if (typLen == -1)
{
/* Assume it is a varlena datatype */
struct varlena *s = (struct varlena *) DatumGetPointer(value);
/*
* variable length type Look at the varlena struct for its
* real length...
*/
s = (struct varlena *) DatumGetPointer(value);
if (!PointerIsValid(s))
{
elog(ERROR,
"datumGetSize: Invalid Datum Pointer");
}
elog(ERROR, "datumGetSize: Invalid Datum Pointer");
size = (Size) VARSIZE(s);
}
else
{
/*
* fixed length type
*/
size = len;
/* Fixed-length pass-by-ref type */
size = (Size) typLen;
}
}
@@ -97,37 +86,29 @@ datumGetSize(Datum value, Oid type, bool byVal, Size len)
*
* make a copy of a datum
*
* If the type of the datum is not passed by value (i.e. "byVal=false")
* then we assume that the datum contains a pointer and we copy all the
* bytes pointed by this pointer
* If the datatype is pass-by-reference, memory is obtained with palloc().
*-------------------------------------------------------------------------
*/
Datum
datumCopy(Datum value, Oid type, bool byVal, Size len)
datumCopy(Datum value, bool typByVal, int typLen)
{
Size realSize;
Datum res;
char *s;
if (byVal)
if (typByVal)
res = value;
else
{
if (value == 0)
return (Datum) NULL;
realSize = datumGetSize(value, type, byVal, len);
Size realSize;
char *s;
if (DatumGetPointer(value) == NULL)
return PointerGetDatum(NULL);
realSize = datumGetSize(value, typByVal, typLen);
/*
* the value is a pointer. Allocate enough space and copy the
* pointed data.
*/
s = (char *) palloc(realSize);
if (s == NULL)
elog(ERROR, "datumCopy: out of memory\n");
memmove(s, DatumGetPointer(value), realSize);
res = (Datum) s;
memcpy(s, DatumGetPointer(value), realSize);
res = PointerGetDatum(s);
}
return res;
}
@@ -143,21 +124,12 @@ datumCopy(Datum value, Oid type, bool byVal, Size len)
*/
#ifdef NOT_USED
void
datumFree(Datum value, Oid type, bool byVal, Size len)
datumFree(Datum value, bool typByVal, int typLen)
{
Size realSize;
Pointer s;
realSize = datumGetSize(value, type, byVal, len);
if (!byVal)
if (!typByVal)
{
Pointer s = DatumGetPointer(value);
/*
* free the space palloced by "datumCopy()"
*/
s = DatumGetPointer(value);
pfree(s);
}
}
@@ -174,46 +146,41 @@ datumFree(Datum value, Oid type, bool byVal, Size len)
* This routine will return false if there are 2 different
* representations of the same value (something along the lines
* of say the representation of zero in one's complement arithmetic).
*
* Also, it will probably not give the answer you want if either
* datum has been "toasted".
*-------------------------------------------------------------------------
*/
bool
datumIsEqual(Datum value1, Datum value2, Oid type, bool byVal, Size len)
datumIsEqual(Datum value1, Datum value2, bool typByVal, int typLen)
{
Size size1,
size2;
char *s1,
*s2;
bool res;
if (byVal)
if (typByVal)
{
/*
* just compare the two datums. NOTE: just comparing "len" bytes
* will not do the work, because we do not know how these bytes
* are aligned inside the "Datum".
*/
if (value1 == value2)
return true;
else
return false;
res = (value1 == value2);
}
else
{
Size size1,
size2;
char *s1,
*s2;
/*
* byVal = false Compare the bytes pointed by the pointers stored
* in the datums.
* Compare the bytes pointed by the pointers stored in the datums.
*/
size1 = datumGetSize(value1, type, byVal, len);
size2 = datumGetSize(value2, type, byVal, len);
size1 = datumGetSize(value1, typByVal, typLen);
size2 = datumGetSize(value2, typByVal, typLen);
if (size1 != size2)
return false;
s1 = (char *) DatumGetPointer(value1);
s2 = (char *) DatumGetPointer(value2);
if (!memcmp(s1, s2, size1))
return true;
else
return false;
res = (memcmp(s1, s2, size1) == 0);
}
return res;
}

108
src/backend/utils/adt/varlena.c
View File

@@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/utils/adt/varlena.c,v 1.63 2000/07/06 05:48:11 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/utils/adt/varlena.c,v 1.64 2000/07/12 02:37:19 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@@ -436,25 +436,38 @@ textpos(PG_FUNCTION_ARGS)
/*
* texteq - returns true iff arguments are equal
* textne - returns true iff arguments are not equal
*
* Note: btree indexes need these routines not to leak memory; therefore,
* be careful to free working copies of toasted datums. Most places don't
* need to be so careful.
*/
Datum
texteq(PG_FUNCTION_ARGS)
{
text *arg1 = PG_GETARG_TEXT_P(0);
text *arg2 = PG_GETARG_TEXT_P(1);
int len;
char *a1p,
*a2p;
bool result;
if (VARSIZE(arg1) != VARSIZE(arg2))
PG_RETURN_BOOL(false);
result = false;
else
{
int len;
char *a1p,
*a2p;
len = VARSIZE(arg1) - VARHDRSZ;
len = VARSIZE(arg1) - VARHDRSZ;
a1p = VARDATA(arg1);
a2p = VARDATA(arg2);
a1p = VARDATA(arg1);
a2p = VARDATA(arg2);
PG_RETURN_BOOL(memcmp(a1p, a2p, len) == 0);
result = (memcmp(a1p, a2p, len) == 0);
}
PG_FREE_IF_COPY(arg1, 0);
PG_FREE_IF_COPY(arg2, 1);
PG_RETURN_BOOL(result);
}
Datum
@@ -462,19 +475,28 @@ textne(PG_FUNCTION_ARGS)
{
text *arg1 = PG_GETARG_TEXT_P(0);
text *arg2 = PG_GETARG_TEXT_P(1);
int len;
char *a1p,
*a2p;
bool result;
if (VARSIZE(arg1) != VARSIZE(arg2))
PG_RETURN_BOOL(true);
result = true;
else
{
int len;
char *a1p,
*a2p;
len = VARSIZE(arg1) - VARHDRSZ;
len = VARSIZE(arg1) - VARHDRSZ;
a1p = VARDATA(arg1);
a2p = VARDATA(arg2);
a1p = VARDATA(arg1);
a2p = VARDATA(arg2);
PG_RETURN_BOOL(memcmp(a1p, a2p, len) != 0);
result = (memcmp(a1p, a2p, len) != 0);
}
PG_FREE_IF_COPY(arg1, 0);
PG_FREE_IF_COPY(arg2, 1);
PG_RETURN_BOOL(result);
}
/* varstr_cmp()
@@ -545,6 +567,10 @@ text_cmp(text *arg1, text *arg2)
/*
* Comparison functions for text strings.
*
* Note: btree indexes need these routines not to leak memory; therefore,
* be careful to free working copies of toasted datums. Most places don't
* need to be so careful.
*/
Datum
@@ -552,8 +578,14 @@ text_lt(PG_FUNCTION_ARGS)
{
text *arg1 = PG_GETARG_TEXT_P(0);
text *arg2 = PG_GETARG_TEXT_P(1);
bool result;
PG_RETURN_BOOL(text_cmp(arg1, arg2) < 0);
result = (text_cmp(arg1, arg2) < 0);
PG_FREE_IF_COPY(arg1, 0);
PG_FREE_IF_COPY(arg2, 1);
PG_RETURN_BOOL(result);
}
Datum
@@ -561,8 +593,14 @@ text_le(PG_FUNCTION_ARGS)
{
text *arg1 = PG_GETARG_TEXT_P(0);
text *arg2 = PG_GETARG_TEXT_P(1);
bool result;
PG_RETURN_BOOL(text_cmp(arg1, arg2) <= 0);
result = (text_cmp(arg1, arg2) <= 0);
PG_FREE_IF_COPY(arg1, 0);
PG_FREE_IF_COPY(arg2, 1);
PG_RETURN_BOOL(result);
}
Datum
@@ -570,8 +608,14 @@ text_gt(PG_FUNCTION_ARGS)
{
text *arg1 = PG_GETARG_TEXT_P(0);
text *arg2 = PG_GETARG_TEXT_P(1);
bool result;
PG_RETURN_BOOL(text_cmp(arg1, arg2) > 0);
result = (text_cmp(arg1, arg2) > 0);
PG_FREE_IF_COPY(arg1, 0);
PG_FREE_IF_COPY(arg2, 1);
PG_RETURN_BOOL(result);
}
Datum
@@ -579,8 +623,14 @@ text_ge(PG_FUNCTION_ARGS)
{
text *arg1 = PG_GETARG_TEXT_P(0);
text *arg2 = PG_GETARG_TEXT_P(1);
bool result;
PG_RETURN_BOOL(text_cmp(arg1, arg2) >= 0);
result = (text_cmp(arg1, arg2) >= 0);
PG_FREE_IF_COPY(arg1, 0);
PG_FREE_IF_COPY(arg2, 1);
PG_RETURN_BOOL(result);
}
Datum
@@ -589,14 +639,8 @@ text_larger(PG_FUNCTION_ARGS)
text *arg1 = PG_GETARG_TEXT_P(0);
text *arg2 = PG_GETARG_TEXT_P(1);
text *result;
text *temp;
temp = ((text_cmp(arg1, arg2) > 0) ? arg1 : arg2);
/* Make a copy --- temporary hack until nodeAgg.c is smarter */
result = (text *) palloc(VARSIZE(temp));
memcpy((char *) result, (char *) temp, VARSIZE(temp));
result = ((text_cmp(arg1, arg2) > 0) ? arg1 : arg2);
PG_RETURN_TEXT_P(result);
}
@@ -607,14 +651,8 @@ text_smaller(PG_FUNCTION_ARGS)
text *arg1 = PG_GETARG_TEXT_P(0);
text *arg2 = PG_GETARG_TEXT_P(1);
text *result;
text *temp;
temp = ((text_cmp(arg1, arg2) < 0) ? arg1 : arg2);
/* Make a copy --- temporary hack until nodeAgg.c is smarter */
result = (text *) palloc(VARSIZE(temp));
memcpy((char *) result, (char *) temp, VARSIZE(temp));
result = ((text_cmp(arg1, arg2) < 0) ? arg1 : arg2);
PG_RETURN_TEXT_P(result);
}