prestogres 0.1.0

data/pgpool2/parser/pool_memory.c

@@ -0,0 +1,342 @@
+/* -*-pgsql-c-*- */
+/*
+ * $Header$
+ *
+ * pgpool: a language independent connection pool server for PostgreSQL 
+ * written by Tatsuo Ishii
+ *
+ * Copyright (c) 2003-2012	PgPool Global Development Group
+ *
+ * Permission to use, copy, modify, and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice appear in all
+ * copies and that both that copyright notice and this permission
+ * notice appear in supporting documentation, and that the name of the
+ * author not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior
+ * permission. The author makes no representations about the
+ * suitability of this software for any purpose.  It is provided "as
+ * is" without express or implied warranty.
+ *
+ * pool_memory.c: Memory pooling module for SQL parser.
+ *
+ */
+
+#undef POOL_MEMORY_DEBUG
+
+#include "pool.h"
+#include "pool_memory.h"
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define ALIGN 3
+#define POOL_HEADER_SIZE (sizeof (POOL_CHUNK_HEADER))
+
+POOL_MEMORY_POOL *pool_memory = NULL;
+
+static int get_free_index(unsigned int size);
+
+static int get_free_index(unsigned int size)
+{
+	int idx = 0;
+
+	if (size > 0)
+	{
+		size = (size - 1) >> ALIGN;
+		while (size)
+		{
+			size >>= 1;
+			idx++;
+		}
+	}
+	return idx;
+}
+
+/*
+ * pool_memory_alloc:
+ *     Returns pointer to allocated memory of given size.
+ */
+void *pool_memory_alloc(POOL_MEMORY_POOL *pool, unsigned int size)
+{
+	POOL_BLOCK *block;
+	POOL_CHUNK *chunk;
+
+#ifdef POOL_MEMORY_DEBUG
+	pool_log("pool_memory_alloc: pool:%p size:%d", pool, size);
+#endif
+
+	if ((size + POOL_HEADER_SIZE) > pool->blocksize)
+	{
+		block = malloc(sizeof(POOL_BLOCK));
+		if (block == NULL)
+		{
+			pool_error("pool_memory_alloc: malloc failed: %s", strerror(errno));
+			child_exit(1);
+		}
+		block->allocsize = block->size = size + POOL_HEADER_SIZE;
+		block->block = malloc(size + POOL_HEADER_SIZE);
+		if (block->block == NULL)
+		{
+			pool_error("pool_memory_alloc: malloc failed: %s", strerror(errno));
+			child_exit(1);
+		}
+		block->freepoint = block + (size + POOL_HEADER_SIZE);
+		chunk = block->block;
+		chunk->header.size = size + POOL_HEADER_SIZE;
+		block->next = pool->largeblocks;
+		pool->largeblocks = block;
+	}
+	else
+	{
+		int fidx = get_free_index(size + POOL_HEADER_SIZE);
+		int allocsize = 1 << (fidx + ALIGN);
+
+		/* pick up from freelist */
+		if (pool->freelist[fidx] != NULL)
+		{
+			chunk = pool->freelist[fidx];
+			pool->freelist[fidx] = chunk->header.next;
+			chunk->header.size = allocsize;
+			return chunk->data;
+		}
+		
+		block = pool->blocks;
+		if (block == NULL ||
+			block->freepoint + allocsize > block->block + block->size)
+		{
+			block = malloc(sizeof(POOL_BLOCK));
+			if (block == NULL)
+			{
+				pool_error("pool_memory_alloc: malloc failed: %s", strerror(errno));
+				child_exit(1);
+			}
+			block->size = pool->blocksize;
+			block->allocsize = 0;
+			block->block = malloc(pool->blocksize);
+			if (block->block == NULL)
+			{
+				pool_error("pool_memory_alloc: malloc failed: %s", strerror(errno));
+				child_exit(1);
+			}
+			block->freepoint = block->block;
+			block->next = pool->blocks;
+			pool->blocks = block;
+		}
+
+		block = pool->blocks;
+		chunk = block->freepoint;
+		block->freepoint += allocsize;
+		block->allocsize += allocsize;
+		chunk->header.size = allocsize;
+	}
+	return chunk->data;
+}
+
+
+/*
+ * pool_memory_alloc_zero:
+ *     Returns pointer to allocated memory of given size.
+ *     The allocated memory is cleared.
+ */
+void *pool_memory_alloc_zero(POOL_MEMORY_POOL *pool, unsigned int size)
+{
+	void *ptr = pool_memory_alloc(pool, size);
+	memset(ptr, 0, size);
+	return ptr;
+}
+
+/*
+ * pool_memory_free:
+ *    Frees allocated memory into memory pool.
+ */
+void pool_memory_free(POOL_MEMORY_POOL *pool, void *ptr)
+{
+	POOL_CHUNK *chunk = ptr - POOL_HEADER_SIZE;
+	int fidx;
+
+#ifdef POOL_MEMORY_DEBUG
+	pool_log("pool_memory_free: pool:%p ptr:%p", pool, ptr);
+#endif
+
+	if (ptr == NULL)
+		return;
+
+	if (chunk->header.size > pool->blocksize)
+	{
+		POOL_BLOCK *block, *ptr = NULL;
+
+		for (block = pool->largeblocks; block; ptr = block, block = block->next)
+		{
+			if (block->block == chunk)
+				break;
+		}
+
+		if (block == NULL)
+		{
+			pool_log("An address \"%p\" does not exist in memory pool.", chunk);
+			return;
+		}
+
+		if (ptr == NULL)
+		{
+			pool->largeblocks = block->next;
+		}
+		else
+		{
+			ptr->next = block->next;
+		}
+		free(block->block);
+		free(block);
+	}
+	else
+	{
+		fidx = get_free_index(chunk->header.size);
+		chunk->header.next = pool->freelist[fidx];
+		pool->freelist[fidx] = chunk;
+	}
+}
+
+/*
+ * pool_memory_realloc:
+ *     Returns new pointer to allocated memory of given size.
+ *     The new memory is copied from the old memory, and the old
+ *     memory is freed.
+ */
+void *pool_memory_realloc(POOL_MEMORY_POOL *pool, void *ptr, unsigned int size)
+{
+	int fidx;
+	void *p;
+	POOL_CHUNK *chunk = ptr - POOL_HEADER_SIZE;
+
+	if (size <= chunk->header.size - POOL_HEADER_SIZE)
+		return ptr;
+
+	fidx = get_free_index(size + POOL_HEADER_SIZE);
+	if (size + POOL_HEADER_SIZE <= pool->blocksize &&
+		chunk->header.size <= pool->blocksize &&
+		fidx == get_free_index(chunk->header.size))
+	{
+		return ptr;
+	}
+
+	p = pool_memory_alloc(pool, size);
+	memmove(p, ptr, chunk->header.size - POOL_HEADER_SIZE);
+	pool_memory_free(pool, ptr);
+
+	return p;
+}
+
+/*
+ * pool_memory_create:
+ *     Create a new memory pool.
+ */
+POOL_MEMORY_POOL *pool_memory_create(int blocksize)
+{
+	POOL_MEMORY_POOL *pool;
+	int i;
+
+	pool = malloc(sizeof(POOL_MEMORY_POOL));
+	if (pool == NULL)
+	{
+		pool_error("pool_memory_create: malloc failed: %s", strerror(errno));
+		child_exit(1);
+	}
+
+#ifdef POOL_MEMORY_DEBUG
+	pool_log("pool_memory_create: blocksize: %d pool:%p", blocksize, pool);
+#endif
+
+	pool->blocks = NULL;
+	pool->largeblocks = NULL;
+	pool->blocksize = blocksize;
+	
+	for (i = 0; i < SLOT_NUM; i++)
+	{
+		pool->freelist[i] = NULL;
+	}
+
+	return pool;
+}
+
+/*
+ * pool_memory_delete:
+ *     Frees all memory which is allocated in the memory pool.
+ */
+void pool_memory_delete(POOL_MEMORY_POOL *pool_memory, int reuse)
+{
+	POOL_BLOCK *block, *ptr;
+
+#ifdef POOL_MEMORY_DEBUG
+	pool_log("pool_memory_delete: pool:%p reuse:%d", pool_memory, reuse);
+#endif
+
+	/* Reuse the first memory block */
+	if (reuse && pool_memory->blocks)
+		block = pool_memory->blocks->next;
+	else
+		block = pool_memory->blocks;
+
+	while (block)
+	{
+		ptr = block->next;
+		free(block->block);
+		free(block);
+		block = ptr;
+	}
+
+	for (block = pool_memory->largeblocks; block;)
+	{
+		ptr = block->next;
+		free(block->block);
+		free(block);
+		block = ptr;
+	}
+
+	if (reuse)
+	{
+		int i;
+
+		if (pool_memory->blocks)
+		{
+			pool_memory->blocks->next = NULL;
+			pool_memory->blocks->allocsize = 0;
+			pool_memory->blocks->freepoint = pool_memory->blocks->block;
+		}
+		pool_memory->largeblocks = NULL;
+		for (i = 0; i < SLOT_NUM; i++)
+		{
+			pool_memory->freelist[i] = NULL;
+		}
+	}
+	else
+	{
+		free(pool_memory);
+		pool_memory = NULL;
+	}
+}
+
+/*
+ * pool_memory_strdup:
+ *     Creates the new string which is copied the given string.
+ */
+char *pool_memory_strdup(POOL_MEMORY_POOL *pool_memory, const char *string)
+{
+	int len = strlen(string);
+	char *str = pool_memory_alloc(pool_memory, len + 1);
+
+	memmove(str, string, len);
+	str[len] = '\0';
+	return str;
+}
+
+/*
+ * Switch memory context from pool_memory to pm
+ */
+POOL_MEMORY_POOL *pool_memory_context_switch_to(POOL_MEMORY_POOL *pm)
+{
+	POOL_MEMORY_POOL *old = pool_memory;
+	pool_memory = pm;
+	return old;
+}
+

data/pgpool2/parser/pool_memory.h

@@ -0,0 +1,77 @@
+/* -*-pgsql-c-*- */
+/*
+ * $Header$
+ *
+ * pgpool: a language independent connection pool server for PostgreSQL 
+ * written by Tatsuo Ishii
+ *
+ * Copyright (c) 2003-2013	PgPool Global Development Group
+ *
+ * Permission to use, copy, modify, and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice appear in all
+ * copies and that both that copyright notice and this permission
+ * notice appear in supporting documentation, and that the name of the
+ * author not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior
+ * permission. The author makes no representations about the
+ * suitability of this software for any purpose.  It is provided "as
+ * is" without express or implied warranty.
+ *
+ * pool_memory.h: Memory pooling module for SQL parser.
+ *
+ */
+
+#ifndef POOL_MEMORY_H
+#define POOL_MEMORY_H
+
+#define SLOT_NUM 11
+
+#define PARSER_BLOCK_SIZE 8192
+#define PREPARE_BLOCK_SIZE 1024
+
+typedef struct POOL_BLOCK {
+	int size;
+	int allocsize;
+	void *block;
+	void *freepoint;
+	struct POOL_BLOCK *next;
+} POOL_BLOCK;
+
+typedef union {
+	unsigned int size;
+	struct POOL_CHUNK *next;
+} POOL_CHUNK_HEADER;
+
+typedef struct POOL_CHUNK {
+	POOL_CHUNK_HEADER header;
+	char data[1];
+} POOL_CHUNK;
+
+typedef struct {
+	int size;
+	int blocksize;
+	POOL_BLOCK *blocks;
+	POOL_BLOCK *largeblocks;
+	POOL_CHUNK *freelist[SLOT_NUM];
+} POOL_MEMORY_POOL;
+
+extern POOL_MEMORY_POOL *pool_memory;
+
+extern void *pool_memory_alloc(POOL_MEMORY_POOL *pool, unsigned int size);
+extern void pool_memory_free(POOL_MEMORY_POOL *pool, void *ptr);
+extern void *pool_memory_realloc(POOL_MEMORY_POOL *pool, void *ptr, unsigned int size);
+extern POOL_MEMORY_POOL *pool_memory_create(int blocksize);
+extern void pool_memory_delete(POOL_MEMORY_POOL *pool_memory, int reuse);
+extern char *pool_memory_strdup(POOL_MEMORY_POOL *pool_memory, const char *string);
+extern void *pool_memory_alloc_zero(POOL_MEMORY_POOL *pool_memory, unsigned int size);
+extern POOL_MEMORY_POOL *pool_memory_context_switch_to(POOL_MEMORY_POOL *pm);
+
+#define palloc(s) pool_memory_alloc(pool_memory, (s))
+#define pfree(p)  pool_memory_free(pool_memory, (p))
+#define repalloc(p, s)  pool_memory_realloc(pool_memory, (p), (s))
+#define pstrdup(s)  pool_memory_strdup(pool_memory, (s))
+#define palloc0(s) pool_memory_alloc_zero(pool_memory, (s))
+#define palloc0fast(s) pool_memory_alloc_zero(pool_memory, (s))	/* Added in 8.4 */
+
+#endif /* POOL_MEMORY_H */

data/pgpool2/parser/pool_parser.h

@@ -0,0 +1,222 @@
+/* -*-pgsql-c-*- */
+/*
+ * $Header$
+ *
+ * Copyright (c) 2006-2009, pgpool Global Development Group
+ *
+ * Permission to use, copy, modify, and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice appear in all
+ * copies and that both that copyright notice and this permission
+ * notice appear in supporting documentation, and that the name of the
+ * author not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior
+ * permission. The author makes no representations about the
+ * suitability of this software for any purpose.  It is provided "as
+ * is" without express or implied warranty.
+ */
+
+#ifndef POOL_PARSER_H
+#define POOL_PARSER_H
+
+#include "../pool_type.h"
+#include <setjmp.h>
+
+extern jmp_buf jmpbuffer;
+extern int	server_version_num;
+
+#define AssertMacro
+#define Assert(expr)	((void) 0)
+
+/* include/c.h */
+/* integer */
+
+/* 
+ * move int32 and int16 to pool_types.h since there's no point that
+ * these are solely used for parser
+ * typedef signed int int32;
+ * typedef signed short int16;
+ */
+
+/*
+ * bitsN
+ *		Unit of bitwise operation, AT LEAST N BITS IN SIZE.
+ */
+typedef uint8 bits8;			/* >= 8 bits */
+typedef uint16 bits16;			/* >= 16 bits */
+typedef uint32 bits32;			/* >= 32 bits */
+typedef unsigned long long int uint64;
+
+
+typedef size_t Size;
+typedef unsigned int PoolOid;
+typedef unsigned int Index;
+typedef short AttrNumber;
+typedef unsigned long Datum;	/* XXX sizeof(long) >= sizeof(void *) */
+
+#define Oid PoolOid
+#define InvalidOid		((Oid) 0)
+
+/*
+ * NAMEDATALEN is the max length for system identifiers (e.g. table names,
+ * attribute names, function names, etc).  It must be a multiple of
+ * sizeof(int) (typically 4).
+ *
+ * NOTE that databases with different NAMEDATALEN's cannot interoperate!
+ */
+#define NAMEDATALEN 64
+
+/*
+ * Max
+ *		Return the maximum of two numbers.
+ */
+#define Max(x, y)		((x) > (y) ? (x) : (y))
+
+/*
+ * Min
+ *		Return the minimum of two numbers.
+ */
+#define Min(x, y)		((x) < (y) ? (x) : (y))
+/* array */
+#define lengthof(array) (sizeof(array) / sizeof(((array)[0])))
+#define endof(array) (&(array)[lengthof(array)])
+
+/* msb for char */
+#define HIGHBIT					(0x80)
+#define IS_HIGHBIT_SET(ch)		((unsigned char)(ch) & HIGHBIT)
+
+#define PGDLLIMPORT
+
+
+/* include/utils/datetime.h */
+/* date and datetime */
+#define RESERV	0
+#define MONTH	1
+#define YEAR	2
+#define DAY		3
+#define JULIAN	4
+#define TZ		5
+#define DTZ		6
+#define DTZMOD	7
+#define IGNORE_DTF	8
+#define AMPM	9
+#define HOUR	10
+#define MINUTE	11
+#define SECOND	12
+#define DOY		13
+#define DOW		14
+#define UNITS	15
+#define ADBC	16
+/* these are only for relative dates */
+#define AGO		17
+#define ABS_BEFORE		18
+#define ABS_AFTER		19
+/* generic fields to help with parsing */
+#define ISODATE 20
+#define ISOTIME 21
+/* reserved for unrecognized string values */
+#define UNKNOWN_FIELD	31
+#define MAX_TIMESTAMP_PRECISION 6
+#define MAX_INTERVAL_PRECISION 6
+#define INTERVAL_FULL_RANGE (0x7FFF)
+#define INTERVAL_RANGE_MASK (0x7FFF)
+#define INTERVAL_FULL_PRECISION (0xFFFF)
+#define INTERVAL_PRECISION_MASK (0xFFFF)
+
+#define INTERVAL_MASK(b) (1 << (b))
+#define INTERVAL_TYPMOD(p,r) ((((r) & INTERVAL_RANGE_MASK) << 16) | ((p) & INTERVAL_PRECISION_MASK))
+#define INTERVAL_PRECISION(t) ((t) & INTERVAL_PRECISION_MASK)
+#define INTERVAL_RANGE(t) (((t) >> 16) & INTERVAL_RANGE_MASK)
+
+
+/* include/storage/lock.h */
+/* lock */
+/* NoLock is not a lock mode, but a flag value meaning "don't get a lock" */
+#define NoLock					0
+
+#define AccessShareLock			1		/* SELECT */
+#define RowShareLock			2		/* SELECT FOR UPDATE/FOR SHARE */
+#define RowExclusiveLock		3		/* INSERT, UPDATE, DELETE */
+#define ShareUpdateExclusiveLock 4		/* VACUUM (non-FULL) */
+#define ShareLock				5		/* CREATE INDEX */
+#define ShareRowExclusiveLock	6		/* like EXCLUSIVE MODE, but allows ROW
+										 * SHARE */
+#define ExclusiveLock			7		/* blocks ROW SHARE/SELECT...FOR
+										 * UPDATE */
+#define AccessExclusiveLock		8		/* ALTER TABLE, DROP TABLE, VACUUM
+										 * FULL, and unqualified LOCK TABLE */
+
+#define DEFAULT_INDEX_TYPE	"btree"
+#define NUMERIC_MAX_PRECISION		1000
+
+#define VARHDRSZ		((int32) sizeof(int32))
+
+#define MaxAttrSize		(10 * 1024 * 1024)
+#define BITS_PER_BYTE		8
+#define MAX_TIME_PRECISION 6
+
+
+/* ----------------------------------------------------------------
+ *              Section 1: hacks to cope with non-ANSI C compilers
+ *
+ * type prefixes (const, signed, volatile, inline) are handled in pg_config.h.
+ * ----------------------------------------------------------------
+ */
+
+/*
+ * CppAsString
+ *      Convert the argument to a string, using the C preprocessor.
+ * CppConcat
+ *      Concatenate two arguments together, using the C preprocessor.
+ *
+ * Note: the standard Autoconf macro AC_C_STRINGIZE actually only checks
+ * whether #identifier works, but if we have that we likely have ## too.
+ */
+#if defined(HAVE_STRINGIZE)
+
+#define CppAsString(identifier) #identifier
+#define CppConcat(x, y)         x##y
+#else                           /* !HAVE_STRINGIZE */
+
+#define CppAsString(identifier) "identifier"
+
+/*
+ * CppIdentity -- On Reiser based cpp's this is used to concatenate
+ *      two tokens.  That is
+ *              CppIdentity(A)B ==> AB
+ *      We renamed it to _private_CppIdentity because it should not
+ *      be referenced outside this file.  On other cpp's it
+ *      produces  A  B.
+ */
+#define _priv_CppIdentity(x)x
+#define CppConcat(x, y)         _priv_CppIdentity(x)y
+#endif   /* !HAVE_STRINGIZE */
+
+#if 0
+/* from include/catalog/pg_trigger.h  start */
+/* Bits within tgtype */
+#define TRIGGER_TYPE_ROW                (1 << 0)
+#define TRIGGER_TYPE_BEFORE             (1 << 1)
+#define TRIGGER_TYPE_INSERT             (1 << 2)
+#define TRIGGER_TYPE_DELETE             (1 << 3)
+#define TRIGGER_TYPE_UPDATE             (1 << 4)
+#define TRIGGER_TYPE_TRUNCATE           (1 << 5)
+/* from include/catalog/pg_trigger.h  end */
+#endif
+
+
+/* include/utils/elog.h */
+#define NOTICE 18
+#define WARNING 19
+#define ERROR 20
+
+extern void pool_parser_error(int level, const char *file, int line);
+#ifndef ereport
+#define ereport(elevel, rest) pool_parser_error(elevel, __FILE__, __LINE__)
+#endif
+#ifndef elog
+#define elog(elevel, fmt, ...) pool_parser_error(elevel, __FILE__, __LINE__)
+#endif
+
+
+#endif /* POOL_PARSER_H */