prestogres 0.1.0

data/pgpool2/pool_proto_modules.h

@@ -0,0 +1,185 @@
+/* -*-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_proto_modules.h.: header file for pool_proto_modules.c, pool_proto2.c
+ * and pool_process_query.c
+ *
+ */
+
+#ifndef POOL_PROTO_MODULES_H
+#define POOL_PROTO_MODULES_H
+
+#include "parser/parser.h"
+#include "parser/pool_memory.h"
+#include "parser/pg_list.h"
+#include "parser/parsenodes.h"
+#include "pool_rewrite_query.h"
+#include "pool_session_context.h"
+#include "pool_process_reporting.h"
+
+#define SPECIFIED_ERROR 1
+#define POOL_DUMMY_WRITE_QUERY "DELETE FROM foo WHERE col = 'pgpool: unable to parse the query'"
+#define POOL_DUMMY_READ_QUERY "SELECT 'pgpool: unable to parse the query'"
+#define POOL_ERROR_QUERY "send invalid query from pgpool to abort transaction"
+
+extern char *copy_table;  /* copy table name */
+extern char *copy_schema;  /* copy table name */
+extern char copy_delimiter; /* copy delimiter char */
+extern char *copy_null; /* copy null string */
+
+extern int is_select_pgcatalog;
+extern int is_select_for_update; /* also for SELECT ... INTO */
+extern bool is_parallel_table;
+extern char *parsed_query;
+
+/*
+ * modules defined in pool_proto_modules.c
+ */
+extern POOL_STATUS SimpleQuery(POOL_CONNECTION *frontend, 
+							   POOL_CONNECTION_POOL *backend,
+							   int len, char *contents);
+
+extern POOL_STATUS Execute(POOL_CONNECTION *frontend, 
+						   POOL_CONNECTION_POOL *backend,
+						   int len, char *contents);
+
+extern POOL_STATUS Parse(POOL_CONNECTION *frontend,
+						 POOL_CONNECTION_POOL *backend,
+						 int len, char *contents);
+
+extern POOL_STATUS Bind(POOL_CONNECTION *frontend,
+						POOL_CONNECTION_POOL *backend,
+						int len, char *contents);
+
+extern POOL_STATUS Describe(POOL_CONNECTION *frontend,
+							POOL_CONNECTION_POOL *backend,
+							int len, char *contents);
+
+extern POOL_STATUS Close(POOL_CONNECTION *frontend,
+						 POOL_CONNECTION_POOL *backend,
+						 int len, char *contents);
+
+extern POOL_STATUS FunctionCall3(POOL_CONNECTION *frontend,
+								 POOL_CONNECTION_POOL *backend,
+								 int len, char *contents);
+
+extern POOL_STATUS ReadyForQuery(POOL_CONNECTION *frontend, 
+								 POOL_CONNECTION_POOL *backend, bool send_ready, bool cache_commit);
+
+extern POOL_STATUS ParseComplete(POOL_CONNECTION *frontend,
+								 POOL_CONNECTION_POOL *backend);
+
+extern POOL_STATUS BindComplete(POOL_CONNECTION *frontend,
+								POOL_CONNECTION_POOL *backend);
+
+extern POOL_STATUS CloseComplete(POOL_CONNECTION *frontend,
+								 POOL_CONNECTION_POOL *backend);
+
+extern POOL_STATUS CommandComplete(POOL_CONNECTION *frontend,
+								   POOL_CONNECTION_POOL *backend);
+
+extern POOL_STATUS ErrorResponse3(POOL_CONNECTION *frontend,
+								  POOL_CONNECTION_POOL *backend);
+
+extern POOL_STATUS CopyInResponse(POOL_CONNECTION *frontend, 
+								  POOL_CONNECTION_POOL *backend);
+
+extern POOL_STATUS CopyOutResponse(POOL_CONNECTION *frontend, 
+								   POOL_CONNECTION_POOL *backend);
+
+extern POOL_STATUS CopyDataRows(POOL_CONNECTION *frontend,
+								POOL_CONNECTION_POOL *backend, int copyin);
+
+extern POOL_STATUS FunctionCall(POOL_CONNECTION *frontend, 
+								POOL_CONNECTION_POOL *backend);
+
+extern POOL_STATUS ProcessFrontendResponse(POOL_CONNECTION *frontend, 
+										   POOL_CONNECTION_POOL *backend);
+
+extern POOL_STATUS ProcessBackendResponse(POOL_CONNECTION *frontend, 
+										  POOL_CONNECTION_POOL *backend,
+										  int *state, short *num_fields);
+
+/*
+ * modules defined in pool_proto2.c
+ */
+extern POOL_STATUS AsciiRow(POOL_CONNECTION *frontend,
+							POOL_CONNECTION_POOL *backend,
+							short num_fields);
+
+extern POOL_STATUS BinaryRow(POOL_CONNECTION *frontend,
+							 POOL_CONNECTION_POOL *backend,
+							 short num_fields);
+
+extern POOL_STATUS CompletedResponse(POOL_CONNECTION *frontend, 
+									 POOL_CONNECTION_POOL *backend);
+
+extern POOL_STATUS CursorResponse(POOL_CONNECTION *frontend,
+								  POOL_CONNECTION_POOL *backend);
+
+extern POOL_STATUS EmptyQueryResponse(POOL_CONNECTION *frontend,
+									  POOL_CONNECTION_POOL *backend);
+
+extern POOL_STATUS FunctionResultResponse(POOL_CONNECTION *frontend,
+										  POOL_CONNECTION_POOL *backend);
+
+extern POOL_STATUS NotificationResponse(POOL_CONNECTION *frontend,
+										POOL_CONNECTION_POOL *backend);
+
+extern int RowDescription(POOL_CONNECTION *frontend,
+						  POOL_CONNECTION_POOL *backend,
+						  short *result);
+
+
+extern POOL_STATUS wait_for_query_response(POOL_CONNECTION *frontend, POOL_CONNECTION *backend, int protoVersion);
+extern int is_select_query(Node *node, char *sql);
+extern bool is_commit_query(Node *node);
+extern bool is_rollback_query(Node *node);
+extern bool is_commit_or_rollback_query(Node *node);
+extern bool is_strict_query(Node *node); /* returns non 0 if this is strict query */
+extern int need_insert_lock(POOL_CONNECTION_POOL *backend, char *query, Node *node);
+extern POOL_STATUS insert_lock(POOL_CONNECTION *frontend, POOL_CONNECTION_POOL *backend, char *query, InsertStmt *node, int lock_kind);
+extern char *parse_copy_data(char *buf, int len, char delimiter, int col_id);
+extern int check_copy_from_stdin(Node *node); /* returns non 0 if this is a COPY FROM STDIN */
+extern void query_ps_status(char *query, POOL_CONNECTION_POOL *backend);		/* show ps status */
+extern POOL_STATUS start_internal_transaction(POOL_CONNECTION *frontend, POOL_CONNECTION_POOL *backend, Node *node);
+extern POOL_STATUS end_internal_transaction(POOL_CONNECTION *frontend, POOL_CONNECTION_POOL *backend);
+extern int detect_deadlock_error(POOL_CONNECTION *master, int major);
+extern int detect_serialization_error(POOL_CONNECTION *master, int major, bool unread);
+extern int detect_active_sql_transaction_error(POOL_CONNECTION *backend, int major);
+extern int detect_query_cancel_error(POOL_CONNECTION *backend, int major);
+extern bool is_partition_table(POOL_CONNECTION_POOL *backend, Node *node);
+extern POOL_STATUS pool_discard_packet(POOL_CONNECTION_POOL *cp);
+extern void query_cache_register(char kind, POOL_CONNECTION *frontend, char *database, char *data, int data_len);
+extern int is_drop_database(Node *node);		/* returns non 0 if this is a DROP DATABASE command */
+
+extern POOL_STATUS send_simplequery_message(POOL_CONNECTION *backend, int len, char *string, int major);
+extern POOL_STATUS send_extended_protocol_message(POOL_CONNECTION_POOL *backend,
+												  int node_id, char *kind,
+												  int len, char *string);
+
+extern int synchronize(POOL_CONNECTION *cp);
+extern POOL_STATUS read_kind_from_backend(POOL_CONNECTION *frontend, POOL_CONNECTION_POOL *backend, char *decided_kind);
+extern POOL_STATUS read_kind_from_one_backend(POOL_CONNECTION *frontend, POOL_CONNECTION_POOL *backend, char *kind, int node);
+extern POOL_STATUS do_error_command(POOL_CONNECTION *backend, int major);
+extern POOL_STATUS raise_intentional_error_if_need(POOL_CONNECTION_POOL *backend);
+
+#endif

data/pgpool2/pool_query_cache.c

@@ -0,0 +1,1020 @@
+/* -*-pgsql-c-*- */
+/*
+ * $Header$
+ *
+ * pgpool: a language independent connection pool server for PostgreSQL
+ * written by Tatsuo Ishii
+ *
+ * Copyright (c) 2003-2010	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_query_cache.c: query cache
+ *
+ */
+
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <time.h>
+#include <sys/time.h>
+#include <unistd.h>
+#ifdef HAVE_SYS_SELECT_H
+#include <sys/select.h>
+#endif
+
+#include "pool.h"
+#include "md5.h"
+#include "pool_stream.h"
+#include "pool_config.h"
+#include "pool_proto_modules.h"
+#include "parser/parsenodes.h"
+
+#define QUERY_CACHE_TABLE_NAME "query_cache"
+#define CACHE_REGISTER_PREPARED_STMT "register_prepared_stmt"
+#define DEFAULT_CACHE_SIZE 8192
+
+#define SYSDB_CON (SYSDB_CONNECTION->con)
+#define SYSDB_MAJOR (SYSDB_CONNECTION->sp->major)
+#define CACHE_TABLE_INFO (SYSDB_INFO->query_cache_table_info)
+
+/* data structure to store RowDescription and DataRow cache */
+typedef struct
+{
+	char *md5_query;			/* query in md5 hushed format*/
+	char *query;				/* query string */
+	char *cache;				/* cached data */
+	int   cache_size;			/* cached data size */
+	int   cache_offset;			/* points the end of cache */
+	char *db_name;				/* database name */
+	char *create_time;			/* cache create timestamp in ISO format */
+} QueryCacheInfo;
+
+typedef enum
+{
+	CACHE_FOUND, CACHE_NOT_FOUND, CACHE_ERROR
+} CACHE_STATUS;
+
+static QueryCacheInfo *query_cache_info;
+
+static CACHE_STATUS search_system_db_for_cache(POOL_CONNECTION *frontend, char *sql, int sql_len, struct timeval *t, char tstate);
+static int ForwardCacheToFrontend(POOL_CONNECTION *frontend, char *cache, char tstate);
+static int init_query_cache_info(POOL_CONNECTION *pc, char *database, char *query);
+static void free_query_cache_info(void);
+static int malloc_failed(void *p);
+static int write_cache(void *buf, int len);
+static char *pq_time_to_str(time_t t);
+static int system_db_connection_exists(void);
+static void define_prepared_statements(void);
+
+/* --------------------------------
+ * pool_clear_cache - clears cache data from the SystemDB
+ *
+ * return 0 on success, -1 otherwise
+ * --------------------------------
+ */
+int
+pool_clear_cache_by_time(Interval *interval, int size)
+{
+	PGresult *pg_result = NULL;
+	long interval_in_days = 0;
+	long interval_in_seconds = 0;
+	time_t query_delete_timepoint;
+	char *query_delete_timepoint_in_str = NULL;
+	int sql_len;
+	char *sql = NULL;
+	int i;
+
+	if (! system_db_connection_exists())
+		return -1;
+
+	for (i = 0; i < size; i++)
+	{
+		int q = interval[i].quantity;
+
+		switch (interval[i].unit)
+		{
+			case millennium:
+			case millenniums:
+				q *= 10;
+
+			case century:
+			case centuries:
+				q *= 10;
+
+			case decade:
+			case decades:
+				q *= 10;
+
+			case year:
+			case years:
+				q *= 12;
+
+			case month:
+			case months:
+				q *= 31;		/* should I change this according to the month? */
+				interval_in_days += q;
+				break;
+
+			case week:
+			case weeks:
+				q *= 7;
+
+			case day:
+			case days:
+				q *= 24;
+
+			case hour:
+			case hours:
+				q *= 60;
+
+			case minute:
+			case minutes:
+				q *= 60;
+
+			case second:
+			case seconds:
+				interval_in_seconds += q;
+				break;
+		}
+	}
+
+	interval_in_seconds = (interval_in_days * 86400) + interval_in_seconds;
+	query_delete_timepoint = time(NULL) - interval_in_seconds;
+
+	query_delete_timepoint_in_str = pq_time_to_str(query_delete_timepoint);
+	if (malloc_failed(query_delete_timepoint_in_str))
+		return -1;
+
+	sql_len =
+		strlen(pool_config->system_db_schema) +
+		strlen(QUERY_CACHE_TABLE_NAME) +
+		strlen(query_delete_timepoint_in_str) +
+		64;
+
+	sql = (char *)malloc(sql_len);
+	if (malloc_failed(sql))
+	{
+		free(query_delete_timepoint_in_str);
+		return -1;
+	}
+
+	snprintf(sql, sql_len,
+			 "DELETE FROM %s.%s WHERE create_time <= '%s'",
+			 pool_config->system_db_schema,
+			 QUERY_CACHE_TABLE_NAME,
+			 query_delete_timepoint_in_str);
+
+	pool_debug("pool_clear_cache: delete all query cache created before '%s'", query_delete_timepoint_in_str);
+
+	pg_result = PQexec(system_db_info->pgconn, sql);
+	if (!pg_result || PQresultStatus(pg_result) != PGRES_COMMAND_OK)
+	{
+		pool_error("pool_clear_cache: PQexec() failed. reason: %s",
+				   PQerrorMessage(system_db_info->pgconn));
+
+		PQclear(pg_result);
+		free(query_delete_timepoint_in_str);
+		free(sql);
+		return -1;
+	}
+
+	PQclear(pg_result);
+	free(query_delete_timepoint_in_str);
+	free(sql);
+
+	return 0;
+}
+
+/* --------------------------------
+ * pool_query_cache_table_exists - checks if query_cache table exists in the SystemDB
+ *
+ * This function is called once and only once from the pgpool parent process.
+ * return 1 if query_cache table exists, 0 otherwise.
+ * --------------------------------
+ */
+int
+pool_query_cache_table_exists(void)
+{
+	PGresult *pg_result = NULL;
+	char *sql = NULL;
+	int sql_len = strlen(pool_config->system_db_schema) + strlen(QUERY_CACHE_TABLE_NAME) + 64;
+
+	if (! system_db_connection_exists())
+		return 0;
+
+	sql = (char *)malloc(sql_len);
+	if (malloc_failed(sql))
+		return 0;
+
+	snprintf(sql, sql_len,
+			 "SELECT hash, query, value, dbname, create_time FROM %s.%s LIMIT 1",
+			 pool_config->system_db_schema,
+			 QUERY_CACHE_TABLE_NAME);
+
+	pg_result = PQexec(system_db_info->pgconn, sql);
+	if (!pg_result || PQresultStatus(pg_result) != PGRES_TUPLES_OK)
+	{
+		pool_error("pool_query_cache_table_exists: PQexec() failed. reason: %s",
+				   PQerrorMessage(system_db_info->pgconn));
+
+		PQclear(pg_result);
+		free(sql);
+		return 0;
+	}
+
+	PQclear(pg_result);
+	pool_close_libpq_connection();
+	free(sql);
+
+	return 1;
+}
+
+/* --------------------------------
+ * pool_query_cache_lookup - retrieve query cache from the SystemDB
+ *
+ * creates a SQL query string for searching a cache from the SystemDB.
+ *
+ * returns POOL_CONTINUE if cache is found. returns POOL_END if cache was
+ * not found. returns POOL_ERROR if an error has been encountered while
+ * searching.
+ *
+ * Note that POOL_END and POOL_ERROR are treated the same by the caller
+ * (pool_process_query.c).
+ * POOL_END and POOL_ERROR both indicates to the caller that the search
+ * query must be forwarded to the backends in order to retrieve data and
+ * the result be cached.
+ * Only difference is that POOL_ERROR indicates that some fatal error has
+ * occurred; query cache function, however, should be seamless to the user
+ * whether cache was not found or error has occurred during cache retrieve.
+ * --------------------------------
+ */
+POOL_STATUS
+pool_query_cache_lookup(POOL_CONNECTION *frontend, char *query, char *database, char tstate)
+{
+	char *sql = NULL;
+	int sql_len;
+	char md5_query[33];
+	struct timeval timeout;
+	int status;
+
+	if (! system_db_connection_exists())
+		return POOL_ERROR;		/* same as POOL_END ... at least for now */
+
+	sql_len =
+		strlen(pool_config->system_db_schema) +
+		strlen(QUERY_CACHE_TABLE_NAME) +
+		sizeof(md5_query) +
+		strlen(database) +
+		64;
+	sql = (char *)malloc(sql_len);
+	if (malloc_failed(sql))
+		return POOL_ERROR;		/* should I exit here rather than returning an error? */
+
+	/* cached data lookup */
+	pool_md5_hash(query, strlen(query), md5_query);
+	snprintf(sql, sql_len, "SELECT value FROM %s.%s WHERE hash = '%s' AND dbname = '%s'",
+			 pool_config->system_db_schema,
+			 QUERY_CACHE_TABLE_NAME,
+			 md5_query,
+			 database);
+
+	/* set timeout value for select */
+	timeout.tv_sec = pool_config->child_life_time;
+	timeout.tv_usec = 0;
+
+	pool_debug("pool_query_cache_lookup: searching cache for query: \"%s\"", query);
+	status = search_system_db_for_cache(frontend, sql, strlen(sql)+1, &timeout, tstate);
+
+	/* make sure that the remaining data is discarded */
+	SYSDB_CON->po = 0;
+	SYSDB_CON->len = 0;
+
+	free(sql);
+
+	/* cache found, and no backend communication needed */
+	if (status == CACHE_FOUND)
+	{
+		return POOL_CONTINUE;
+	}
+
+	/* cache not found */
+
+	if (status == CACHE_ERROR)
+	{
+		pool_error("pool_query_cache_lookup: query cache lookup failed");
+		/* reset the SystemDB connection */
+		if (system_db_info->pgconn)
+			pool_close_libpq_connection();
+		return POOL_ERROR;		/* same as POOL_END ... at least for now */
+	}
+
+	pool_debug("pool_query_cache_lookup: query cache not found");
+	return POOL_END;
+}
+
+/* --------------------------------
+ * search_system_db_for_cache - search for query cache in libpq protocol level
+ *
+ * sends a cache searching query string using libpq protocol to the SystemDB.
+ * if the SystemDB returns cache, forward the data to the frontend, and return
+ * CACHE_FOUND. if cache was not found, silently discards the remaining data
+ * returned by the SystemDB, and return CACHE_NOT_FOUND. returns CACHE_ERROR
+ * if an error was encountered.
+ * --------------------------------
+ */
+static CACHE_STATUS
+search_system_db_for_cache(POOL_CONNECTION *frontend, char *sql, int sql_len, struct timeval *t, char tstate)
+{
+	fd_set readmask;
+	int fds;
+	int num_fds;
+	struct timeval *timeout = NULL;
+	char kind;
+	int readlen;
+	char *data = NULL;
+	CACHE_STATUS return_value = CACHE_ERROR;
+	int cache_found = 0;
+
+	pool_debug("pool_query_cache_lookup: executing query: \"%s\"", sql);
+
+	pool_write(SYSDB_CON, "Q", 1);
+	if (SYSDB_MAJOR == PROTO_MAJOR_V3)
+	{
+		int sendlen = htonl(sql_len + 4);
+		pool_write(SYSDB_CON, &sendlen, sizeof(sendlen));
+	}
+	if (pool_write_and_flush(SYSDB_CON, sql, sql_len) < 0)
+	{
+		pool_error("pool_query_cache_lookup: error while sending data to the SystemDB");
+		return CACHE_ERROR;
+	}
+
+	if ((t->tv_sec + t->tv_usec) == 0)
+		timeout = NULL;
+	else
+		timeout = t;
+
+	/* don't really need select() or for(;;) here, but we may need it someday... or not */
+	for (;;)
+	{
+		FD_ZERO(&readmask);
+		num_fds = 0;
+
+		num_fds = SYSDB_CON->fd + 1;
+		FD_SET(SYSDB_CON->fd, &readmask);
+		fds = select(num_fds, &readmask, NULL, NULL, timeout);
+		if (fds == -1)
+		{
+			if (errno == EINTR)
+				continue;
+
+			pool_error("pool_query_cache_lookup: select() failed. reason: %s", strerror(errno));
+			return CACHE_ERROR;
+		}
+
+		/* select() timeout */
+		if (fds == 0)
+			return CACHE_ERROR;
+
+		for (;;)
+		{
+			if (! FD_ISSET(SYSDB_CON->fd, &readmask))
+			{
+				pool_error("pool_query_cache_lookup: select() failed");
+				return CACHE_ERROR;
+			}
+
+			/* read kind */
+			if (pool_read(SYSDB_CON, &kind, sizeof(kind)) < 0)
+			{
+				pool_error("pool_query_cache_lookup: error while reading message kind");
+				return CACHE_ERROR;
+			}
+			pool_debug("pool_query_cache_lookup: received %c from systemdb", kind);
+
+			/* just do the routine work of reading data in. data won't be used */
+			if (kind == 'T')
+			{
+				if (SYSDB_MAJOR == PROTO_MAJOR_V3)
+				{
+					if (pool_read(SYSDB_CON, &readlen, sizeof(int)) < 0)
+					{
+						pool_error("pool_query_cache_lookup: error while reading message length");
+						return CACHE_ERROR;
+					}
+					readlen = ntohl(readlen) - sizeof(int);
+					data = pool_read2(SYSDB_CON, readlen);
+				}
+				else
+				{
+					data = pool_read_string(SYSDB_CON, &readlen, 0);
+				}
+			}
+			else if (kind == 'D') /* cache found! forward it to the frontend */
+			{
+				char *cache;
+				int status;
+
+				cache_found = 1;
+
+				if (SYSDB_MAJOR == PROTO_MAJOR_V3)
+				{
+					if (pool_read(SYSDB_CON, &readlen, sizeof(readlen)) < 0)
+					{
+						pool_error("pool_query_cache_lookup: error while reading message length");
+						return CACHE_ERROR;
+					}
+					readlen = ntohl(readlen) - sizeof(int);
+					cache = pool_read2(SYSDB_CON, readlen);
+				}
+				else
+				{
+					cache = pool_read_string(SYSDB_CON, &readlen, 0);
+				}
+
+				if (cache == NULL)
+				{
+					pool_error("pool_query_cache_lookup: error while reading message body");
+					return CACHE_ERROR;
+				}
+
+				cache[readlen] = '\0';
+
+				cache += sizeof(short);	/* number of columns in 'D' (we know it's always going to be 1, so skip) */
+				cache += sizeof(int); /* length of escaped bytea cache in string format. don't need the length */
+
+				status = ForwardCacheToFrontend(frontend, cache, tstate);
+				if (status < 0)
+				{
+					/* fatal error has occurred while forwarding cache */
+					pool_error("pool_query_cache_lookup: query cache forwarding failed");
+					return_value = CACHE_ERROR;
+				}
+			}
+			else if (kind == 'C') /* see if 'D' was received */
+			{
+				if (cache_found)
+					return_value = CACHE_FOUND;
+				else
+					return_value = CACHE_NOT_FOUND;
+
+				/* must discard the remaining data */
+				if (SYSDB_MAJOR == PROTO_MAJOR_V3)
+				{
+					if (pool_read(SYSDB_CON, &readlen, sizeof(int)) < 0)
+					{
+						pool_error("pool_query_cache_lookup: error while reading message length");
+						return CACHE_ERROR;
+					}
+					readlen = ntohl(readlen) - sizeof(int);
+					data = pool_read2(SYSDB_CON, readlen);
+				}
+				else
+				{
+					data = pool_read_string(SYSDB_CON, &readlen, 0);
+				}
+			}
+			else if (kind == 'Z')
+			{
+				/* must discard the remaining data */
+				if (SYSDB_MAJOR == PROTO_MAJOR_V3)
+				{
+					if (pool_read(SYSDB_CON, &readlen, sizeof(int)) < 0)
+					{
+						pool_error("pool_query_cache_lookup: error while reading message length");
+						return CACHE_ERROR;
+					}
+					readlen = ntohl(readlen) - sizeof(int);
+					data = pool_read2(SYSDB_CON, readlen);
+				}
+				else
+				{
+					data = pool_read_string(SYSDB_CON, &readlen, 0);
+				}
+
+				break;
+			}
+			else if (kind == 'E')
+			{
+				/* must discard the remaining data */
+				if (SYSDB_MAJOR == PROTO_MAJOR_V3)
+				{
+					if (pool_read(SYSDB_CON, &readlen, sizeof(int)) < 0)
+					{
+						pool_error("pool_query_cache_lookup: error while reading message length");
+						return CACHE_ERROR;
+					}
+					readlen = ntohl(readlen) - sizeof(int);
+					data = pool_read2(SYSDB_CON, readlen);
+				}
+				else
+				{
+					data = pool_read_string(SYSDB_CON, &readlen, 0);
+				}
+
+				return_value = CACHE_ERROR;
+			}
+			else
+			{
+				/* shouldn't get here, but just in case */
+				return CACHE_ERROR;
+			}
+		}
+
+		break;
+	}
+
+	return return_value;
+}
+
+/* --------------------------------
+ * ForwardCacheToFrontend - simply forwards cached data to the frontend
+ *
+ * since the cached data passed from the caller is in escaped binary string
+ * format, unescape it and send it to the frontend appending 'Z' at the end.
+ * returns 0 on success, -1 otherwise.
+ * --------------------------------
+ */
+static int ForwardCacheToFrontend(POOL_CONNECTION *frontend, char *cache, char tstate)
+{
+	int sendlen;
+	size_t sz;
+	char *binary_cache = NULL;
+
+	binary_cache = (char *)PQunescapeBytea((unsigned char *)cache, &sz);
+	sendlen = (int) sz;
+	if (malloc_failed(binary_cache))
+		return -1;
+
+	pool_debug("ForwardCacheToFrontend: query cache found (%d bytes)", sendlen);
+
+	/* forward cache to the frontend */
+	pool_write(frontend, binary_cache, sendlen);
+
+	/* send ReadyForQuery to the frontend*/
+	pool_write(frontend, "Z", 1);
+	sendlen = htonl(5);
+	pool_write(frontend, &sendlen, sizeof(int));
+	if (pool_write_and_flush(frontend, &tstate, 1) < 0)
+	{
+		pool_error("pool_query_cache_lookup: error while writing data to the frontend");
+		PQfreemem(binary_cache);
+		return -1;
+	}
+
+	PQfreemem(binary_cache);
+	return 0;
+}
+
+/* --------------------------------
+ * pool_query_cache_register() - register query cache to the SystemDB
+ *
+ * returns 0 on success, -1 otherwise
+ * --------------------------------
+ */
+int
+pool_query_cache_register(char kind,
+						  POOL_CONNECTION *frontend,
+						  char *database,
+						  char *data,
+						  int data_len,
+						  char *query)
+{
+	int ret;
+	int send_len;
+
+	if (! system_db_connection_exists())
+		return -1;
+	if (! CACHE_TABLE_INFO.has_prepared_statement)
+		define_prepared_statements();
+
+	switch (kind)
+	{
+		case 'T':				/* RowDescription */
+		{
+			/* for all SELECT result data from the backend, 'T' must come first */
+			if (query_cache_info != NULL)
+			{
+				pool_error("pool_query_cache_register: received RowDescription in the wrong order");
+				free_query_cache_info();
+				return -1;
+			}
+
+			pool_debug("pool_query_cache_register: saving cache for query: \"%s\"", query);
+
+			/* initialize query_cache_info and save the query */
+			ret = init_query_cache_info(frontend, database, query);
+			if (ret)
+				return ret;
+
+			/* store data into the cache */
+			write_cache(&kind, 1);
+			send_len = htonl(data_len + sizeof(int));
+			write_cache(&send_len, sizeof(int));
+			write_cache(data, data_len);
+
+			break;
+		}
+
+		case 'D':				/* DataRow */
+		{
+			/* for all SELECT result data from the backend, 'T' must come first */
+			if (query_cache_info == NULL)
+			{
+				pool_error("pool_query_cache_register: received DataRow in the wrong order");
+				return -1;
+			}
+
+			write_cache(&kind, 1);
+			send_len = htonl(data_len + sizeof(int));
+			write_cache(&send_len, sizeof(int));
+			write_cache(data, data_len);
+
+			break;
+		}
+
+		case 'C':				/* CommandComplete */
+		{
+			PGresult *pg_result = NULL;
+			char *escaped_query = NULL;
+			size_t escaped_query_len;
+			time_t now = time(NULL);
+			char *values[5];
+			int values_len[5];
+			int values_format[5];
+			int i;
+
+			/* for all SELECT result data from the backend, 'T' must come first */
+			if (query_cache_info == NULL)
+			{
+				pool_error("pool_query_cache_register: received CommandComplete in the wrong order");
+				return -1;
+			}
+
+			/* pack CommandComplete data into the cache */
+			write_cache(&kind, 1);
+			send_len = htonl(data_len + sizeof(int));
+			write_cache(&send_len, sizeof(int));
+			write_cache(data, data_len);
+
+			query_cache_info->create_time = pq_time_to_str(now);
+			if (malloc_failed(query_cache_info->create_time))
+			{
+				free_query_cache_info();
+				return -1;
+			}
+
+			escaped_query = (char *)malloc(strlen(query_cache_info->query) * 2 + 1);
+			if (malloc_failed(escaped_query))
+			{
+				free_query_cache_info();
+				return -1;
+			}
+
+/* 			escaped_query_len = PQescapeStringConn(system_db_info->pgconn, */
+/* 												   escaped_query, */
+/* 												   query_cache_info->query, */
+/* 												   strlen(query_cache_info->query))); */
+			escaped_query_len = PQescapeString(escaped_query, query_cache_info->query, strlen(query_cache_info->query));
+
+			/* all the result data have been received. store into the SystemDB */
+			values[0] = strdup(query_cache_info->md5_query);
+			values[1] = strdup(escaped_query);
+			values[2] = (char *)malloc(query_cache_info->cache_offset);
+			memcpy(values[2], query_cache_info->cache, query_cache_info->cache_offset);
+			values[3] = strdup(query_cache_info->db_name);
+			values[4] = strdup(query_cache_info->create_time);
+			for (i = 0; i < 5; i++)
+			{
+				if (malloc_failed(values[i]))
+				{
+					pool_error("pool_query_cache_register: malloc() failed");
+					free_query_cache_info();
+					{
+						int j;
+						for (j = 0; j < i; j++)
+							free(values[j]);
+					}
+					return -1;
+				}
+
+				values_len[i] = strlen(values[i]);
+			}
+			values_format[0] = values_format[1] = values_format[3] = values_format[4] = 0;
+			values_format[2] = 1;
+			values_len[2] = query_cache_info->cache_offset;
+
+			pg_result = PQexecPrepared(system_db_info->pgconn,
+									   CACHE_TABLE_INFO.register_prepared_statement,
+									   5,
+									   (const char * const *)values,
+									   values_len,
+									   values_format,
+									   0);
+			if (!pg_result || PQresultStatus(pg_result) != PGRES_COMMAND_OK)
+			{
+				pool_error("pool_query_cache_register: PQexecPrepared() failed. reason: %s",
+						   PQerrorMessage(system_db_info->pgconn));
+
+				PQclear(pg_result);
+				PQfreemem(escaped_query);
+				free_query_cache_info();
+				for (i = 0; i < 5; i++)
+					free(values[i]);
+				return -1;
+			}
+
+			PQclear(pg_result);
+			PQfreemem(escaped_query);
+			for (i = 0; i < 5; i++)
+				free(values[i]);
+			free_query_cache_info();
+
+			break;
+		}
+
+		case 'E':
+		{
+			pool_debug("pool_query_cache_register: received 'E': free query cache buffer");
+
+			pool_close_libpq_connection();
+			free_query_cache_info();
+
+			break;
+		}
+	}
+
+	return 0;
+}
+
+/* --------------------------------
+ * init_query_cache_info() - allocate memory for query_cache_info and stores query
+ *
+ * returns 0 on success, -1 otherwise
+`* --------------------------------
+ */
+static int
+init_query_cache_info(POOL_CONNECTION *pc, char *database, char *query)
+{
+	int query_len;				/* length of the SELECT query to be cached */
+
+	query_cache_info = (QueryCacheInfo *)malloc(sizeof(QueryCacheInfo));
+	if (malloc_failed(query_cache_info))
+		return -1;
+
+	/* query */
+	query_len = strlen(query);
+	query_cache_info->query = (char *)malloc(query_len + 1);
+	if (malloc_failed(query_cache_info->query))
+		return -1;
+	memcpy(query_cache_info->query, query, query_len + 1);
+
+	/* md5_query */
+	query_cache_info->md5_query = (char *)malloc(33); /* md5sum is always 33 bytes (including the '\0') */
+	if (malloc_failed(query_cache_info->md5_query))
+		return -1;
+	pool_md5_hash(query_cache_info->query, query_len, query_cache_info->md5_query);
+
+	/* malloc DEFAULT_CACHE_SIZE for query_cache_info->cache */
+	query_cache_info->cache = (char *)malloc(DEFAULT_CACHE_SIZE);
+	if (malloc_failed(query_cache_info->cache))
+		return -1;
+	query_cache_info->cache_size = DEFAULT_CACHE_SIZE;
+	query_cache_info->cache_offset = 0;
+
+	/* save database name */
+	query_cache_info->db_name = (char *)malloc(strlen(database)+1);
+	if (malloc_failed(query_cache_info->db_name))
+		return -1;
+	strcpy(query_cache_info->db_name, database);
+
+	/* initialize create_timestamp */
+	query_cache_info->create_time = NULL;
+
+	return 0;
+}
+
+/* --------------------------------
+ * free_query_cache_info() - free query_cache_info and its members
+ * --------------------------------
+ */
+static void
+free_query_cache_info(void)
+{
+	if (query_cache_info == NULL)
+		return;
+
+	free(query_cache_info->md5_query);
+	free(query_cache_info->query);
+	free(query_cache_info->cache);
+	free(query_cache_info->db_name);
+	if (query_cache_info->create_time)
+		free(query_cache_info->create_time);
+	free(query_cache_info);
+	query_cache_info = NULL;
+}
+
+/* --------------------------------
+ * malloc_failed() - checks if the caller's most recent malloc() has succeeded
+ *
+ * returns 0 if malloc() was a success, -1 otherwise
+`* --------------------------------
+ */
+static int
+malloc_failed(void *p)
+{
+	if (p != NULL)
+		return 0;
+
+	pool_error("pool_query_cache: malloc() failed");
+	free_query_cache_info();
+
+	return -1;
+}
+
+/* --------------------------------
+ * write_cache() - append result data to buffer
+ *
+ * returns 0 on success, -1 otherwise
+ * --------------------------------
+ */
+static int
+write_cache(void *buf, int len)
+{
+	int required_len;
+
+	if (len < 0)
+		return -1;
+
+	required_len = query_cache_info->cache_offset + len;
+	if (required_len > query_cache_info->cache_size)
+	{
+		char *ptr;
+
+		required_len = query_cache_info->cache_size * 2;
+		ptr = (char *)realloc(query_cache_info->cache, required_len);
+		if (malloc_failed(ptr))
+			return -1;
+
+		query_cache_info->cache = ptr;
+		query_cache_info->cache_size = required_len;
+
+		pool_debug("pool_query_cache: extended cache buffer size to %d", query_cache_info->cache_size);
+	}
+
+	memcpy(query_cache_info->cache + query_cache_info->cache_offset, buf, len);
+	query_cache_info->cache_offset += len;
+
+	return 0;
+}
+
+/* --------------------------------
+ * pq_time_to_str() - convert time_t to ISO standard time output string
+ *
+ * returns a pointer to newly allocated string, NULL if malloc fails
+ * --------------------------------
+ */
+static char *
+pq_time_to_str(time_t t)
+{
+	char *time_p;
+	char iso_time[32];
+	struct tm *tm;
+
+	tm = localtime(&t);
+	strftime(iso_time, sizeof(iso_time), "%Y-%m-%d %H:%M:%S%z", tm);
+
+	time_p = strdup(iso_time);
+
+	return time_p;
+}
+
+
+/* --------------------------------
+ * system_db_connection_exists() - checks and if a connection to the SystemDB exists
+ *
+ * if not connected, it makes an attempt to connect to the SystemDB. If a connection
+ * exists, returns 1, returns 0 otherwise.
+ * --------------------------------
+ */
+static int
+system_db_connection_exists(void)
+{
+	if (!system_db_info->pgconn ||
+		(PQstatus(system_db_info->pgconn) != CONNECTION_OK))
+	{
+		if (system_db_connect())
+			return 0;
+	}
+
+	return 1;
+}
+
+
+/* --------------------------------
+ * define_prepared_statements() - defines prepared statements for the current session
+ * --------------------------------
+ */
+static void
+define_prepared_statements(void)
+{
+	PGresult *pg_result;
+	char *sql = NULL;
+	int sql_len;
+
+	sql_len =
+		strlen(pool_config->system_db_schema) +
+		strlen(QUERY_CACHE_TABLE_NAME) +
+		1024;
+
+	sql = (char *)malloc(sql_len);
+	if (malloc_failed(sql))
+	{
+		pool_error("pool_query_cache: malloc() failed");
+		return;
+	}
+
+	free(CACHE_TABLE_INFO.register_prepared_statement);
+	CACHE_TABLE_INFO.register_prepared_statement
+		= strdup(CACHE_REGISTER_PREPARED_STMT);
+	if (malloc_failed(CACHE_TABLE_INFO.register_prepared_statement))
+	{
+		pool_error("pool_query_cache: malloc() failed");
+		free(sql);
+		return;
+	}
+
+#ifdef HAVE_PQPREPARE
+	snprintf(sql, sql_len,
+			 "INSERT INTO %s.%s VALUES ( $1, $2, $3, $4, $5 )",
+			 pool_config->system_db_schema,
+			 QUERY_CACHE_TABLE_NAME);
+	pg_result = PQprepare(system_db_info->pgconn,
+						  CACHE_TABLE_INFO.register_prepared_statement,
+						  sql,
+						  5,
+						  NULL);
+#else
+	snprintf(sql, sql_len,
+			 "PREPARE %s (TEXT, TEXT, BYTEA, TEXT, TIMESTAMP WITH TIME ZONE) AS INSERT INTO %s.%s VALUES ( $1, $2, $3, $4, $5 )",
+			 CACHE_TABLE_INFO.register_prepared_statement,
+			 pool_config->system_db_schema,
+			 QUERY_CACHE_TABLE_NAME);
+	pg_result = PQexec(system_db_info->pgconn, sql);
+#endif
+	if (!pg_result || PQresultStatus(pg_result) != PGRES_COMMAND_OK)
+	{
+		pool_error("pool_query_cache: PQprepare() failed: %s", PQerrorMessage(system_db_info->pgconn));
+		free(CACHE_TABLE_INFO.register_prepared_statement);
+		free(sql);
+		return;
+	}
+
+	pool_debug("pool_query_cache: prepared statements created");
+	CACHE_TABLE_INFO.has_prepared_statement = 1;
+
+	free(sql);
+	PQclear(pg_result);
+}
+
+/* --------------------------------
+ * Execute query cache look up
+ * --------------------------------
+ */
+POOL_STATUS pool_execute_query_cache_lookup(POOL_CONNECTION *frontend, POOL_CONNECTION_POOL *backend, Node *node)
+{
+	SelectStmt *select = (SelectStmt *)node;
+	POOL_STATUS status = POOL_END;	/* cache not found */
+
+	if (! (select->intoClause || select->lockingClause))
+	{
+		parsed_query = strdup(nodeToString(node));
+		if (parsed_query == NULL)
+		{
+			pool_error("pool_execute_query_cache_lookup: malloc failed");
+			return POOL_ERROR;
+		}
+
+		status = pool_query_cache_lookup(frontend, parsed_query, backend->info->database, TSTATE(backend, MASTER_NODE_ID));
+		if (status == POOL_CONTINUE)
+		{
+			free(parsed_query);
+			parsed_query = NULL;
+		}
+	}
+
+	return status;
+}