prestogres 0.1.0

data/pgpool2/pool_query_context.h

@@ -0,0 +1,105 @@
+/* -*-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_process_context.h.: process context information
+ *
+ */
+
+#ifndef POOL_QUERY_CONTEXT_H
+#define POOL_QUERY_CONTEXT_H
+
+#include "pool.h"
+#include "pool_process_context.h"
+#include "parser/nodes.h"
+#include "parser/parsenodes.h"
+#include "parser/pool_memory.h"
+#include "pool_memqcache.h"
+
+/*
+ * Parse state transition.
+ * transition order is:
+ * UNPARSED < PARSE_COMPLETE < BIND_COMPLETE < EXECUTE_COMPLETE
+ */
+typedef enum {
+	POOL_UNPARSED,
+	POOL_PARSE_COMPLETE,
+	POOL_BIND_COMPLETE,
+	POOL_EXECUTE_COMPLETE
+} POOL_QUERY_STATE;
+
+/*
+ * Query context:
+ * Manages per query context
+ */
+typedef struct {
+	char *original_query;		/* original query string */
+	char *rewritten_query;		/* rewritten query string if any */
+	int original_length;	   	/* original query length which contains '\0' */
+	int rewritten_length;	   	/* rewritten query length which contains '\0' if any */
+	Node *parse_tree;			/* raw parser output if any */
+	Node *rewritten_parse_tree;	/* rewritten raw parser output if any */
+	bool where_to_send[MAX_NUM_BACKENDS];	/* DB node map to send query */
+	int  virtual_master_node_id;	   		/* the 1st DB node to send query */
+	POOL_MEMORY_POOL *memory_context;		/* memory context for query */
+	POOL_QUERY_STATE query_state[MAX_NUM_BACKENDS];	/* for extended query protocol */
+	bool is_cache_safe;	/* true if SELECT is safe to cache */
+	POOL_TEMP_QUERY_CACHE *temp_cache;	/* temporary cache */
+	bool is_multi_statement;	/* true if multi statement query */
+	int dboid;	/* DB oid which is used at DROP DATABASE */
+	char *query_w_hex;	/* original_query with bind message hex which used for committing cache of extended query */
+	bool is_parse_error;		/* if true, we could not parse the original
+								 * query and parsed node is actually a dummy query.
+								 */
+} POOL_QUERY_CONTEXT;
+
+extern POOL_QUERY_CONTEXT *pool_init_query_context(void);
+extern void pool_query_context_destroy(POOL_QUERY_CONTEXT *query_context);
+extern void pool_start_query(POOL_QUERY_CONTEXT *query_context, char *query, int len, Node *node);
+extern void pool_set_node_to_be_sent(POOL_QUERY_CONTEXT *query_context, int node_id);
+extern void pool_unset_node_to_be_sent(POOL_QUERY_CONTEXT *query_context, int node_id);
+extern bool pool_is_node_to_be_sent(POOL_QUERY_CONTEXT *query_context, int node_id);
+extern void pool_set_node_to_be_sent(POOL_QUERY_CONTEXT *query_context, int node_id);
+extern void pool_unset_node_to_be_sent(POOL_QUERY_CONTEXT *query_context, int node_id);
+extern void pool_clear_node_to_be_sent(POOL_QUERY_CONTEXT *query_context);
+extern void pool_setall_node_to_be_sent(POOL_QUERY_CONTEXT *query_context);
+extern bool pool_multi_node_to_be_sent(POOL_QUERY_CONTEXT *query_context);
+extern void pool_where_to_send(POOL_QUERY_CONTEXT *query_context, char *query, Node *node);
+extern POOL_STATUS pool_send_and_wait(POOL_QUERY_CONTEXT *query_context, int send_type, int node_id);
+extern POOL_STATUS pool_extended_send_and_wait(POOL_QUERY_CONTEXT *query_context, char *kind, int len, char *contents, int send_type, int node_id);
+extern Node *pool_get_parse_tree(void);
+extern char *pool_get_query_string(void);
+extern bool is_set_transaction_serializable(Node *node);
+extern bool is_start_transaction_query(Node *node);
+extern bool is_read_write(TransactionStmt *node);
+extern bool is_serializable(TransactionStmt *node);
+extern bool pool_need_to_treat_as_if_default_transaction(POOL_QUERY_CONTEXT *query_context);
+extern bool is_savepoint_query(Node *node);
+extern bool is_2pc_transaction_query(Node *node);
+extern void pool_set_query_state(POOL_QUERY_CONTEXT *query_context, POOL_QUERY_STATE state);
+extern int statecmp(POOL_QUERY_STATE s1, POOL_QUERY_STATE s2);
+extern bool pool_is_cache_safe(void);
+extern void pool_set_cache_safe(void);
+extern void pool_unset_cache_safe(void);
+extern bool pool_is_cache_exceeded(void);
+extern void pool_set_cache_exceeded(void);
+extern void pool_unset_cache_exceeded(void);
+
+#endif /* POOL_QUERY_CONTEXT_H */

data/pgpool2/pool_relcache.c

@@ -0,0 +1,284 @@
+/* -*-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_relcache.c: Per process relation cache modules
+ */
+#include "config.h"
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+
+#include "pool.h"
+#include "pool_relcache.h"
+#include "pool_session_context.h"
+#include "pool_config.h"
+
+/*
+ * Create relation cache
+ */
+POOL_RELCACHE *pool_create_relcache(int cachesize, char *sql,
+									func_ptr register_func, func_ptr unregister_func,
+									bool issessionlocal)
+{
+	POOL_RELCACHE *p;
+	PoolRelCache *ip;
+
+	if (cachesize < 0)
+	{
+		pool_error("pool_create_relcache: wrong cache size: %d", cachesize);
+		return NULL;
+	}
+
+	ip = (PoolRelCache *)malloc(sizeof(PoolRelCache)*cachesize);
+	if (ip == NULL)
+	{
+		pool_error("pool_create_relcache: cannot allocate memory %zd", sizeof(PoolRelCache)*cachesize);
+		return NULL;
+	}
+	memset(ip, 0, sizeof(PoolRelCache)*cachesize);
+
+	p = (POOL_RELCACHE *)malloc(sizeof(POOL_RELCACHE));
+	if (p == NULL)
+	{
+		pool_error("pool_create_relcache: cannot allocate memory %zd", sizeof(POOL_RELCACHE));
+		free(ip);
+		return NULL;
+	}
+
+	p->num = cachesize;
+	strlcpy(p->sql, sql, sizeof(p->sql));
+	p->register_func = register_func;
+	p->unregister_func = unregister_func;
+	p->cache_is_session_local = issessionlocal;
+	p->no_cache_if_zero = false;
+	p->cache = ip;
+	
+	return p;
+}
+/*
+ * Discard relation cache.
+ */
+void pool_discard_relcache(POOL_RELCACHE *relcache)
+{
+	int i;
+
+	for (i=0;i<relcache->num;i++)
+	{
+		(*relcache->unregister_func)(relcache->cache[i].data);
+	}
+	free(relcache->cache);
+	free(relcache);
+}
+
+/*
+ * Search relcache. If found, return user data. Otherwise return 0.
+ * If not found in cache, do the query and store the result into cache and return it.
+ */
+void *pool_search_relcache(POOL_RELCACHE *relcache, POOL_CONNECTION_POOL *backend, char *table)
+{
+	char *rel;
+	char *dbname;
+	int i;
+	int maxrefcnt = INT_MAX;
+	char query[1024];
+	POOL_SELECT_RESULT *res = NULL;
+	int index = 0;
+	int local_session_id;
+	time_t now;
+	void *result;
+
+	/* Eliminate double quotes */
+	rel = malloc(strlen(table)+1);
+	if (!rel)
+	{
+		pool_error("pool_search_relcache: malloc failed");
+		return NULL;
+	}
+
+	local_session_id = pool_get_local_session_id();
+	if (local_session_id < 0)
+	{
+		pool_error("pool_search_relcache: pool_get_local_session_id failed");
+		return NULL;
+	}
+
+	for(i=0;*table;table++)
+	{
+		if (*table != '"')
+			rel[i++] = *table;
+	}
+	rel[i] = '\0';
+
+	/* Obtain database name */
+	dbname = MASTER_CONNECTION(backend)->sp->database;
+
+	now = time(NULL);
+
+	/* Look for cache first */
+	for (i=0;i<relcache->num;i++)
+	{
+		/*
+		 * If cache is session local, we need to check session id
+		 */
+		if (relcache->cache_is_session_local)
+		{
+			if (relcache->cache[i].session_id != local_session_id)
+				continue;
+		}
+
+		if (strcasecmp(relcache->cache[i].dbname, dbname) == 0 &&
+			strcasecmp(relcache->cache[i].relname, rel) == 0)
+		{
+			if (relcache->cache[i].expire > 0)
+			{
+				if (now > relcache->cache[i].expire)
+				{
+					pool_debug("pool_search_relcache: relcache for database:%s table:%s expired. now:%ld expiration time:%ld", dbname, rel, now, relcache->cache[i].expire);
+					relcache->cache[i].refcnt = 0;
+					break;
+				}
+			}
+
+			/* Found */
+			if (relcache->cache[i].refcnt < INT_MAX)
+				relcache->cache[i].refcnt++;
+			free(rel);
+			return relcache->cache[i].data;
+		}
+	}
+
+	/* Not in cache. Check the system catalog */
+	snprintf(query, sizeof(query), relcache->sql, rel);
+
+	per_node_statement_log(backend, MASTER_NODE_ID, query);
+
+	if (do_query(MASTER(backend), query, &res, MAJOR(backend)) != POOL_CONTINUE)
+	{
+		pool_error("pool_search_relcache: do_query failed");
+		if (res)
+			free_select_result(res);
+		free(rel);
+		return NULL;
+	}
+
+	/*
+	 * Look for replacement in cache
+	 */
+	for (i=0;i<relcache->num;i++)
+	{
+		/*
+		 * If cache is session local, we can discard old cache immediately
+		 */
+		if (relcache->cache_is_session_local)
+		{
+			if (relcache->cache[i].session_id != local_session_id)
+			{
+				index = i;
+				relcache->cache[i].refcnt = 0;
+				break;
+			}
+		}
+
+		if (relcache->cache[i].refcnt == 0)
+		{
+			/* Found empty slot */
+			index = i;
+			break;
+		}
+		else if (relcache->cache[i].refcnt < maxrefcnt)
+		{
+			maxrefcnt = relcache->cache[i].refcnt;
+			index = i;
+		}
+	}
+
+	if (relcache->cache[index].refcnt != 0)
+	{
+		pool_log("pool_search_relcache: cache replacement happend");
+	}
+
+	/* Register cache */
+	result = (*relcache->register_func)(res);
+
+	if (!relcache->no_cache_if_zero || result)
+	{
+		strlcpy(relcache->cache[index].dbname, dbname, MAX_ITEM_LENGTH);
+		strlcpy(relcache->cache[index].relname, rel, MAX_ITEM_LENGTH);
+		relcache->cache[index].refcnt = 1;
+		relcache->cache[index].session_id = local_session_id;
+		if (pool_config->relcache_expire > 0)
+		{
+			relcache->cache[index].expire = now + pool_config->relcache_expire;
+		}
+		else
+		{
+			relcache->cache[index].expire = 0;
+		}
+		/*
+		 * Call user defined unregister/register function.
+		 */
+		(*relcache->unregister_func)(relcache->cache[index].data);
+		relcache->cache[index].data = result;
+	}
+	free(rel);
+	free_select_result(res);
+
+	return 	result;
+}
+
+/*
+ * Standard register/unregister function for "SELECT count(*)" type
+ * query. Returns row count.
+ */
+void *int_register_func(POOL_SELECT_RESULT *res)
+{
+	if (res->numrows >= 1)
+		return (void *)atol(res->data[0]);
+	return (void *)0;
+}
+
+void *int_unregister_func(void *data)
+{
+	/* Nothing to do since no memory was allocated */
+	return NULL;
+}
+
+void *string_register_func(POOL_SELECT_RESULT *res)
+{
+	char	*ret = NULL;
+	int		 i;
+
+	if (res->numrows == 0)
+		return NULL;
+
+	for (i = 0; i < res->numrows; i++)
+	{
+		ret = strdup(res->data[i]);
+		break;
+	}
+
+	return (void *)ret;
+}
+
+void *string_unregister_func(void *data)
+{
+	free(data);
+	return data;
+}

data/pgpool2/pool_relcache.h

@@ -0,0 +1,78 @@
+/* -*-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_relcache.h.: pool_relcache.c related header file
+ *
+ */
+
+#ifndef POOL_RELCACHE_H
+#define POOL_RELCACHE_H
+
+/* ------------------------
+ * Relation cache structure
+ *-------------------------
+*/
+#define MAX_ITEM_LENGTH	1024
+
+/* Relation lookup cache structure */
+
+typedef void *(*func_ptr) ();
+
+typedef struct {
+	char dbname[MAX_ITEM_LENGTH];	/* database name */
+	char relname[MAX_ITEM_LENGTH];	/* table name */
+	void *data;	/* user data */
+	int refcnt;		/* reference count */
+	int session_id;		/* LocalSessionId */
+	time_t expire;		/* cache expiration absolute time in seconds */
+} PoolRelCache;
+
+typedef struct {
+	int num;		/* number of cache items */
+	char sql[MAX_ITEM_LENGTH];	/* Query to relation */
+	/*
+	 * User defined function to be called at data register.
+	 * Argument is POOL_SELECT_RESULT *.
+	 * This function must return a pointer to be
+	 * saved in cache->data.
+	 */
+	func_ptr	register_func;
+	/*
+	 * User defined function to be called at data unregister.
+	 * Argument cache->data.
+	 */
+	func_ptr	unregister_func;
+	bool cache_is_session_local;		/* True if cache life time is session local */
+	bool no_cache_if_zero;		/* if register func returns 0, do not cache the data */
+	PoolRelCache *cache;	/* cache data */
+} POOL_RELCACHE;
+
+extern POOL_RELCACHE *pool_create_relcache(int cachesize, char *sql,
+									func_ptr register_func, func_ptr unregister_func,
+									bool issessionlocal);
+extern void pool_discard_relcache(POOL_RELCACHE *relcache);
+extern void *pool_search_relcache(POOL_RELCACHE *relcache, POOL_CONNECTION_POOL *backend, char *table);
+extern void *int_register_func(POOL_SELECT_RESULT *res);
+extern void *int_unregister_func(void *data);
+extern void *string_register_func(POOL_SELECT_RESULT *res);
+extern void *string_unregister_func(void *data);
+
+#endif /* POOL_RELCACHE_H */