prestogres 0.1.0 → 0.2.0

data/pgpool2/pool_proto_modules.c

@@ -896,6 +896,9 @@ POOL_STATUS Parse(POOL_CONNECTION *frontend, POOL_CONNECTION_POOL *backend,
 	POOL_SESSION_CONTEXT *session_context;
 	POOL_QUERY_CONTEXT *query_context;
 
+	pool_error("Parse: Prestogres doesn't support extended query");
+	return POOL_END;
+
 	/* Get session context */
 	session_context = pool_get_session_context();
 	if (!session_context)
@@ -1031,16 +1034,6 @@ POOL_STATUS Parse(POOL_CONNECTION *frontend, POOL_CONNECTION_POOL *backend,
 		 */
 		pool_where_to_send(query_context, query_context->original_query,
 						   query_context->parse_tree);
-		{
-			int alloc_len = len - strlen(stmt) + strlen(query_context->original_query);
-			contents = palloc(alloc_len);
-			strcpy(contents, name);
-			strcpy(contents + strlen(name) + 1, query_context->original_query);
-			memcpy(contents + strlen(name) + 1 + strlen(query_context->original_query) + 1,
-					stmt + strlen(stmt) + 1,
-					len - (strlen(name) + 1 + strlen(stmt) + 1));
-			len = alloc_len;
-		}
 
 		if (REPLICATION)
 		{

data/pgpool2/pool_query_context.c

@@ -289,122 +289,244 @@ int pool_virtual_master_db_node_id(void)
 	return my_master_node_id;
 }
 
-char rewrite_query_string_buffer[QUERY_STRING_BUFFER_LEN];
-
 #ifndef PRESTO_RESULT_TABLE_NAME
 #define PRESTO_RESULT_TABLE_NAME "presto_result"
 #endif
 
-static POOL_STATUS run_clear_query(POOL_SESSION_CONTEXT* session_context, POOL_QUERY_CONTEXT* query_context)
+char rewrite_query_string_buffer[QUERY_STRING_BUFFER_LEN];
+
+static char *strcpy_capped(char *buffer, int length, const char *string)
 {
-    //POOL_STATUS status;
-    //POOL_SELECT_RESULT *res;
-    //POOL_CONNECTION *con;
-	//POOL_CONNECTION_POOL *backend = session_context->backend;
-    //con = CONNECTION(backend, session_context->load_balance_node_id);
+	int slen;
 
-    // do something if multi-statement?
+	if (buffer == NULL) {
+		return NULL;
+	}
 
-	return POOL_CONTINUE;
+	slen = strlen(string);
+	if (length <= slen) {
+		return NULL;
+	}
+
+	memcpy(buffer, string, slen + 1);
+	return buffer + slen;
 }
 
-static POOL_STATUS run_system_catalog_query(POOL_SESSION_CONTEXT* session_context, POOL_QUERY_CONTEXT* query_context)
+static char *strcpy_capped_escaped(char *buffer, int length, const char *string, const char *escape_chars)
 {
-    POOL_STATUS status;
-    POOL_SELECT_RESULT *res;
-    POOL_CONNECTION *con;
-	POOL_CONNECTION_POOL *backend = session_context->backend;
-    con = CONNECTION(backend, session_context->load_balance_node_id);
+	char *bpos, *bend;
+	const char *spos, *send;
+	bool escaped = false;
 
-    snprintf(rewrite_query_string_buffer, sizeof(rewrite_query_string_buffer),
-            "select presto_create_tables('%s', '%s', '%s')",
-            presto_server, presto_user, presto_catalog);
-    status = do_query(con, rewrite_query_string_buffer, &res, MAJOR(backend));
-    free_select_result(res);
+	if (buffer == NULL) {
+		return NULL;
+	}
 
-    if (status != POOL_CONTINUE) {
-        // TODO error message
-        return status;
-    }
+	bpos = buffer;
+	bend = buffer + length;
+	spos = string;
+	send = string + strlen(string);
+	while (spos < send) {
+		if (bpos >= bend) {
+			return NULL;
+		}
 
-	return POOL_CONTINUE;
-}
+		if (escaped) {
+			*bpos = *spos;
+			escaped = false;
+			spos++;
+		} else if (strchr(escape_chars, *spos) != NULL) {
+			*bpos = '\\';
+			escaped = true;
+		} else {
+			*bpos = *spos;
+			spos++;
+		}
 
-static char* escape_original_query(const char* original_query)
-{
-    char* query;
-    char* c;
+		bpos++;
+	}
 
-    query = malloc(QUERY_STRING_BUFFER_LEN);
-    strlcpy(query, original_query, QUERY_STRING_BUFFER_LEN);
+	if (bpos >= bend) {
+		return NULL;
+	}
+	*bpos = '\0';
 
-    // remove last ;
-    c = strrchr(query, ';');
-    if (c != NULL) {
-        *c = '\0';
-    }
+	return bpos;
+}
 
-    // TODO escape ' character
+static void do_replace_query(POOL_QUERY_CONTEXT* query_context, const char *query)
+{
+	char *dupq = pstrdup(query);
 
-    return query;
+	query_context->original_query = dupq;
+	query_context->original_length = strlen(dupq) + 1;
 }
 
-static POOL_STATUS run_presto_query(POOL_SESSION_CONTEXT* session_context, POOL_QUERY_CONTEXT* query_context)
+static void rewrite_error_query(POOL_QUERY_CONTEXT* query_context, const char *message, const char* errcode)
 {
-    POOL_STATUS status;
-    POOL_SELECT_RESULT *res;
-    POOL_CONNECTION *con;
-	POOL_CONNECTION_POOL *backend = session_context->backend;
-    con = CONNECTION(backend, session_context->load_balance_node_id);
-    char* query;
-
-    snprintf(rewrite_query_string_buffer, sizeof(rewrite_query_string_buffer),
-            "drop table if exists %s",
-            PRESTO_RESULT_TABLE_NAME);
-    status = do_query(con, rewrite_query_string_buffer, &res, MAJOR(backend));
-    free_select_result(res);
-
-    if (status != POOL_CONTINUE) {
-        // TODO error message
-        return status;
-    }
-
-    query = escape_original_query(query_context->original_query);
-    snprintf(rewrite_query_string_buffer, sizeof(rewrite_query_string_buffer),
-            "select run_presto_as_temp_table('%s', '%s', '%s', '%s', '%s', '%s')",
-            presto_server, presto_user, presto_catalog, presto_schema,
-            PRESTO_RESULT_TABLE_NAME, query);
-    free(query);
-
-    status = do_query(con, rewrite_query_string_buffer, &res, MAJOR(backend));
-    free_select_result(res);
-
-    if (status != POOL_CONTINUE) {
-        // TODO error message
-        return status;
-    }
+	char *buffer, *bufend;
+
+	buffer = rewrite_query_string_buffer;
+	bufend = buffer + sizeof(rewrite_query_string_buffer);
+
+	buffer = strcpy_capped(buffer, bufend - buffer, "do $$ begin raise ");
+	buffer = strcpy_capped(buffer, bufend - buffer, "exception '%', E'");
+	buffer = strcpy_capped_escaped(buffer, bufend - buffer, message, "'\\$");
+	buffer = strcpy_capped(buffer, bufend - buffer, "'");
+	if (errcode != NULL) {
+		buffer = strcpy_capped(buffer, bufend - buffer, " using errcode = E'");
+		buffer = strcpy_capped_escaped(buffer, bufend - buffer, errcode, "'\\$");
+		buffer = strcpy_capped(buffer, bufend - buffer, "'");
+	}
+	buffer = strcpy_capped(buffer, bufend - buffer, "; end $$ language plpgsql");
 
-	return POOL_CONTINUE;
+	if (buffer == NULL) {
+		do_replace_query(query_context,
+				"do $$ begin raise ecxeption 'too long error message'; end $$ language plpgsql");
+		return;
+	}
+
+	do_replace_query(query_context, rewrite_query_string_buffer);
 }
 
-static void do_replace_query(POOL_QUERY_CONTEXT* query_context, const char* query)
+static void run_clear_query(POOL_SESSION_CONTEXT* session_context, POOL_QUERY_CONTEXT* query_context)
 {
-    char* dupq = pstrdup(query);
-
-    query_context->original_query = dupq;
-    query_context->original_length = strlen(dupq) + 1;
+	// TODO
 }
 
-static void rewrite_presto_query(POOL_QUERY_CONTEXT* query_context)
+static void run_and_rewrite_system_catalog_query(POOL_SESSION_CONTEXT* session_context, POOL_QUERY_CONTEXT* query_context)
 {
-    snprintf(rewrite_query_string_buffer, sizeof(rewrite_query_string_buffer),
-            "select * from %s", PRESTO_RESULT_TABLE_NAME);
-    do_replace_query(query_context, rewrite_query_string_buffer);
+	char *buffer, *bufend;
+	char *errmsg = NULL, *errcode = NULL;
+	POOL_STATUS status;
+	POOL_SELECT_RESULT *res;
+	POOL_CONNECTION *con;
+	POOL_CONNECTION_POOL *backend = session_context->backend;
+	con = CONNECTION(backend, session_context->load_balance_node_id);
+
+	/* build query */
+	buffer = rewrite_query_string_buffer;
+	bufend = buffer + sizeof(rewrite_query_string_buffer);
+
+	buffer = strcpy_capped(buffer, bufend - buffer, "select prestogres_catalog.run_system_catalog_as_temp_table(E'");
+	buffer = strcpy_capped_escaped(buffer, bufend - buffer, presto_server, "'\\");
+	buffer = strcpy_capped(buffer, bufend - buffer, "', E'");
+	buffer = strcpy_capped_escaped(buffer, bufend - buffer, presto_user, "'\\");
+	buffer = strcpy_capped(buffer, bufend - buffer, "', E'");
+	buffer = strcpy_capped_escaped(buffer, bufend - buffer, presto_catalog, "'\\");
+	buffer = strcpy_capped(buffer, bufend - buffer, "', E'");
+	buffer = strcpy_capped_escaped(buffer, bufend - buffer, PRESTO_RESULT_TABLE_NAME, "'\\");
+	buffer = strcpy_capped(buffer, bufend - buffer, "', E'");
+	buffer = strcpy_capped_escaped(buffer, bufend - buffer, query_context->original_query, "'\\");
+	buffer = strcpy_capped(buffer, bufend - buffer, "')");
+
+	if (buffer == NULL) {
+		rewrite_error_query(query_context, "metadata too long", NULL);
+		return;
+	}
+
+	/* run query */
+	status = do_query_or_get_error_message(con,
+			rewrite_query_string_buffer, &res, MAJOR(backend), &errmsg, &errcode);
+	free_select_result(res);
+
+	if (errmsg != NULL) {
+		rewrite_error_query(query_context, errmsg, errcode);
+	} else if (status != POOL_CONTINUE) {
+		rewrite_error_query(query_context, "Unknown execution error", NULL);
+	}
+
+	/* rewrite query */
+	buffer = rewrite_query_string_buffer;
+	bufend = buffer + sizeof(rewrite_query_string_buffer);
+
+	buffer = strcpy_capped(buffer, bufend - buffer, "select * from ");
+	buffer = strcpy_capped(buffer, bufend - buffer, PRESTO_RESULT_TABLE_NAME);
+
+	if (buffer == NULL) {
+		rewrite_error_query(query_context, "query too long", NULL);
+		return;
+	}
+
+	do_replace_query(query_context, rewrite_query_string_buffer);
 }
 
-static void rewrite_error_query(POOL_QUERY_CONTEXT* query_context, const char* message)
+static void run_and_rewrite_presto_query(POOL_SESSION_CONTEXT* session_context, POOL_QUERY_CONTEXT* query_context)
 {
-    // TODO
+	char *buffer, *bufend;
+	char *errmsg = NULL, *errcode = NULL;
+	POOL_STATUS status;
+	POOL_SELECT_RESULT *res;
+	POOL_CONNECTION *con;
+	POOL_CONNECTION_POOL *backend = session_context->backend;
+	con = CONNECTION(backend, session_context->load_balance_node_id);
+
+	/* build query */
+	buffer = rewrite_query_string_buffer;
+	bufend = buffer + sizeof(rewrite_query_string_buffer);
+
+	buffer = strcpy_capped(buffer, bufend - buffer, "select prestogres_catalog.run_presto_as_temp_table(E'");
+	buffer = strcpy_capped_escaped(buffer, bufend - buffer, presto_server, "'\\");
+	buffer = strcpy_capped(buffer, bufend - buffer, "', E'");
+	buffer = strcpy_capped_escaped(buffer, bufend - buffer, presto_user, "'\\");
+	buffer = strcpy_capped(buffer, bufend - buffer, "', E'");
+	buffer = strcpy_capped_escaped(buffer, bufend - buffer, presto_catalog, "'\\");
+	buffer = strcpy_capped(buffer, bufend - buffer, "', E'");
+	buffer = strcpy_capped_escaped(buffer, bufend - buffer, presto_schema, "'\\");
+	buffer = strcpy_capped(buffer, bufend - buffer, "', E'");
+	buffer = strcpy_capped_escaped(buffer, bufend - buffer, PRESTO_RESULT_TABLE_NAME, "'\\");
+	buffer = strcpy_capped(buffer, bufend - buffer, "', E'");
+	{
+		char *query = query_context->original_query;
+		char *c = strrchr(query, ';');
+		int save;
+
+		// remove last ';'
+		if (c != NULL) {
+			save = *c;
+			*c = '\0';
+		}
+
+		buffer = strcpy_capped_escaped(buffer, bufend - buffer, query, "'\\");
+
+		// restore last ';'
+		if (c != NULL) {
+			*c = save;
+		}
+	}
+	buffer = strcpy_capped(buffer, bufend - buffer, "')");
+
+	if (buffer == NULL) {
+		rewrite_error_query(query_context, "query too long", NULL);
+		return;
+	}
+
+	/* run query */
+	status = do_query_or_get_error_message(con,
+			rewrite_query_string_buffer, &res, MAJOR(backend), &errmsg, &errcode);
+	free_select_result(res);
+
+	if (errmsg != NULL) {
+		rewrite_error_query(query_context, errmsg, errcode);
+		return;
+	} else if (status != POOL_CONTINUE) {
+		rewrite_error_query(query_context, "Unknown execution error", NULL);
+		return;
+	}
+
+	/* rewrite query */
+	buffer = rewrite_query_string_buffer;
+	bufend = buffer + sizeof(rewrite_query_string_buffer);
+
+	buffer = strcpy_capped(buffer, bufend - buffer, "select * from ");
+	buffer = strcpy_capped(buffer, bufend - buffer, PRESTO_RESULT_TABLE_NAME);
+
+	if (buffer == NULL) {
+		rewrite_error_query(query_context, "query too long", NULL);
+		return;
+	}
+
+	do_replace_query(query_context, rewrite_query_string_buffer);
 }
 
 /*
@@ -416,7 +538,6 @@ void pool_where_to_send(POOL_QUERY_CONTEXT *query_context, char *query, Node *no
 	POOL_CONNECTION_POOL *backend;
 	int i;
 
-	POOL_STATUS status;
 	const char* rewrite_error_message;
 	enum {
 		REWRITE_CLEAR,
@@ -502,13 +623,13 @@ void pool_where_to_send(POOL_QUERY_CONTEXT *query_context, char *query, Node *no
 		/* Should be sent to primary only? */
 		if (dest == POOL_PRIMARY)
 		{
-			pool_debug("pggw: send_to_where: POOL_PRIMARY\n");
+			pool_debug("prestogres: send_to_where: POOL_PRIMARY");
 			pool_set_node_to_be_sent(query_context, PRIMARY_NODE_ID);
 		}
 		/* Should be sent to both primary and standby? */
 		else if (dest == POOL_BOTH)
 		{
-			pool_debug("pggw: send_to_where: POOL_BOTH\n");
+			pool_debug("prestogres: send_to_where: POOL_BOTH");
 			pool_setall_node_to_be_sent(query_context);
 		}
 
@@ -545,7 +666,7 @@ void pool_where_to_send(POOL_QUERY_CONTEXT *query_context, char *query, Node *no
 						pool_config->delay_threshold &&
 						bkinfo->standby_delay > pool_config->delay_threshold)
 					{
-						pool_debug("pggw: send_to_where: replication delay\n");
+						pool_debug("prestogres: send_to_where: replication delay");
 						pool_set_node_to_be_sent(query_context, PRIMARY_NODE_ID);
 						rewrite_mode = REWRITE_ERROR;
 						rewrite_error_message = "unexpected replication delay";
@@ -557,7 +678,7 @@ void pool_where_to_send(POOL_QUERY_CONTEXT *query_context, char *query, Node *no
 					 */
 					else if (pool_has_function_call(node))
 					{
-						pool_debug("pggw: send_to_where: writing function\n");
+						pool_debug("prestogres: send_to_where: writing function");
 						pool_set_node_to_be_sent(query_context, PRIMARY_NODE_ID);
 					}
 
@@ -575,7 +696,7 @@ void pool_where_to_send(POOL_QUERY_CONTEXT *query_context, char *query, Node *no
 					 */
 					else if (pool_has_system_catalog(node))
 					{
-						pool_debug("pggw: send_to_where: system catalog\n");
+						pool_debug("prestogres: send_to_where: system catalog");
 						pool_set_node_to_be_sent(query_context, PRIMARY_NODE_ID);
 						rewrite_mode = REWRITE_SYSTEM_CATALOG;
 					}
@@ -586,7 +707,7 @@ void pool_where_to_send(POOL_QUERY_CONTEXT *query_context, char *query, Node *no
 					 */
 					else if (pool_config->check_temp_table && pool_has_temp_table(node))
 					{
-						pool_debug("pggw: send_to_where: temporary table\n");
+						pool_debug("prestogres: send_to_where: temporary table");
 						pool_set_node_to_be_sent(query_context,
 												 session_context->load_balance_node_id);
 						rewrite_mode = REWRITE_PRESTO;
@@ -598,7 +719,7 @@ void pool_where_to_send(POOL_QUERY_CONTEXT *query_context, char *query, Node *no
 					 */
 					else if (pool_has_unlogged_table(node))
 					{
-						pool_debug("pggw: send_to_where: unlogged table\n");
+						pool_debug("prestogres: send_to_where: unlogged table");
 						pool_set_node_to_be_sent(query_context,
 												 session_context->load_balance_node_id);
 						rewrite_mode = REWRITE_PRESTO;
@@ -610,14 +731,14 @@ void pool_where_to_send(POOL_QUERY_CONTEXT *query_context, char *query, Node *no
 					 */
 					else if (!pool_has_relation(node))
 					{
-						pool_debug("pggw: send_to_where: no relation\n");
+						pool_debug("prestogres: send_to_where: no relation");
 						pool_set_node_to_be_sent(query_context, PRIMARY_NODE_ID);
 						rewrite_mode = REWRITE_SYSTEM_CATALOG;
 					}
 
 					else
 					{
-						pool_debug("pggw: send_to_where: load balance\n");
+						pool_debug("prestogres: send_to_where: load balance");
 						pool_set_node_to_be_sent(query_context,
 												 session_context->load_balance_node_id);
 						rewrite_mode = REWRITE_PRESTO;
@@ -626,7 +747,7 @@ void pool_where_to_send(POOL_QUERY_CONTEXT *query_context, char *query, Node *no
 				else
 				{
 					/* Send to the primary only */
-					pool_debug("pggw: send_to_where: invalid session state\n");
+					pool_debug("prestogres: send_to_where: invalid session state");
 					pool_set_node_to_be_sent(query_context, PRIMARY_NODE_ID);
 					rewrite_mode = REWRITE_ERROR;
 					rewrite_error_message = "invalid session state";
@@ -635,7 +756,7 @@ void pool_where_to_send(POOL_QUERY_CONTEXT *query_context, char *query, Node *no
 			else
 			{
 				/* Send to the primary only */
-				pool_debug("pggw: send_to_where: non-select\n");
+				pool_debug("prestogres: send_to_where: non-select");
 				pool_set_node_to_be_sent(query_context, PRIMARY_NODE_ID);
 				rewrite_mode = REWRITE_ERROR;
 				rewrite_error_message = "only SELECT is supported";
@@ -732,32 +853,21 @@ void pool_where_to_send(POOL_QUERY_CONTEXT *query_context, char *query, Node *no
 
 	switch (rewrite_mode) {
 	case REWRITE_CLEAR:
-		status = run_clear_query(session_context, query_context);
+		run_clear_query(session_context, query_context);
 		break;
 
 	case REWRITE_SYSTEM_CATALOG:
-		status = run_system_catalog_query(session_context, query_context);
+		run_and_rewrite_system_catalog_query(session_context, query_context);
 		break;
 
 	case REWRITE_PRESTO:
-		status = run_presto_query(session_context, query_context);
-		rewrite_presto_query(query_context);
+		run_and_rewrite_presto_query(session_context, query_context);
 		break;
 
 	case REWRITE_ERROR:
-		rewrite_error_query(query_context, rewrite_error_message);
-		status = POOL_CONTINUE;
+		rewrite_error_query(query_context, rewrite_error_message, NULL);
 		break;
 	}
-
-    if (status != POOL_CONTINUE) {
-		pool_error("presto-pggw: query failed");
-		return;
-    }
-
-	pool_debug("exec status: %d  POOL_CONTINUE=%d\n", status, POOL_CONTINUE);
-
-	return;
 }
 
 /*