You are viewing a plain text version of this content. The canonical link for it is here.
Posted to sandesha-dev@ws.apache.org by da...@apache.org on 2007/01/11 06:27:22 UTC

svn commit: r495125 [2/4] - in /webservices/sandesha/trunk/c: include/ samples/rm_echo/ src/client/ src/handlers/ src/msgprocessors/ src/storage/ src/storage/beans/ src/storage/inmemory/ src/storage/permanent/ src/util/ src/workers/ src/wsrm/

Modified: webservices/sandesha/trunk/c/src/storage/permanent/permanent_bean_mgr.c
URL: http://svn.apache.org/viewvc/webservices/sandesha/trunk/c/src/storage/permanent/permanent_bean_mgr.c?view=diff&rev=495125&r1=495124&r2=495125
==============================================================================
--- webservices/sandesha/trunk/c/src/storage/permanent/permanent_bean_mgr.c (original)
+++ webservices/sandesha/trunk/c/src/storage/permanent/permanent_bean_mgr.c Wed Jan 10 21:27:18 2007
@@ -14,8 +14,9 @@
  * limitations under the License.
  */
  
-#include "sandesha2_permanent_bean_mgr.h"
+#include <sandesha2_permanent_bean_mgr.h>
 #include <sandesha2_constants.h>
+#include <sandesha2_permanent_bean_mgr.h>
 #include <sandesha2_error.h>
 #include <sandesha2_storage_mgr.h>
 #include <sandesha2_property_bean.h>
@@ -26,7 +27,6 @@
 #include <axis2_thread.h>
 #include <axis2_property.h>
 #include <axis2_conf_ctx.h>
-#include <sqlite3.h>
 #include <axis2_types.h>
 #include <platforms/axis2_platform_auto_sense.h>
 
@@ -45,242 +45,90 @@
 #define SANDESHA2_INTF_TO_IMPL(bean_mgr) \
     ((sandesha2_permanent_bean_mgr_impl_t *) bean_mgr)
 
-static int
-sandesha2_permanent_bean_mgr_busy_handler(
-    sqlite3_stmt* stmt,
-    int rc);
-
-static void 
-sandesha2_permanent_bean_mgr_handle_sql_error(
-    const axis2_env_t *env,
-    sqlite3 *dbconn,
-    axis2_char_t *sql_stmt);
-
-static axis2_status_t 
-sandesha2_msg_retrieve_callback(
-    const axis2_env_t *env,
-    sqlite3_stmt *stmt,
-    int (*busy_handler)(sqlite3_stmt* stmt, int rc),
-    void *key,
-    axis2_array_list_t *data_list)
-{
-    int rc = -1;
-    sandesha2_msg_store_bean_t *bean = (sandesha2_msg_store_bean_t *) 
-        sandesha2_msg_store_bean_create(env);
-    axis2_char_t *stored_key = (axis2_char_t *) key;
-    if(stored_key)
+static int 
+sandesha2_msg_store_bean_retrieve_callback(
+    void *not_used, 
+    int argc, 
+    char **argv, 
+    char **col_name)
+{
+    int i = 0;
+    sandesha2_bean_mgr_args_t *args = (sandesha2_bean_mgr_args_t *) not_used;
+    const axis2_env_t *env = args->env;
+    sandesha2_msg_store_bean_t *bean = NULL;
+    if(argc < 1)
     {
-        if (sqlite3_bind_text(stmt, 1, stored_key, axis2_strlen(stored_key), SQLITE_STATIC))
-        {
-            return AXIS2_FAILURE;
-        }
+        args->data = NULL;
+        return 0;
     }
-    rc = sqlite3_step(stmt);
-    if(rc == SQLITE_BUSY)
+    bean = (sandesha2_msg_store_bean_t *) args->data;
+    if(!bean)
     {
-        if(busy_handler(stmt, rc) != SQLITE_OK)
-        {
-            return AXIS2_FAILURE;
-        }
+        bean = sandesha2_msg_store_bean_create(env);
+        args->data = bean;
     }
-    if(rc == SQLITE_ROW)
+    for(i = 0; i < argc; i++)
     {
-        sandesha2_msg_store_bean_set_stored_key(bean, env, 
-            (axis2_char_t *) sqlite3_column_text(stmt, 0));
-        sandesha2_msg_store_bean_set_msg_id(bean, env, 
-            (axis2_char_t *) sqlite3_column_text(stmt, 1));
-        sandesha2_msg_store_bean_set_soap_envelope_str(bean, env, 
-            (axis2_char_t *) sqlite3_column_text(stmt, 2));
-        sandesha2_msg_store_bean_set_soap_version(bean, env, 
-            sqlite3_column_int(stmt, 3));
-        sandesha2_msg_store_bean_set_transport_out(bean, env, 
-            (axis2_char_t *) sqlite3_column_text(stmt, 4));
-        sandesha2_msg_store_bean_set_op(bean, env, 
-            (axis2_char_t *) sqlite3_column_text(stmt, 5));
-        sandesha2_msg_store_bean_set_svc(bean, env, 
-            (axis2_char_t *) sqlite3_column_text(stmt, 6));
-        sandesha2_msg_store_bean_set_svc_grp(bean, env, 
-            (axis2_char_t *) sqlite3_column_text(stmt, 7));
-        sandesha2_msg_store_bean_set_op_mep(bean, env, 
-            (axis2_char_t *) sqlite3_column_text(stmt, 8));
-        sandesha2_msg_store_bean_set_to_url(bean, env, 
-            (axis2_char_t *) sqlite3_column_text(stmt, 9));
-        sandesha2_msg_store_bean_set_reply_to(bean, env, 
-            (axis2_char_t *) sqlite3_column_text(stmt, 10));
-        sandesha2_msg_store_bean_set_transport_to(bean, env, 
-            (axis2_char_t *) sqlite3_column_text(stmt, 11));
-        sandesha2_msg_store_bean_set_execution_chain_str(bean, env, 
-            (axis2_char_t *) sqlite3_column_text(stmt, 12));
-        sandesha2_msg_store_bean_set_flow(bean, env, 
-            sqlite3_column_int(stmt, 13));
-        sandesha2_msg_store_bean_set_msg_recv_str(bean, env, 
-            (axis2_char_t *) sqlite3_column_text(stmt, 14));
-        sandesha2_msg_store_bean_set_svr_side(bean, env, 
-            sqlite3_column_int(stmt, 15));
-        sandesha2_msg_store_bean_set_in_msg_store_key(bean, env, 
-            (axis2_char_t *) sqlite3_column_text(stmt, 16));
-        sandesha2_msg_store_bean_set_persistent_property_str(bean, env, 
-            (axis2_char_t *) sqlite3_column_text(stmt, 17));
-        sandesha2_msg_store_bean_set_action(bean, env, 
-            (axis2_char_t *) sqlite3_column_text(stmt, 18));
-        rc = sqlite3_step(stmt);
-        if(rc == SQLITE_BUSY)
-        {
-            if(busy_handler(stmt, rc) != SQLITE_OK)
-            {
-                return AXIS2_FAILURE;
-            }
-        }
+        if(0 == AXIS2_STRCMP(col_name[i], "stored_key"))
+            if(argv[i])
+                sandesha2_msg_store_bean_set_stored_key(bean, env, argv[i]);
+        if(0 == AXIS2_STRCMP(col_name[i], "msg_id"))
+            if(argv[i])
+                sandesha2_msg_store_bean_set_msg_id(bean, env, argv[i]);
+        if(0 == AXIS2_STRCMP(col_name[i], "soap_env_str"))
+            if(argv[i])
+                sandesha2_msg_store_bean_set_soap_envelope_str(bean, env, 
+                    argv[i]);
+        if(0 == AXIS2_STRCMP(col_name[i], "soap_version"))
+            if(argv[i])
+                sandesha2_msg_store_bean_set_soap_version(bean, env, AXIS2_ATOI(argv[i]));
+        if(0 == AXIS2_STRCMP(col_name[i], "transport_out"))
+            if(argv[i])
+                sandesha2_msg_store_bean_set_transport_out(bean, env, argv[i]);
+        if(0 == AXIS2_STRCMP(col_name[i], "op"))
+            if(argv[i])
+                sandesha2_msg_store_bean_set_op(bean, env, argv[i]);
+        if(0 == AXIS2_STRCMP(col_name[i], "svc"))
+            if(argv[i])
+                sandesha2_msg_store_bean_set_svc(bean, env, argv[i]);
+        if(0 == AXIS2_STRCMP(col_name[i], "svc_grp"))
+            if(argv[i])
+                sandesha2_msg_store_bean_set_svc_grp(bean, env, argv[i]);
+        if(0 == AXIS2_STRCMP(col_name[i], "op_mep"))
+            if(argv[i])
+                sandesha2_msg_store_bean_set_op_mep(bean, env, argv[i]);
+        if(0 == AXIS2_STRCMP(col_name[i], "to_url"))
+            if(argv[i])
+                sandesha2_msg_store_bean_set_to_url(bean, env, argv[i]);
+        if(0 == AXIS2_STRCMP(col_name[i], "transport_to"))
+            if(argv[i])
+                sandesha2_msg_store_bean_set_transport_to(bean, env, argv[i]);
+        if(0 == AXIS2_STRCMP(col_name[i], "execution_chain_str"))
+            if(argv[i])
+                sandesha2_msg_store_bean_set_execution_chain_str(bean, env, argv[i]);
+        if(0 == AXIS2_STRCMP(col_name[i], "flow"))
+            if(argv[i])
+                sandesha2_msg_store_bean_set_flow(bean, env, AXIS2_ATOI(argv[i]));
+        if(0 == AXIS2_STRCMP(col_name[i], "msg_recv_str"))
+            if(argv[i])
+                sandesha2_msg_store_bean_set_msg_recv_str(bean, env, argv[i]);
+        if(0 == AXIS2_STRCMP(col_name[i], "svr_side"))
+            if(argv[i])
+                sandesha2_msg_store_bean_set_svr_side(bean, env, AXIS2_ATOI(argv[i]));
+        if(0 == AXIS2_STRCMP(col_name[i], "in_msg_store_key"))
+            if(argv[i])
+                sandesha2_msg_store_bean_set_in_msg_store_key(bean, env, argv[i]);
+        if(0 == AXIS2_STRCMP(col_name[i], "prop_str"))
+            if(argv[i])
+                sandesha2_msg_store_bean_set_persistent_property_str(bean, 
+                    env, argv[i]);
+        if(0 == AXIS2_STRCMP(col_name[i], "action"))
+            if(argv[i])
+                sandesha2_msg_store_bean_set_action(bean, env, argv[i]);
     }
-    axis2_array_list_add(data_list, env, bean);
-    return AXIS2_SUCCESS;
+    return 0;
 }
 
-static axis2_status_t 
-sandesha2_msg_update_or_insert_callback(
-    const axis2_env_t *env,
-    sqlite3_stmt *stmt,
-    int (*busy_handler)(sqlite3_stmt* stmt, int rc),
-    sandesha2_msg_store_bean_t *bean)
-{
-    if(!bean)
-        return AXIS2_FAILURE;
-    {
-        int rc = -1;
-		axis2_char_t *stored_key = NULL;
-		axis2_char_t *msg_id = NULL;
-		axis2_char_t *soap_env_str = NULL;
-		int soap_version = 0;
-		axis2_char_t *transport_out = NULL;
-		axis2_char_t *op = NULL;
-		axis2_char_t *svc = NULL;
-		axis2_char_t *svc_grp = NULL;
-		axis2_char_t *op_mep	= NULL;
-		axis2_char_t *to_url = NULL;
-		axis2_char_t *reply_to = NULL;
-		axis2_char_t *transport_to = NULL;
-		axis2_char_t *execution_chain_str = NULL;
-		int flow = 0;
-		axis2_char_t *msg_recv_str = NULL;
-		axis2_bool_t svr_side = AXIS2_FALSE;
-		axis2_char_t *in_msg_store_key = NULL;
-		axis2_char_t *prop_str = NULL;
-		axis2_char_t *action  = NULL;
-
-		stored_key = sandesha2_msg_store_bean_get_stored_key(bean, env);
-		msg_id = sandesha2_msg_store_bean_get_msg_id(bean, env);
-		soap_env_str = sandesha2_msg_store_bean_get_soap_envelope_str(bean, env);
-		soap_version = sandesha2_msg_store_bean_get_soap_version(
-            bean, env);
-		transport_out = sandesha2_msg_store_bean_get_transport_out(
-            bean, env);
-		op = sandesha2_msg_store_bean_get_op(bean, env);
-		svc = sandesha2_msg_store_bean_get_svc(bean, env);
-        svc_grp = sandesha2_msg_store_bean_get_svc_grp(bean, env);
-        op_mep = sandesha2_msg_store_bean_get_op_mep(bean, env);;
-        to_url = sandesha2_msg_store_bean_get_to_url(bean, env);
-        reply_to = sandesha2_msg_store_bean_get_reply_to(bean, env);
-		transport_to = sandesha2_msg_store_bean_get_transport_to(
-            bean, env);
-        execution_chain_str = sandesha2_msg_store_bean_get_execution_chain_str(bean, env);
-
-        flow = sandesha2_msg_store_bean_get_flow(bean, env);
-		msg_recv_str = sandesha2_msg_store_bean_get_msg_recv_str(bean, env);
-
-        svr_side = sandesha2_msg_store_bean_is_svr_side(bean, env);
-		in_msg_store_key = sandesha2_msg_store_bean_get_in_msg_store_key(bean, env);
-		prop_str = sandesha2_msg_store_bean_get_persistent_property_str(bean, env);
-		action = sandesha2_msg_store_bean_get_action(bean, env);
-       
-        if (sqlite3_bind_text(stmt, 1, msg_id, axis2_strlen(msg_id), SQLITE_STATIC))
-        {
-            return AXIS2_FAILURE;
-        }
-        if (sqlite3_bind_text(stmt, 2, soap_env_str, axis2_strlen(soap_env_str), SQLITE_STATIC))
-        {
-            return AXIS2_FAILURE;
-        }
-        if (sqlite3_bind_int(stmt, 3, soap_version))
-        {
-            return AXIS2_FAILURE;
-        }
-        if (sqlite3_bind_text(stmt, 4, transport_out, axis2_strlen(transport_out), SQLITE_STATIC))
-        {
-            return AXIS2_FAILURE;
-        }
-        if (sqlite3_bind_text(stmt, 5, op, axis2_strlen(op), SQLITE_STATIC))
-        {
-            return AXIS2_FAILURE;
-        }
-        if (sqlite3_bind_text(stmt, 6, svc, axis2_strlen(svc), SQLITE_STATIC))
-        {
-            return AXIS2_FAILURE;
-        }
-        if (sqlite3_bind_text(stmt, 7, svc_grp, axis2_strlen(svc_grp), SQLITE_STATIC))
-        {
-            return AXIS2_FAILURE;
-        }
-        if (sqlite3_bind_text(stmt, 8, op_mep, axis2_strlen(op_mep), SQLITE_STATIC))
-        {
-            return AXIS2_FAILURE;
-        }
-        if (sqlite3_bind_text(stmt, 9, to_url, axis2_strlen(to_url), SQLITE_STATIC))
-        {
-            return AXIS2_FAILURE;
-        }
-        if (sqlite3_bind_text(stmt, 10, reply_to, axis2_strlen(reply_to), SQLITE_STATIC))
-        {
-            return AXIS2_FAILURE;
-        }
-        if (sqlite3_bind_text(stmt, 11, transport_to, axis2_strlen(transport_to), SQLITE_STATIC))
-        {
-            return AXIS2_FAILURE;
-        }
-        if (sqlite3_bind_text(stmt, 12, execution_chain_str, axis2_strlen(execution_chain_str), SQLITE_STATIC))
-        {
-            return AXIS2_FAILURE;
-        }
-        if (sqlite3_bind_int(stmt, 13, flow))
-        {
-            return AXIS2_FAILURE;
-        }
-        if (sqlite3_bind_text(stmt, 14, msg_recv_str, axis2_strlen(msg_recv_str), SQLITE_STATIC))
-        {
-            return AXIS2_FAILURE;
-        }
-        if (sqlite3_bind_int(stmt, 15, svr_side))
-        {
-            return AXIS2_FAILURE;
-        }
-        if (sqlite3_bind_text(stmt, 16, in_msg_store_key, axis2_strlen(in_msg_store_key), SQLITE_STATIC))
-        {
-            return AXIS2_FAILURE;
-        }
-        if (sqlite3_bind_text(stmt, 17, prop_str, axis2_strlen(prop_str), SQLITE_STATIC))
-        {
-            return AXIS2_FAILURE;
-        }
-        if (sqlite3_bind_text(stmt, 18, action, axis2_strlen(action), SQLITE_STATIC))
-        {
-            return AXIS2_FAILURE;
-        }
-        if (sqlite3_bind_text(stmt, 19, stored_key, axis2_strlen(stored_key), SQLITE_STATIC))
-        {
-            return AXIS2_FAILURE;
-        }
-        rc = sqlite3_step(stmt);
-        if (rc == SQLITE_BUSY)
-        {
-            if(busy_handler(stmt, rc) != SQLITE_OK)
-            {
-                return AXIS2_FAILURE;
-            }
-        }
-        else if (rc == SQLITE_DONE)
-            return AXIS2_SUCCESS;
-    }
-    return AXIS2_FAILURE;
-}
 
 axis2_bool_t AXIS2_CALL
 sandesha2_permanent_bean_mgr_match(
@@ -346,99 +194,87 @@
 sandesha2_permanent_bean_mgr_insert(
     sandesha2_permanent_bean_mgr_t *bean_mgr,
     const axis2_env_t *env,
-    void *key,
     sandesha2_rm_bean_t *bean,
-    axis2_status_t (*retrieve_callback)(const axis2_env_t *, sqlite3_stmt *, int (*busy_handler)(
-        sqlite3_stmt*, int), void *, axis2_array_list_t *),
-    axis2_status_t (*update_or_insert_callback)(const axis2_env_t *, sqlite3_stmt *, int (*busy_handler)(
-        sqlite3_stmt*, int), sandesha2_rm_bean_t *),
+    int (*retrieve_func)(void *, int, char **, char **),
     axis2_char_t *sql_stmt_retrieve,
     axis2_char_t *sql_stmt_update,
     axis2_char_t *sql_stmt_insert)
 {
+    axis2_char_t *error_msg = NULL;
     int rc = -1;
     sqlite3 *dbconn = NULL;
-    sqlite3_stmt *stmt_retrieve = NULL;
-    sqlite3_stmt *stmt_update = NULL;
-    sqlite3_stmt *stmt_insert = NULL;
     sandesha2_rm_bean_t *retrieve_bean = NULL;
-    axis2_array_list_t *data_list = NULL;
+    sandesha2_bean_mgr_args_t *args = NULL;
     sandesha2_permanent_bean_mgr_impl_t *bean_mgr_impl = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FALSE);
     bean_mgr_impl = SANDESHA2_INTF_TO_IMPL(bean_mgr);
     
     sandesha2_storage_mgr_enlist_bean(bean_mgr_impl->storage_mgr, env, bean);
     axis2_thread_mutex_lock(bean_mgr_impl->mutex);
+    args = AXIS2_MALLOC(env->allocator, sizeof(sandesha2_bean_mgr_args_t));
+    args->env = env;
+    args->data = NULL;
     dbconn = (sqlite3 *) sandesha2_permanent_storage_mgr_get_dbconn(
         bean_mgr_impl->storage_mgr, env);
     if(!dbconn)
         return AXIS2_FALSE;
-    if(sqlite3_prepare(dbconn, sql_stmt_retrieve, AXIS2_STRLEN(sql_stmt_retrieve), 
-        &stmt_retrieve, NULL))
-    {
-        axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
-        sandesha2_permanent_bean_mgr_handle_sql_error(env, dbconn, 
-            sql_stmt_retrieve);
-        return AXIS2_FALSE;
-    }
-    data_list = axis2_array_list_create(env, 1);
-    rc = retrieve_callback(env, stmt_retrieve, sandesha2_permanent_bean_mgr_busy_handler, key, 
-        data_list);
-    if(rc != AXIS2_SUCCESS )
-    {
-        axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
-        if(data_list)
-            AXIS2_ARRAY_LIST_FREE(data_list, env);
-        sandesha2_permanent_bean_mgr_handle_sql_error(env, dbconn, 
-            sql_stmt_retrieve);
-        return AXIS2_FALSE;
-    }
-    if(0 < AXIS2_ARRAY_LIST_SIZE(data_list, env))
-        retrieve_bean = AXIS2_ARRAY_LIST_GET(data_list, env, 0);
-    if(data_list)
-        AXIS2_ARRAY_LIST_FREE(data_list, env);
-    sqlite3_reset(stmt_retrieve);
+    rc = sqlite3_exec(dbconn, sql_stmt_retrieve, retrieve_func, args,
+        &error_msg);
+    if(rc == SQLITE_BUSY)
+        rc = sandesha2_permanent_bean_mgr_busy_handler(dbconn, sql_stmt_retrieve, 
+            retrieve_func, args, &error_msg, rc);
+    if(rc != SQLITE_OK )
+    {
+        axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
+        AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_SQL_ERROR, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "sql stmt:%s. sql error: %s",
+            sql_stmt_retrieve, error_msg);
+        printf("sql_stmt_retrieve:%s\n", sql_stmt_retrieve);
+        printf("retrieve error_msg:%s\n", error_msg);
+        sqlite3_free(error_msg);
+        return AXIS2_FALSE;
+    }
+    if(args)
+        AXIS2_FREE(env->allocator, args);
+    retrieve_bean = (sandesha2_rm_bean_t *) args->data;
     if(retrieve_bean)
     {
-        if(sqlite3_prepare(dbconn, sql_stmt_update, AXIS2_STRLEN(sql_stmt_update), 
-            &stmt_update, NULL))
-        {
-            axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
-            sandesha2_permanent_bean_mgr_handle_sql_error(env, dbconn, 
-                sql_stmt_update);
-            return AXIS2_FALSE;
-        }
-        rc = update_or_insert_callback(env, stmt_update, sandesha2_permanent_bean_mgr_busy_handler, bean);
-        if(rc != AXIS2_SUCCESS)
+        rc = sqlite3_exec(dbconn, sql_stmt_update, 0, 0, &error_msg);
+        if(rc == SQLITE_BUSY)
+            rc = sandesha2_permanent_bean_mgr_busy_handler(dbconn, sql_stmt_update, 
+            0, 0, &error_msg, rc);
+        if( rc != SQLITE_OK )
         {
             axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
-            sandesha2_permanent_bean_mgr_handle_sql_error(env, dbconn, 
-                sql_stmt_update);
+            AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_SQL_ERROR, 
+                AXIS2_FAILURE);
+            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "sql stmt: %s.sql error: %s", 
+                sql_stmt_update, error_msg);
+            printf("sql_stmt_update:%s\n", sql_stmt_update);
+            printf("update error_msg:%s\n", error_msg);
+            sqlite3_free(error_msg);
             return AXIS2_FALSE;
         }
         axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
         return AXIS2_TRUE;
     }
-    sqlite3_reset(stmt_update);
     axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
     axis2_thread_mutex_lock(bean_mgr_impl->mutex);
-    if(sqlite3_prepare(dbconn, sql_stmt_insert, AXIS2_STRLEN(sql_stmt_insert), 
-        &stmt_insert, NULL))
-    {
-        axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
-        sandesha2_permanent_bean_mgr_handle_sql_error(env, dbconn, 
-            sql_stmt_insert);
-        return AXIS2_FALSE;
-    }
-    rc = update_or_insert_callback(env, stmt_insert, sandesha2_permanent_bean_mgr_busy_handler, bean);
-    if(rc != AXIS2_SUCCESS)
+    rc = sqlite3_exec(dbconn, sql_stmt_insert, 0, 0, &error_msg);
+    if(rc == SQLITE_BUSY)
+        rc = sandesha2_permanent_bean_mgr_busy_handler(dbconn, sql_stmt_insert, 
+            0, 0, &error_msg, rc);
+    if( rc != SQLITE_OK )
     {
         axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
-        sandesha2_permanent_bean_mgr_handle_sql_error(env, dbconn, 
-            sql_stmt_insert);
+        AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_SQL_ERROR, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "sql stmt: %s. sql error: %s", 
+            sql_stmt_insert, error_msg);
+        printf("sql_stmt_insert:%s\n", sql_stmt_insert);
+        printf("insert error_msg:%s\n", error_msg);
+        sqlite3_free(error_msg);
         return AXIS2_FALSE;
     }
-    sqlite3_reset(stmt_insert);
     axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
     return AXIS2_TRUE;
 }
@@ -447,21 +283,16 @@
 sandesha2_permanent_bean_mgr_remove(
     sandesha2_permanent_bean_mgr_t *bean_mgr,
     const axis2_env_t *env,
-    void *key, 
-    axis2_status_t (*retrieve_callback)(const axis2_env_t *, sqlite3_stmt *, int (*busy_handler)(
-        sqlite3_stmt*, int), void *, axis2_array_list_t *),
-    axis2_status_t (*remove_callback)(sqlite3_stmt *, int (*busy_handler)(
-        sqlite3_stmt*, int), void *),
+    int (*retrieve_func)(void *, int, char **, char **),
     axis2_char_t *sql_stmt_retrieve,
     axis2_char_t *sql_stmt_remove)
 {
     sandesha2_permanent_bean_mgr_impl_t *bean_mgr_impl = NULL;
+    sandesha2_bean_mgr_args_t *args = NULL;
+    axis2_char_t *error_msg = NULL;
     sandesha2_rm_bean_t *bean = NULL;
     sqlite3 *dbconn = NULL;
     int rc = -1;
-    sqlite3_stmt *stmt_retrieve = NULL;
-    sqlite3_stmt *stmt_remove = NULL;
-    axis2_array_list_t *data_list = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FALSE);
     bean_mgr_impl = SANDESHA2_INTF_TO_IMPL(bean_mgr);
     axis2_thread_mutex_lock(bean_mgr_impl->mutex);
@@ -469,31 +300,28 @@
         bean_mgr_impl->storage_mgr, env);
     if(!dbconn)
         return AXIS2_FALSE;
-    if(sqlite3_prepare(dbconn, sql_stmt_retrieve, AXIS2_STRLEN(sql_stmt_retrieve), 
-        &stmt_retrieve, NULL))
-    {
-        axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
-        sandesha2_permanent_bean_mgr_handle_sql_error(env, dbconn, 
-            sql_stmt_retrieve);
-        return AXIS2_FALSE;
-    }
-    data_list = axis2_array_list_create(env, 1);
-    rc = retrieve_callback(env, stmt_retrieve, sandesha2_permanent_bean_mgr_busy_handler, key, 
-        data_list);
-    if(rc != AXIS2_SUCCESS)
-    {
-        axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
-        if(data_list)
-            AXIS2_ARRAY_LIST_FREE(data_list, env);
-        sandesha2_permanent_bean_mgr_handle_sql_error(env, dbconn, 
-            sql_stmt_retrieve);
-        return AXIS2_FALSE;
-    }
-    if(0 < AXIS2_ARRAY_LIST_SIZE(data_list, env))
-        bean = (sandesha2_rm_bean_t *) AXIS2_ARRAY_LIST_GET(data_list, env, 0);
-    sqlite3_reset(stmt_retrieve);
-    if(data_list)
-        AXIS2_ARRAY_LIST_FREE(data_list, env);
+    args = AXIS2_MALLOC(env->allocator, sizeof(sandesha2_bean_mgr_args_t));
+    args->env = env;
+    args->data = NULL;
+    rc = sqlite3_exec(dbconn, sql_stmt_retrieve, retrieve_func, args, 
+        &error_msg);
+    if(rc == SQLITE_BUSY)
+        rc = sandesha2_permanent_bean_mgr_busy_handler(dbconn, sql_stmt_retrieve, 
+            retrieve_func, args, &error_msg, rc);
+    if(rc != SQLITE_OK )
+    {
+        axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
+        AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_SQL_ERROR, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "sql stmt: %s. sql error: %s",
+            sql_stmt_retrieve, error_msg);
+        printf("sql_stmt_retrieve:%s\n", sql_stmt_retrieve);
+        printf("retrieve error_msg:%s\n", error_msg);
+        sqlite3_free(error_msg);
+        return AXIS2_FALSE;
+    }
+    bean = (sandesha2_rm_bean_t *) args->data;
+    if(args)
+        AXIS2_FREE(env->allocator, args);
     axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
     if(bean)
     {
@@ -502,23 +330,21 @@
                 bean);
     }
     axis2_thread_mutex_lock(bean_mgr_impl->mutex);
-    if(sqlite3_prepare(dbconn, sql_stmt_remove, AXIS2_STRLEN(sql_stmt_remove), 
-        &stmt_remove, NULL))
-    {
-        axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
-        sandesha2_permanent_bean_mgr_handle_sql_error(env, dbconn, 
-            sql_stmt_remove);
-        return AXIS2_FALSE;
-    }
-    rc = remove_callback(stmt_remove, sandesha2_permanent_bean_mgr_busy_handler, key);
-    if(rc != AXIS2_SUCCESS )
+    rc = sqlite3_exec(dbconn, sql_stmt_remove, 0, 0, &error_msg);
+    if(rc == SQLITE_BUSY)
+        rc = sandesha2_permanent_bean_mgr_busy_handler(dbconn, sql_stmt_remove, 
+            0, 0, &error_msg, rc);
+    if(rc != SQLITE_OK )
     {
         axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
-        sandesha2_permanent_bean_mgr_handle_sql_error(env, dbconn, 
-            sql_stmt_remove);
+        AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_SQL_ERROR, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "sql stmt: %s. sql error: %s",
+            sql_stmt_remove, error_msg);
+        printf("sql_stmt_remove:%s\n", sql_stmt_remove);
+        printf("remove error_msg:%s\n", error_msg);
+        sqlite3_free(error_msg);
         return AXIS2_FALSE;
     }
-    sqlite3_reset(stmt_remove);
     axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
     return AXIS2_TRUE;
 }
@@ -527,55 +353,71 @@
 sandesha2_permanent_bean_mgr_retrieve(
     sandesha2_permanent_bean_mgr_t *bean_mgr,
     const axis2_env_t *env,
-    void *key,
-    axis2_status_t (*retrieve_callback)(const axis2_env_t *, sqlite3_stmt *, int (*busy_handler)(
-        sqlite3_stmt*, int), void *, axis2_array_list_t *),
+    int (*retrieve_func)(void *, int, char **, char **),
     axis2_char_t *sql_stmt_retrieve)
 {
     sandesha2_permanent_bean_mgr_impl_t *bean_mgr_impl = NULL;
+    sandesha2_bean_mgr_args_t *args = NULL;
+    axis2_char_t *error_msg = NULL;
     sandesha2_rm_bean_t *bean = NULL;
     sqlite3 *dbconn = NULL;
-    sqlite3_stmt *stmt_retrieve = NULL;
     int rc = -1;
-    axis2_array_list_t *data_list = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FALSE);
     bean_mgr_impl = SANDESHA2_INTF_TO_IMPL(bean_mgr);
     axis2_thread_mutex_lock(bean_mgr_impl->mutex);
     dbconn = (sqlite3 *) sandesha2_permanent_storage_mgr_get_dbconn(
         bean_mgr_impl->storage_mgr, env);
     if(!dbconn)
-    {
-        axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
         return NULL;
-    }
-    if(sqlite3_prepare(dbconn, sql_stmt_retrieve, AXIS2_STRLEN(sql_stmt_retrieve), 
-        &stmt_retrieve, NULL))
-    {
-        axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
-        sandesha2_permanent_bean_mgr_handle_sql_error(env, dbconn, 
-            sql_stmt_retrieve);
-        return AXIS2_FALSE;
-    }
-    data_list = axis2_array_list_create(env, 1);
-    rc = retrieve_callback(env, stmt_retrieve, sandesha2_permanent_bean_mgr_busy_handler, key, 
-        data_list);
-    if(rc != AXIS2_SUCCESS )
-    {
-        axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
-        if(data_list)
-            AXIS2_ARRAY_LIST_FREE(data_list, env);
-        sandesha2_permanent_bean_mgr_handle_sql_error(env, dbconn, 
-            sql_stmt_retrieve);
-        return AXIS2_FALSE;
-    }
-    if(0 < AXIS2_ARRAY_LIST_SIZE(data_list, env))
-        bean = (sandesha2_rm_bean_t *) AXIS2_ARRAY_LIST_GET(data_list, env, 0);
-    sqlite3_reset(stmt_retrieve);
-    if(data_list)
-        AXIS2_ARRAY_LIST_FREE(data_list, env);
+    args = AXIS2_MALLOC(env->allocator, sizeof(sandesha2_bean_mgr_args_t));
+    args->env = (axis2_env_t*)env;
+    args->data = NULL;
+    rc = sqlite3_exec(dbconn, sql_stmt_retrieve, retrieve_func, args, 
+        &error_msg);
+    if(rc == SQLITE_BUSY)
+        rc = sandesha2_permanent_bean_mgr_busy_handler(dbconn, sql_stmt_retrieve, 
+            retrieve_func, args, &error_msg, rc);
+    if(rc != SQLITE_OK )
+    {
+        axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
+        AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_SQL_ERROR, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "sql stmt: %s. sql error: %s",
+            sql_stmt_retrieve, error_msg);
+        printf("sql_stmt_retrieve:%s\n", sql_stmt_retrieve);
+        printf("retrieve error_msg:%s\n", error_msg);
+        sqlite3_free(error_msg);
+        return AXIS2_FALSE;
+    }
+    bean = (sandesha2_rm_bean_t *) args->data;
+    if(args)
+        AXIS2_FREE(env->allocator, args);
     axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
     if(bean)
         sandesha2_storage_mgr_enlist_bean(bean_mgr_impl->storage_mgr, env, bean);
+    axis2_thread_mutex_lock(bean_mgr_impl->mutex);
+    args = AXIS2_MALLOC(env->allocator, sizeof(sandesha2_bean_mgr_args_t));
+    args->env = (axis2_env_t*)env;
+    args->data = NULL;
+    rc = sqlite3_exec(dbconn, sql_stmt_retrieve, retrieve_func, args, 
+        &error_msg);
+    if(rc == SQLITE_BUSY)
+        rc = sandesha2_permanent_bean_mgr_busy_handler(dbconn, sql_stmt_retrieve, 
+            retrieve_func, args, &error_msg, rc);
+    if(rc != SQLITE_OK )
+    {
+        axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
+        AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_SQL_ERROR, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "sql error %s",
+            error_msg);
+        printf("sql_stmt_retrieve:%s\n", sql_stmt_retrieve);
+        printf("retrieve error_msg:%s\n", error_msg);
+        sqlite3_free(error_msg);
+        return AXIS2_FALSE;
+    }
+    bean = (sandesha2_rm_bean_t *) args->data;
+    if(args)
+        AXIS2_FREE(env->allocator, args);
+    axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
     return bean;
 }
 
@@ -583,23 +425,18 @@
 sandesha2_permanent_bean_mgr_update(
     sandesha2_permanent_bean_mgr_t *bean_mgr,
     const axis2_env_t *env,
-    void *key,
     sandesha2_rm_bean_t *bean,
-    axis2_status_t (*retrieve_callback)(const axis2_env_t *, sqlite3_stmt *, int (*busy_handler)(
-        sqlite3_stmt*, int), void *, axis2_array_list_t *),
-    axis2_status_t (*update_or_insert_callback)(const axis2_env_t *, sqlite3_stmt *, int (*busy_handler)(
-        sqlite3_stmt*, int), sandesha2_rm_bean_t *),
+    int (*retrieve_func)(void *, int, char **, char **),
     axis2_char_t *sql_stmt_retrieve_old_bean,
     axis2_char_t *sql_stmt_update)
 {
     sandesha2_permanent_bean_mgr_impl_t *bean_mgr_impl = NULL;
+    sandesha2_bean_mgr_args_t *args = NULL;
     sqlite3 *dbconn = NULL;
     sandesha2_rm_bean_t *old_bean = NULL;
-    sqlite3_stmt *stmt_retrieve_old_bean = NULL;
-    sqlite3_stmt *stmt_update = NULL;
+    axis2_char_t *error_msg = NULL;
     int rc = -1;
-    axis2_char_t *key_l = NULL;
-    axis2_array_list_t *data_list = NULL;
+    axis2_char_t *key = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FALSE);
     bean_mgr_impl = SANDESHA2_INTF_TO_IMPL(bean_mgr);
     if(bean)
@@ -609,59 +446,51 @@
         bean_mgr_impl->storage_mgr, env);
     if(!dbconn)
         return AXIS2_FALSE;
-    if(sqlite3_prepare(dbconn, sql_stmt_retrieve_old_bean, AXIS2_STRLEN(sql_stmt_retrieve_old_bean), 
-        &stmt_retrieve_old_bean, NULL))
-    {
-        axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
-        sandesha2_permanent_bean_mgr_handle_sql_error(env, dbconn, 
-            sql_stmt_retrieve_old_bean);
-        return AXIS2_FALSE;
-    }
-    data_list = axis2_array_list_create(env, 1);
-    rc = retrieve_callback(env, stmt_retrieve_old_bean, sandesha2_permanent_bean_mgr_busy_handler, key, 
-        data_list);
-    if(rc != AXIS2_SUCCESS )
-    {
-        axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
-        if(data_list)
-            AXIS2_ARRAY_LIST_FREE(data_list, env);
-        sandesha2_permanent_bean_mgr_handle_sql_error(env, dbconn, 
-            sql_stmt_retrieve_old_bean);
-        return AXIS2_FALSE;
-    }
-    sqlite3_reset(stmt_retrieve_old_bean);
-    if(sqlite3_prepare(dbconn, sql_stmt_update, AXIS2_STRLEN(sql_stmt_update), 
-        &stmt_update, NULL))
-    {
-        axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
-        sandesha2_permanent_bean_mgr_handle_sql_error(env, dbconn, 
-            sql_stmt_update);
+    args = AXIS2_MALLOC(env->allocator, sizeof(sandesha2_bean_mgr_args_t));
+    args->env = (axis2_env_t*)env;
+    args->data = NULL;
+    rc = sqlite3_exec(dbconn, sql_stmt_retrieve_old_bean, 
+       retrieve_func, args, &error_msg);
+    if(rc == SQLITE_BUSY)
+        rc = sandesha2_permanent_bean_mgr_busy_handler(dbconn, sql_stmt_retrieve_old_bean, 
+            retrieve_func, args, &error_msg, rc);
+    if(rc != SQLITE_OK )
+    {
+        axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
+        if(args)
+            AXIS2_FREE(env->allocator, args);
+        AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_SQL_ERROR, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "sql error %s", 
+            error_msg);
+        printf("sql_stmt_retrieve_old_bean:%s\n", sql_stmt_retrieve_old_bean);
+        printf("retrieve error_msg:%s\n", error_msg);
+        sqlite3_free(error_msg);
         return AXIS2_FALSE;
     }
-    rc = update_or_insert_callback(env, stmt_update, sandesha2_permanent_bean_mgr_busy_handler, bean);
-    if(rc != AXIS2_SUCCESS)
+    rc = sqlite3_exec(dbconn, sql_stmt_update, 0, 0, &error_msg);
+    if(rc == SQLITE_BUSY)
+        rc = sandesha2_permanent_bean_mgr_busy_handler(dbconn, sql_stmt_update, 
+            0, 0, &error_msg, rc);
+    if(rc != SQLITE_OK )
     {
         axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
-        if(data_list)
-            AXIS2_ARRAY_LIST_FREE(data_list, env);
-        sandesha2_permanent_bean_mgr_handle_sql_error(env, dbconn, 
-            sql_stmt_update);
+        AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_SQL_ERROR, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "sql error %s", 
+            error_msg);
+        printf("sql_stmt_update:%s\n", sql_stmt_update);
+        printf("update error_msg:%s\n", error_msg);
+        sqlite3_free(error_msg);
         return AXIS2_FALSE;
     }
     axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
-    if(0 < AXIS2_ARRAY_LIST_SIZE(data_list, env))
-        old_bean = (sandesha2_rm_bean_t *) AXIS2_ARRAY_LIST_GET(data_list, 
-            env, 0);
+    old_bean = (sandesha2_rm_bean_t *) args->data;
     if(old_bean)
-        key_l = sandesha2_rm_bean_get_key(old_bean, env);
-    if(data_list)
-        AXIS2_ARRAY_LIST_FREE(data_list, env);
-    if(!key_l)
-    {
+        key = sandesha2_rm_bean_get_key(old_bean, env);
+    if(!key)
         return AXIS2_FALSE;
-    }
-    sqlite3_reset(stmt_update);
     sandesha2_storage_mgr_enlist_bean(bean_mgr_impl->storage_mgr, env, old_bean);
+    if(args)
+        AXIS2_FREE(env->allocator, args);
     return AXIS2_TRUE;
 }
 
@@ -670,18 +499,17 @@
     sandesha2_permanent_bean_mgr_t *bean_mgr,
     const axis2_env_t *env,
     sandesha2_rm_bean_t *bean,
-    axis2_status_t (*retrieve_callback)(const axis2_env_t *env, sqlite3_stmt *, int (*busy_handler)(
-        sqlite3_stmt*, int), void *, axis2_array_list_t *),
+    int (*find_func)(void *, int, char **, char **),
     int (*count_func)(void *, int, char **, char **),
     axis2_char_t *sql_stmt_find,
     axis2_char_t *sql_stmt_count)
 {
     sandesha2_permanent_bean_mgr_impl_t *bean_mgr_impl = NULL;
+    sandesha2_bean_mgr_args_t *args = NULL;
     axis2_array_list_t *beans = NULL;
     int i = 0, size = 0, rc = -1;
     sqlite3 *dbconn = NULL;
-    sqlite3_stmt *stmt_find = NULL;
-    axis2_array_list_t *data_list = NULL;
+    axis2_array_list_t *data_array = NULL;
     axis2_char_t *error_msg = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FALSE);
     bean_mgr_impl = SANDESHA2_INTF_TO_IMPL(bean_mgr);
@@ -692,37 +520,40 @@
         return NULL;
     }
     axis2_thread_mutex_lock(bean_mgr_impl->mutex);
+    args = AXIS2_MALLOC(env->allocator, sizeof(sandesha2_bean_mgr_args_t));
+    args->env = (axis2_env_t*)env;
+    args->data = NULL;
     dbconn = (sqlite3 *) sandesha2_permanent_storage_mgr_get_dbconn(
         bean_mgr_impl->storage_mgr, env);
     if(!dbconn)
         return NULL;
-    if(sqlite3_prepare(dbconn, sql_stmt_find, AXIS2_STRLEN(sql_stmt_find), 
-        &stmt_find, NULL))
-    {
-        axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
-        sandesha2_permanent_bean_mgr_handle_sql_error(env, dbconn, 
-            sql_stmt_find);
-        return AXIS2_FALSE;
-    }
-    data_list = axis2_array_list_create(env, 0);
-    rc = retrieve_callback(env, stmt_find, sandesha2_permanent_bean_mgr_busy_handler, NULL, 
-        data_list);
-    if(rc != AXIS2_SUCCESS )
-    {
-        axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
-        if(data_list)
-            AXIS2_ARRAY_LIST_FREE(data_list, env);
-        sandesha2_permanent_bean_mgr_handle_sql_error(env, dbconn, 
-            sql_stmt_find);
+    rc = sqlite3_exec(dbconn, sql_stmt_find, find_func, args, 
+        &error_msg);
+    if(rc == SQLITE_BUSY)
+        rc = sandesha2_permanent_bean_mgr_busy_handler(dbconn, sql_stmt_find, 
+            find_func, args, &error_msg, rc);
+    data_array = (axis2_array_list_t *) args->data;
+    if(rc != SQLITE_OK )
+    {
+        axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
+        if(data_array)
+            AXIS2_ARRAY_LIST_FREE(data_array, env);
+        if(args)
+            AXIS2_FREE(env->allocator, args);
+        AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_SQL_ERROR, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "sql error %s", 
+            error_msg);
+        printf("sql_stmt_find:%s\n", sql_stmt_find);
+        printf("retrieve error_msg:%s\n", error_msg);
+        sqlite3_free(error_msg);
         return NULL;
     }
-    sqlite3_reset(stmt_find);
-    if(data_list)
-        size = AXIS2_ARRAY_LIST_SIZE(data_list, env);
+    if(data_array)
+        size = AXIS2_ARRAY_LIST_SIZE(data_array, env);
     for(i = 0; i < size; i++)
     {
         sandesha2_rm_bean_t *candidate = NULL;
-        candidate = (sandesha2_rm_bean_t *) AXIS2_ARRAY_LIST_GET(data_list, 
+        candidate = (sandesha2_rm_bean_t *) AXIS2_ARRAY_LIST_GET(data_array, 
             env, i);
          if(!candidate)
             continue;
@@ -734,8 +565,10 @@
         if(!bean)
             AXIS2_ARRAY_LIST_ADD(beans, env, candidate);
     }
-    if(data_list)
-        AXIS2_ARRAY_LIST_FREE(data_list, env);
+    if(data_array)
+        AXIS2_ARRAY_LIST_FREE(data_array, env);
+    if(args)
+        AXIS2_FREE(env->allocator, args);
     axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
     /* Now we have a point-in-time view of the beans, lock them all.*/
     size = AXIS2_ARRAY_LIST_SIZE(beans, env);
@@ -758,6 +591,9 @@
 
             rc = sqlite3_exec(dbconn, sql_stmt_count, count_func, &count, 
                 &error_msg);
+            if(rc == SQLITE_BUSY)
+                rc = sandesha2_permanent_bean_mgr_busy_handler(dbconn, sql_stmt_count, 
+                    count_func, &count, &error_msg, rc);
             if(rc != SQLITE_OK )
             {
                 axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
@@ -784,8 +620,7 @@
     sandesha2_permanent_bean_mgr_t *bean_mgr,
     const axis2_env_t *env,
     sandesha2_rm_bean_t *bean,
-    axis2_status_t (*retrieve_callback)(const axis2_env_t *, sqlite3_stmt *, int (*busy_handler)(
-        sqlite3_stmt*, int), void *, axis2_array_list_t *),
+    int (*find_func)(void *, int, char **, char **),
     int (*count_func)(void *, int, char **, char **),
     axis2_char_t *sql_stmt_find,
     axis2_char_t *sql_stmt_count)
@@ -797,7 +632,7 @@
     AXIS2_ENV_CHECK(env, AXIS2_FALSE);
     AXIS2_PARAM_CHECK(env->error, bean, AXIS2_FALSE);
     bean_mgr_impl = SANDESHA2_INTF_TO_IMPL(bean_mgr);
-    beans = sandesha2_permanent_bean_mgr_find(bean_mgr, env, bean, retrieve_callback, 
+    beans = sandesha2_permanent_bean_mgr_find(bean_mgr, env, bean, find_func, 
         count_func, sql_stmt_find, sql_stmt_count);
     if(beans)
         size = AXIS2_ARRAY_LIST_SIZE(beans, env);
@@ -820,12 +655,12 @@
     axis2_char_t *key)
 {
     sandesha2_permanent_bean_mgr_impl_t *bean_mgr_impl = NULL;
+    sandesha2_bean_mgr_args_t *args = NULL;
+    axis2_char_t *error_msg = NULL;
     sandesha2_msg_store_bean_t *msg_store_bean = NULL;
     int rc = -1;
     sqlite3 *dbconn = NULL;
-    sqlite3_stmt *stmt_retrieve = NULL;
-    axis2_char_t *sql_stmt_retrieve = NULL;
-    axis2_array_list_t *data_list = NULL;
+    axis2_char_t sql_stmt_retrieve[512];
     AXIS2_ENV_CHECK(env, AXIS2_FALSE);
     bean_mgr_impl = SANDESHA2_INTF_TO_IMPL(bean_mgr);
     axis2_thread_mutex_lock(bean_mgr_impl->mutex);
@@ -833,36 +668,33 @@
         bean_mgr_impl->storage_mgr, env);
     if(!dbconn)
         return NULL;
-    sql_stmt_retrieve = axis2_strcat(env, "select stored_key, msg_id, soap_env_str,"\
+    args = AXIS2_MALLOC(env->allocator, sizeof(sandesha2_bean_mgr_args_t));
+    args->env = (axis2_env_t*)env;
+    args->data = NULL;
+    sprintf(sql_stmt_retrieve, "select stored_key, msg_id, soap_env_str,"\
         "soap_version, transport_out, op, svc, svc_grp, op_mep, to_url, "\
         "transport_to, execution_chain_str, flow, msg_recv_str, svr_side, "\
-        "in_msg_store_key, prop_str, action from msg where stored_key = ?", NULL);
-    if(sqlite3_prepare(dbconn, sql_stmt_retrieve, AXIS2_STRLEN(sql_stmt_retrieve), 
-        &stmt_retrieve, NULL))
-    {
-        axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
-        sandesha2_permanent_bean_mgr_handle_sql_error(env, dbconn, 
-            sql_stmt_retrieve);
-        return AXIS2_FALSE;
-    }
-    data_list = axis2_array_list_create(env, 0);
-    rc = sandesha2_msg_retrieve_callback(env, stmt_retrieve, sandesha2_permanent_bean_mgr_busy_handler, key, 
-        data_list);
-    if(rc != AXIS2_SUCCESS )
-    {
-        axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
-        if(data_list)
-            AXIS2_ARRAY_LIST_FREE(data_list, env);
-        sandesha2_permanent_bean_mgr_handle_sql_error(env, dbconn, 
-            sql_stmt_retrieve);
-        return NULL;
-    }
-    sqlite3_reset(stmt_retrieve);
-    if(0 < AXIS2_ARRAY_LIST_SIZE(data_list, env))
-        msg_store_bean = (sandesha2_msg_store_bean_t *) AXIS2_ARRAY_LIST_GET(
-            data_list, env, 0);
-    if(data_list)
-        AXIS2_ARRAY_LIST_FREE(data_list, env);
+        "in_msg_store_key, prop_str, action from msg where stored_key='%s'", 
+        key);
+    rc = sqlite3_exec(dbconn, sql_stmt_retrieve, 
+        sandesha2_msg_store_bean_retrieve_callback, args, &error_msg);
+    if(rc == SQLITE_BUSY)
+        rc = sandesha2_permanent_bean_mgr_busy_handler(dbconn, sql_stmt_retrieve, 
+            sandesha2_msg_store_bean_retrieve_callback, args, &error_msg, rc);
+    if(rc != SQLITE_OK )
+    {
+        axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
+        AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_SQL_ERROR, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "sql error %s",
+            error_msg);
+        printf("sql_stmt_retrieve:%s\n", sql_stmt_retrieve);
+        printf("retrieve error_msg:%s\n", error_msg);
+        sqlite3_free(error_msg);
+        return AXIS2_FALSE;
+    }
+    msg_store_bean = (sandesha2_msg_store_bean_t *) args->data;
+    if(args)
+        AXIS2_FREE(env->allocator, args);
     axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
     return msg_store_bean;
 }
@@ -874,20 +706,54 @@
     axis2_char_t *key,
     sandesha2_msg_store_bean_t *bean)
 {
-    axis2_char_t *sql_stmt_retrieve = NULL;
+    axis2_char_t sql_stmt_retrieve[512];
     axis2_char_t *sql_stmt_update = NULL;
     axis2_char_t *sql_stmt_insert = NULL;
-    axis2_array_list_t *data_list = NULL;
+    axis2_char_t *error_msg = NULL;
     int rc = -1;
+    int sql_size = -1;
     sqlite3 *dbconn = NULL;
-    sqlite3_stmt *stmt_retrieve = NULL;
-    sqlite3_stmt *stmt_update = NULL;
-    sqlite3_stmt *stmt_insert = NULL;
+    sandesha2_bean_mgr_args_t *args = NULL;
     sandesha2_msg_store_bean_t *msg_store_bean = NULL;
 
     sandesha2_permanent_bean_mgr_impl_t *bean_mgr_impl = 
         bean_mgr_impl = SANDESHA2_INTF_TO_IMPL(bean_mgr);
     
+    axis2_char_t *msg_id = sandesha2_msg_store_bean_get_msg_id(bean, env);
+    axis2_char_t *stored_key = sandesha2_msg_store_bean_get_stored_key(bean, env);
+    axis2_char_t *soap_env_str = 
+        sandesha2_msg_store_bean_get_soap_envelope_str(bean, env);
+    int soap_version = sandesha2_msg_store_bean_get_soap_version(
+        bean, env);
+    axis2_char_t *transport_out = sandesha2_msg_store_bean_get_transport_out(
+        bean, env);
+    axis2_char_t *op = sandesha2_msg_store_bean_get_op(bean, env);
+    axis2_char_t *svc = sandesha2_msg_store_bean_get_svc(bean, env);
+    axis2_char_t *svc_grp = sandesha2_msg_store_bean_get_svc_grp(bean, env);
+    axis2_char_t *op_mep = sandesha2_msg_store_bean_get_op_mep(bean, env);;
+    axis2_char_t *to_url = sandesha2_msg_store_bean_get_to_url(bean, env);
+    axis2_char_t *reply_to = sandesha2_msg_store_bean_get_reply_to(bean, env);
+    axis2_char_t *transport_to = sandesha2_msg_store_bean_get_transport_to(
+        bean, env);
+    axis2_char_t *execution_chain_str = 
+        sandesha2_msg_store_bean_get_execution_chain_str(bean, env);
+    int flow = sandesha2_msg_store_bean_get_flow(bean, env);
+    axis2_char_t *msg_recv_str = sandesha2_msg_store_bean_get_msg_recv_str(
+        bean, env);
+    axis2_bool_t svr_side = sandesha2_msg_store_bean_is_svr_side(bean, env);
+    axis2_char_t *in_msg_store_key = 
+        sandesha2_msg_store_bean_get_in_msg_store_key(bean, env);
+    axis2_char_t *prop_str = 
+        sandesha2_msg_store_bean_get_persistent_property_str(bean, env);
+    axis2_char_t *action = sandesha2_msg_store_bean_get_action(bean, env);
+
+    sql_size = AXIS2_STRLEN(msg_id) + AXIS2_STRLEN(stored_key) + 
+        AXIS2_STRLEN(soap_env_str) + sizeof(int) + AXIS2_STRLEN(transport_out) + 
+        AXIS2_STRLEN(op) + AXIS2_STRLEN(svc) + AXIS2_STRLEN(svc_grp) + 
+        AXIS2_STRLEN(op_mep) + AXIS2_STRLEN(to_url) + AXIS2_STRLEN(reply_to) +
+        AXIS2_STRLEN(transport_to) + AXIS2_STRLEN(execution_chain_str) + sizeof(int) + 
+        AXIS2_STRLEN(msg_recv_str) + sizeof(int) + AXIS2_STRLEN(in_msg_store_key) +
+        AXIS2_STRLEN(prop_str) + AXIS2_STRLEN(action) + 512;
 
     axis2_thread_mutex_lock(bean_mgr_impl->mutex);
     dbconn = (sqlite3 *) sandesha2_permanent_storage_mgr_get_dbconn(
@@ -895,88 +761,92 @@
     if(!dbconn)
         return AXIS2_FALSE;
 
-    sql_stmt_retrieve = axis2_strcat(env, "select stored_key, msg_id, soap_env_str,"\
+    args = AXIS2_MALLOC(env->allocator, sizeof(sandesha2_bean_mgr_args_t));
+    args->env = env;
+    args->data = NULL;
+    sprintf(sql_stmt_retrieve, "select stored_key, msg_id, soap_env_str,"\
         "soap_version, transport_out, op, svc, svc_grp, op_mep, to_url, reply_to, "\
         "transport_to, execution_chain_str, flow, msg_recv_str, svr_side, "\
-        "in_msg_store_key, prop_str, action from msg where stored_key = ?", NULL);
-    if(sqlite3_prepare(dbconn, sql_stmt_retrieve, AXIS2_STRLEN(sql_stmt_retrieve), 
-        &stmt_retrieve, NULL))
-    {
-        axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
-        sandesha2_permanent_bean_mgr_handle_sql_error(env, dbconn, 
-            sql_stmt_retrieve);
-        return AXIS2_FALSE;
-    }
-    data_list = axis2_array_list_create(env, 0);
-    rc = sandesha2_msg_retrieve_callback(env, stmt_retrieve, sandesha2_permanent_bean_mgr_busy_handler, key, 
-        data_list);
-    if(rc != AXIS2_SUCCESS)
-    {
-        axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
-        if(data_list)
-            AXIS2_ARRAY_LIST_FREE(data_list, env);
-        sandesha2_permanent_bean_mgr_handle_sql_error(env, dbconn, 
-            sql_stmt_retrieve);
-        return AXIS2_FALSE;
-    }
-    sqlite3_reset(stmt_retrieve);
-    if(0 < AXIS2_ARRAY_LIST_SIZE(data_list, env))
-        msg_store_bean = (sandesha2_msg_store_bean_t *) AXIS2_ARRAY_LIST_GET(
-            data_list, env, 0);
-    if(data_list)
-        AXIS2_ARRAY_LIST_FREE(data_list, env);
+        "in_msg_store_key, prop_str, action from msg where stored_key = '%s'", 
+        key);
+    rc = sqlite3_exec(dbconn, sql_stmt_retrieve,
+        sandesha2_msg_store_bean_retrieve_callback, args, &error_msg);
+    if(rc == SQLITE_BUSY)
+        rc = sandesha2_permanent_bean_mgr_busy_handler(dbconn, sql_stmt_retrieve, 
+            sandesha2_msg_store_bean_retrieve_callback, args, &error_msg, rc);
+    if(rc != SQLITE_OK )
+    {
+        axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
+        AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_SQL_ERROR, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "sql error %s",
+            error_msg);
+        printf("sql_stmt_retrieve:%s\n", sql_stmt_retrieve);
+        printf("retrieve error_msg:%s\n", error_msg);
+        sqlite3_free(error_msg);
+        return AXIS2_FALSE;
+    }
+    if(args)
+        AXIS2_FREE(env->allocator, args);
+    msg_store_bean = (sandesha2_msg_store_bean_t *) args->data;
     if(msg_store_bean)
     {
-        sql_stmt_update = axis2_strcat(env, "update msg set msg_id=?,"\
-            "soap_env_str=?,soap_version=?, transport_out=?, op=?,"\
-            "svc=?, svc_grp=?, op_mep=?, to_url=?, transport_to=?, reply_to=?,"\
-            "execution_chain_str=?, flow=?, msg_recv_str=?, svr_side=?,"\
-            "in_msg_store_key=?, prop_str=?, action=?"\
-            " where stored_key=?", NULL);
-        if(sqlite3_prepare(dbconn, sql_stmt_update, AXIS2_STRLEN(sql_stmt_update), 
-            &stmt_update, NULL))
-        {
-            axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
-            sandesha2_permanent_bean_mgr_handle_sql_error(env, dbconn, 
-                sql_stmt_update);
-            return AXIS2_FALSE;
-        }
-        rc = sandesha2_msg_update_or_insert_callback(env, stmt_update, 
-            sandesha2_permanent_bean_mgr_busy_handler, bean);
-        if(rc != AXIS2_SUCCESS)
+        sql_stmt_update = AXIS2_MALLOC(env->allocator, sql_size);
+        sprintf(sql_stmt_update, "update msg set msg_id='%s',"\
+            "soap_env_str='%s', soap_version=%d, transport_out='%s', op='%s',"\
+            "svc='%s', svc_grp='%s', op_mep='%s', to_url='%s',"\
+            "transport_to='%s', reply_to='%s', execution_chain_str='%s',"\
+            "flow=%d, msg_recv_str='%s', svr_side='%d', in_msg_store_key='%s',"\
+            "prop_str='%s', action='%s' where stored_key='%s'", msg_id, 
+            soap_env_str, soap_version, transport_out, op, svc, svc_grp, op_mep, 
+            to_url, transport_to, reply_to, execution_chain_str, flow, 
+            msg_recv_str, svr_side, in_msg_store_key, prop_str, action, key);
+        rc = sqlite3_exec(dbconn, sql_stmt_update, 0, 0, &error_msg);
+        if(rc == SQLITE_BUSY)
+            rc = sandesha2_permanent_bean_mgr_busy_handler(dbconn, sql_stmt_update, 
+                0, 0, &error_msg, rc);
+        if( rc != SQLITE_OK )
         {
             axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
-            sandesha2_permanent_bean_mgr_handle_sql_error(env, dbconn, 
-                sql_stmt_update);
+            AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_SQL_ERROR, 
+                AXIS2_FAILURE);
+            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "sql error %s", 
+                error_msg);
+            printf("sql_stmt_update:%s\n", sql_stmt_update);
+            printf("update error_msg:%s\n", error_msg);
+            AXIS2_FREE(env->allocator, sql_stmt_update);
+            sqlite3_free(error_msg);
             return AXIS2_FALSE;
         }
-        sqlite3_reset(stmt_update);
+        AXIS2_FREE(env->allocator, sql_stmt_update);
         axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
         return AXIS2_TRUE;
     }
-    sql_stmt_insert = axis2_strcat(env, "insert into msg(msg_id, "\
+    sql_stmt_insert = AXIS2_MALLOC(env->allocator, sql_size);
+    sprintf(sql_stmt_insert, "insert into msg(stored_key, msg_id, "\
         "soap_env_str, soap_version, transport_out, op, svc, svc_grp, op_mep,"\
-        "to_url, reply_to,transport_to, execution_chain_str, flow, msg_recv_str, "\
-        "svr_side, in_msg_store_key, prop_str, action, stored_key) "\
-        "values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)", NULL);
-    if(sqlite3_prepare(dbconn, sql_stmt_insert, AXIS2_STRLEN(sql_stmt_insert), 
-        &stmt_insert, NULL))
-    {
-        axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
-        sandesha2_permanent_bean_mgr_handle_sql_error(env, dbconn, 
-            sql_stmt_insert);
-        return AXIS2_FALSE;
-    }
-    rc = sandesha2_msg_update_or_insert_callback(env, stmt_insert, 
-        sandesha2_permanent_bean_mgr_busy_handler, bean);
-    if(rc != AXIS2_SUCCESS)
+        "to_url, reply_to,transport_to, execution_chain_str, flow,"\
+        "msg_recv_str, svr_side, in_msg_store_key, prop_str, action) "\
+        "values('%s', '%s', '%s', %d, '%s', '%s', '%s', '%s', '%s', '%s',"\
+        "'%s', '%s', '%s', %d, '%s', %d, '%s', '%s', '%s')", stored_key, msg_id, 
+        soap_env_str, soap_version, transport_out, op, svc, svc_grp, op_mep, 
+        to_url, reply_to, transport_to, execution_chain_str, flow, msg_recv_str, 
+        svr_side, in_msg_store_key, prop_str, action);
+    rc = sqlite3_exec(dbconn, sql_stmt_insert, 0, 0, &error_msg);
+    if(rc == SQLITE_BUSY)
+        rc = sandesha2_permanent_bean_mgr_busy_handler(dbconn, sql_stmt_insert, 
+            0, 0, &error_msg, rc);
+    if( rc != SQLITE_OK )
     {
         axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
-        sandesha2_permanent_bean_mgr_handle_sql_error(env, dbconn, 
-            sql_stmt_insert);
+        AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_SQL_ERROR, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "sql error %s", error_msg);
+        printf("sql_stmt_insert:%s\n", sql_stmt_insert);
+        printf("insert error_msg:%s\n", error_msg);
+        AXIS2_FREE(env->allocator, sql_stmt_insert);
+        sqlite3_free(error_msg);
         return AXIS2_FALSE;
     }
-    sqlite3_reset(stmt_insert);
+    AXIS2_FREE(env->allocator, sql_stmt_insert);
     axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
     return AXIS2_TRUE;
 }
@@ -987,11 +857,11 @@
     const axis2_env_t *env,
     axis2_char_t *key)
 {
-    axis2_char_t *sql_stmt_remove = NULL;
+    axis2_char_t sql_stmt_remove[256];
     sandesha2_permanent_bean_mgr_impl_t *bean_mgr_impl = NULL;
+    axis2_char_t *error_msg = NULL;
     int rc = -1;
     sqlite3 *dbconn = NULL;
-    sqlite3_stmt *stmt_remove = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FALSE);
     bean_mgr_impl = SANDESHA2_INTF_TO_IMPL(bean_mgr);
     axis2_thread_mutex_lock(bean_mgr_impl->mutex);
@@ -999,62 +869,45 @@
         bean_mgr_impl->storage_mgr, env);
     if(!dbconn)
         return AXIS2_FALSE;
-    sql_stmt_remove = "delete from msg where stored_key=?";
-    if(sqlite3_prepare(dbconn, sql_stmt_remove, axis2_strlen(sql_stmt_remove), 
-        &stmt_remove, NULL))
+    sprintf(sql_stmt_remove, "delete from msg where stored_key='%s'", key);
+    rc = sqlite3_exec(dbconn, sql_stmt_remove, 0, 0, &error_msg);
+    if(rc == SQLITE_BUSY)
+        rc = sandesha2_permanent_bean_mgr_busy_handler(dbconn, sql_stmt_remove, 
+            0, 0, &error_msg, rc);
+    if(rc != SQLITE_OK )
     {
         axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
-        sandesha2_permanent_bean_mgr_handle_sql_error(env, dbconn, 
-            sql_stmt_remove);
+        AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_SQL_ERROR, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "sql error %s",
+            error_msg);
+        printf("sql_stmt_remove:%s\n", sql_stmt_remove);
+        printf("remove error_msg:%s\n", error_msg);
+        sqlite3_free(error_msg);
         return AXIS2_FALSE;
     }
-    if (sqlite3_bind_text(stmt_remove, 1, key, axis2_strlen(key), SQLITE_STATIC))
-    {
-        sandesha2_permanent_bean_mgr_handle_sql_error(env, dbconn, 
-            sql_stmt_remove);
-    }
-    rc = sqlite3_step(stmt_remove);
-    if (rc == SQLITE_BUSY)
-    {
-        if(sandesha2_permanent_bean_mgr_busy_handler(stmt_remove, rc) != 
-            SQLITE_OK)
-        {
-            axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
-            sandesha2_permanent_bean_mgr_handle_sql_error(env, dbconn, 
-                sql_stmt_remove);
-            return AXIS2_FALSE;
-        }
-    }
     axis2_thread_mutex_unlock(bean_mgr_impl->mutex);
     return AXIS2_TRUE;
 }
 
-static int
+int
 sandesha2_permanent_bean_mgr_busy_handler(
-    sqlite3_stmt* stmt,
+    sqlite3* dbconn,
+    char *sql_stmt,
+    int (*callback_func)(void *, int, char **, char **),
+    void *args,
+    char **error_msg,
     int rc)
 {
     int counter = 0;
     while(rc == SQLITE_BUSY && counter < 8)
     {
+        if(*error_msg)
+             sqlite3_free(*error_msg);
         counter++;
         AXIS2_SLEEP(SANDESHA2_BUSY_WAIT_TIME);
-        rc = sqlite3_step(stmt);
+        rc = sqlite3_exec(dbconn, sql_stmt, callback_func, args, error_msg);
     }
     return rc;
 }
 
-static void 
-sandesha2_permanent_bean_mgr_handle_sql_error(
-    const axis2_env_t *env,
-    sqlite3 *dbconn,
-    axis2_char_t *sql_stmt)
-{
-    const axis2_char_t *error_msg = sqlite3_errmsg(dbconn);
-    AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_SQL_ERROR, AXIS2_FAILURE);
-    AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "sql stmt:%s. sql error: %s",
-        sql_stmt, error_msg);
-    printf("sql_stmt:%s\n", sql_stmt);
-    printf("sql error_msg:%s\n", error_msg);
-}
 

Modified: webservices/sandesha/trunk/c/src/storage/permanent/permanent_create_seq_mgr.c
URL: http://svn.apache.org/viewvc/webservices/sandesha/trunk/c/src/storage/permanent/permanent_create_seq_mgr.c?view=diff&rev=495125&r1=495124&r2=495125
==============================================================================
--- webservices/sandesha/trunk/c/src/storage/permanent/permanent_create_seq_mgr.c (original)
+++ webservices/sandesha/trunk/c/src/storage/permanent/permanent_create_seq_mgr.c Wed Jan 10 21:27:18 2007
@@ -15,12 +15,13 @@
  */
  
 #include <sandesha2_permanent_create_seq_mgr.h>
-#include "sandesha2_permanent_bean_mgr.h"
+#include <sandesha2_permanent_bean_mgr.h>
 #include <sandesha2_constants.h>
 #include <sandesha2_storage_mgr.h>
 #include <sandesha2_create_seq_mgr.h>
 #include <sandesha2_error.h>
 #include <sandesha2_rm_bean.h>
+#include <sandesha2_sqls.h>
 #include <axis2_log.h>
 #include <axis2_hash.h>
 #include <axis2_thread.h>
@@ -41,144 +42,91 @@
 #define SANDESHA2_INTF_TO_IMPL(seq_mgr) \
     ((sandesha2_permanent_create_seq_mgr_t *) seq_mgr)
 
-axis2_status_t 
-sandesha2_create_seq_retrieve_callback(
-    const axis2_env_t *env,
-    sqlite3_stmt *stmt,
-    int (*busy_handler)(sqlite3_stmt* stmt, int rc),
-    void *key,
-    axis2_array_list_t *data_list)
-{
-    int rc = -1;
-    axis2_char_t *create_seq_msg_id = (axis2_char_t *) key;
-    if(create_seq_msg_id)
+static int 
+sandesha2_create_seq_find_callback(
+    void *not_used, 
+    int argc, 
+    char **argv, 
+    char **col_name)
+{
+    int i = 0;
+    sandesha2_create_seq_bean_t *bean = NULL;
+    sandesha2_bean_mgr_args_t *args = (sandesha2_bean_mgr_args_t *) not_used;
+    const axis2_env_t *env = args->env;
+    axis2_array_list_t *data_list = (axis2_array_list_t *) args->data;
+    if(argc < 1)
     {
-        if (sqlite3_bind_text(stmt, 1, create_seq_msg_id, 
-            axis2_strlen(create_seq_msg_id), SQLITE_STATIC))
-        {
-            return AXIS2_FAILURE;
-        }
+        args->data = NULL;
+        return 0;
     }
-    rc = sqlite3_step(stmt);
-    if(rc == SQLITE_BUSY)
+    if(!data_list)
     {
-        if(busy_handler(stmt, rc) != SQLITE_OK)
-        {
-            return AXIS2_FAILURE;
-        }
+        data_list = axis2_array_list_create(env, 0);
+        args->data = data_list;
     }
-    while(rc == SQLITE_ROW)
+    bean = sandesha2_create_seq_bean_create(env);
+    for(i = 0; i < argc; i++)
     {
-        sandesha2_create_seq_bean_t *bean = (sandesha2_create_seq_bean_t *) 
-            sandesha2_create_seq_bean_create(env);
-        sandesha2_create_seq_bean_set_create_seq_msg_id(bean, env, 
-            (axis2_char_t *) sqlite3_column_text(stmt, 0));
-        sandesha2_create_seq_bean_set_internal_seq_id(bean, env,
-            (axis2_char_t *) sqlite3_column_text(stmt, 1));
-        sandesha2_create_seq_bean_set_seq_id(bean, env,
-            (axis2_char_t *) sqlite3_column_text(stmt, 2));
-        sandesha2_create_seq_bean_set_create_seq_msg_store_key(bean, env,
-            (axis2_char_t *) sqlite3_column_text(stmt, 3));
-        sandesha2_create_seq_bean_set_ref_msg_store_key(bean, env,
-            (axis2_char_t *) sqlite3_column_text(stmt, 4));
-        rc = sqlite3_step(stmt);
-        if(rc == SQLITE_BUSY)
-        {
-            if(busy_handler(stmt, rc) != SQLITE_OK)
-            {
-                return AXIS2_FAILURE;
-            }
-        }
-        axis2_array_list_add(data_list, env, bean);
+        if(0 == AXIS2_STRCMP(col_name[i], "create_seq_msg_id"))
+            sandesha2_create_seq_bean_set_create_seq_msg_id(bean, env, argv[i]);
+        if(0 == AXIS2_STRCMP(col_name[i], "internal_seq_id"))
+            if(argv[i])
+                sandesha2_create_seq_bean_set_internal_seq_id(bean, env, argv[i]);
+        if(0 == AXIS2_STRCMP(col_name[i], "seq_id"))
+            if(argv[i])
+                sandesha2_create_seq_bean_set_seq_id(bean, env, argv[i]);
+        if(0 == AXIS2_STRCMP(col_name[i], "create_seq_msg_store_key"))
+            if(argv[i])
+                sandesha2_create_seq_bean_set_create_seq_msg_store_key(bean, env, 
+                argv[i]);
+        if(0 == AXIS2_STRCMP(col_name[i], "ref_msg_store_key"))
+            if(argv[i])
+                sandesha2_create_seq_bean_set_ref_msg_store_key(bean, env, argv[i]);
     }
-    return AXIS2_SUCCESS;
+    axis2_array_list_add(data_list, env, bean);
+    return 0;
 }
 
-static axis2_status_t
-sandesha2_create_seq_remove_callback(
-    sqlite3_stmt *stmt,
-    int (*busy_handler)(sqlite3_stmt* stmt, int rc),
-    void *key)
-{
-    int rc = -1;
-    axis2_char_t *create_seq_msg_id = (axis2_char_t *) key;
-    if (sqlite3_bind_text(stmt, 1, create_seq_msg_id, 
-        axis2_strlen(create_seq_msg_id), SQLITE_STATIC))
+static int 
+sandesha2_create_seq_retrieve_callback(
+    void *not_used, 
+    int argc, 
+    char **argv, 
+    char **col_name)
+{
+    int i = 0;
+    sandesha2_bean_mgr_args_t *args = (sandesha2_bean_mgr_args_t *) not_used;
+    const axis2_env_t *env = args->env;
+    sandesha2_create_seq_bean_t *bean = (sandesha2_create_seq_bean_t *) args->data;
+    if(argc < 1)
     {
-        return AXIS2_FAILURE;
+        args->data = NULL;
+        return 0;
     }
-    rc = sqlite3_step(stmt);
-    if (rc == SQLITE_BUSY)
+    if(!bean)
     {
-        if(busy_handler(stmt, rc) != SQLITE_OK)
-        {
-            return AXIS2_FAILURE;
-        }
+        bean = sandesha2_create_seq_bean_create(env);
+        args->data = bean;
     }
-    else if (rc == SQLITE_DONE)
-        return AXIS2_SUCCESS;
-    return AXIS2_FAILURE;
-}
-
-static axis2_status_t 
-sandesha2_create_seq_update_or_insert_callback(
-    const axis2_env_t *env,
-    sqlite3_stmt *stmt,
-    int (*busy_handler)(sqlite3_stmt* stmt, int rc),
-    sandesha2_rm_bean_t *create_seq_bean)
-{
-    sandesha2_create_seq_bean_t *bean = (sandesha2_create_seq_bean_t *) 
-        create_seq_bean;
-    if(!bean)
-        return AXIS2_FAILURE;
+    for(i = 0; i < argc; i++)
     {
-        int rc = -1;
-        axis2_char_t *create_seq_msg_id = 
-            sandesha2_create_seq_bean_get_create_seq_msg_id((sandesha2_rm_bean_t *)
-                create_seq_bean, env);
-        axis2_char_t *internal_seq_id = sandesha2_create_seq_bean_get_internal_seq_id(
-            (sandesha2_create_seq_bean_t *) bean, env);
-        axis2_char_t *seq_id = sandesha2_create_seq_bean_get_seq_id(bean, env);
-        axis2_char_t *create_seq_msg_store_key = 
-            sandesha2_create_seq_bean_get_create_seq_msg_store_key(bean, env);
-        axis2_char_t *ref_msg_store_key = 
-            sandesha2_create_seq_bean_get_ref_msg_store_key(bean, env);
-           
-        if (sqlite3_bind_text(stmt, 1, internal_seq_id, axis2_strlen(internal_seq_id), SQLITE_STATIC))
-        {
-            return AXIS2_FAILURE;
-        }
-        if (sqlite3_bind_text(stmt, 2, seq_id, axis2_strlen(seq_id), SQLITE_STATIC))
-        {
-            return AXIS2_FAILURE;
-        }
-        if (sqlite3_bind_text(stmt, 3, create_seq_msg_store_key, 
-            axis2_strlen(create_seq_msg_store_key), SQLITE_STATIC))
-        {
-            return AXIS2_FAILURE;
-        }
-        if (sqlite3_bind_text(stmt, 4, ref_msg_store_key, 
-            axis2_strlen(ref_msg_store_key), SQLITE_STATIC))
-        {
-            return AXIS2_FAILURE;
-        }
-        if (sqlite3_bind_text(stmt, 5, create_seq_msg_id, axis2_strlen(
-            create_seq_msg_id), SQLITE_STATIC))
-        {
-            return AXIS2_FAILURE;
-        }
-        rc = sqlite3_step(stmt);
-        if (rc == SQLITE_BUSY)
-        {
-            if(busy_handler(stmt, rc) != SQLITE_OK)
-            {
-                return AXIS2_FAILURE;
-            }
-        }
-        else if (rc == SQLITE_DONE)
-            return AXIS2_SUCCESS;
+        if(0 == AXIS2_STRCMP(col_name[i], "create_seq_msg_id"))
+            sandesha2_create_seq_bean_set_create_seq_msg_id(bean, env, argv[i]);
+        if(0 == AXIS2_STRCMP(col_name[i], "internal_seq_id"))
+            if(argv[i])
+                sandesha2_create_seq_bean_set_internal_seq_id(bean, env, argv[i]);
+        if(0 == AXIS2_STRCMP(col_name[i], "seq_id"))
+            if(argv[i])
+                sandesha2_create_seq_bean_set_seq_id(bean, env, argv[i]);
+        if(0 == AXIS2_STRCMP(col_name[i], "create_seq_msg_store_key"))
+            if(argv[i])
+                sandesha2_create_seq_bean_set_create_seq_msg_store_key(bean, env, 
+                argv[i]);
+        if(0 == AXIS2_STRCMP(col_name[i], "ref_msg_store_key"))
+            if(argv[i])
+                sandesha2_create_seq_bean_set_ref_msg_store_key(bean, env, argv[i]);
     }
-    return AXIS2_FAILURE;
+    return 0;
 }
 
 static int 
@@ -298,31 +246,41 @@
 {
     sandesha2_permanent_create_seq_mgr_t *seq_mgr_impl = NULL;
     axis2_bool_t ret = AXIS2_FALSE;
-    axis2_char_t *sql_insert = NULL;
-    axis2_char_t *sql_update = NULL;
-    axis2_char_t *sql_retrieve = NULL;
-    axis2_char_t *create_seq_msg_id = NULL; 
+    axis2_char_t sql_insert[1024];
+    axis2_char_t sql_update[1024];
+    axis2_char_t sql_retrieve[256];
+
+    axis2_char_t *create_seq_msg_id = sandesha2_create_seq_bean_get_create_seq_msg_id(
+        (sandesha2_rm_bean_t *) bean, env);
+    axis2_char_t *internal_seq_id = sandesha2_create_seq_bean_get_internal_seq_id(bean, env);
+    axis2_char_t *seq_id = sandesha2_create_seq_bean_get_seq_id(bean, env);
+    axis2_char_t *create_seq_msg_store_key = 
+        sandesha2_create_seq_bean_get_create_seq_msg_store_key(bean, env);
+    axis2_char_t *ref_msg_store_key = 
+        sandesha2_create_seq_bean_get_ref_msg_store_key(bean, env);
+
     AXIS2_LOG_INFO(env->log, 
         "[sandesha2]Entry:sandesha2_permanent_create_seq_mgr_insert");
     AXIS2_ENV_CHECK(env, AXIS2_FALSE);
     AXIS2_PARAM_CHECK(env->error, bean, AXIS2_FALSE);
     seq_mgr_impl = SANDESHA2_INTF_TO_IMPL(seq_mgr);
 
-   create_seq_msg_id = sandesha2_create_seq_bean_get_create_seq_msg_id(
-        (sandesha2_rm_bean_t *) bean, env);
-    sql_retrieve = "select create_seq_msg_id, internal_seq_id,"\
+    sprintf(sql_retrieve, "select create_seq_msg_id, internal_seq_id,"\
         "seq_id, create_seq_msg_store_key, ref_msg_store_key from create_seq "\
-        "where create_seq_msg_id=?";
-    sql_update = "update create_seq set internal_seq_id=?, seq_id=?, "\
-        "create_seq_msg_store_key=?, ref_msg_store_key=? where"\
-        " create_seq_msg_id=?"; 
-    sql_insert = "insert into create_seq(internal_seq_id, seq_id, "\
-        "create_seq_msg_store_key, ref_msg_store_key, create_seq_msg_id) "\
-        "values(?,?,?,?,?)";
+        "where create_seq_msg_id='%s';", create_seq_msg_id);
+    
+    sprintf(sql_update, "update create_seq set internal_seq_id='%s', seq_id='%s'"\
+        ",create_seq_msg_store_key='%s', ref_msg_store_key='%s' where "\
+        "create_seq_msg_id='%s';", internal_seq_id, seq_id, 
+        create_seq_msg_store_key, ref_msg_store_key, create_seq_msg_id);
+    
+    sprintf(sql_insert, "insert into create_seq(create_seq_msg_id, "\
+        "internal_seq_id, seq_id, create_seq_msg_store_key, ref_msg_store_key) "\
+        "values('%s', '%s', '%s', '%s', '%s');", create_seq_msg_id, 
+        internal_seq_id, seq_id, create_seq_msg_store_key, ref_msg_store_key);
+
     ret = sandesha2_permanent_bean_mgr_insert(seq_mgr_impl->bean_mgr, env, 
-        (void *) create_seq_msg_id,(sandesha2_rm_bean_t *) bean, 
-        sandesha2_create_seq_retrieve_callback, 
-        sandesha2_create_seq_update_or_insert_callback, 
+        (sandesha2_rm_bean_t *) bean, sandesha2_create_seq_retrieve_callback, 
         sql_retrieve, sql_update, sql_insert);
     AXIS2_LOG_INFO(env->log, 
         "[sandesha2]Exit:sandesha2_permanent_create_seq_mgr_insert");
@@ -336,21 +294,20 @@
     axis2_char_t *msg_id)
 {
     sandesha2_permanent_create_seq_mgr_t *seq_mgr_impl = NULL;
-    axis2_char_t *sql_remove = NULL;
-    axis2_char_t *sql_retrieve = NULL;
+    axis2_char_t sql_remove[256];
+    axis2_char_t sql_retrieve[256];
 
     AXIS2_ENV_CHECK(env, AXIS2_FALSE);
     AXIS2_PARAM_CHECK(env->error, msg_id, AXIS2_FALSE);
     seq_mgr_impl = SANDESHA2_INTF_TO_IMPL(seq_mgr);
-    sql_remove = "delete from create_seq where create_seq_msg_id=?";
-    sql_retrieve = "select create_seq_msg_id, internal_seq_id,"\
+
+    sprintf(sql_remove, "delete from create_seq where create_seq_msg_id='%s';", 
+        msg_id);
+    sprintf(sql_retrieve, "select create_seq_msg_id, internal_seq_id,"\
         "seq_id, create_seq_msg_store_key, ref_msg_store_key from create_seq "\
-        "where create_seq_msg_id=?";
+        "where create_seq_msg_id='%s';", msg_id);
     return sandesha2_permanent_bean_mgr_remove(seq_mgr_impl->bean_mgr, env, 
-        (void *) msg_id, 
-        sandesha2_create_seq_retrieve_callback, 
-        sandesha2_create_seq_remove_callback, 
-        sql_retrieve, sql_remove);
+        sandesha2_create_seq_retrieve_callback, sql_retrieve, sql_remove);
 }
 
 static sandesha2_create_seq_bean_t *AXIS2_CALL
@@ -359,17 +316,17 @@
     const axis2_env_t *env,
     axis2_char_t *msg_id)
 {
-    axis2_char_t *sql_retrieve = NULL;
+    axis2_char_t sql_retrieve[256];
     sandesha2_permanent_create_seq_mgr_t *seq_mgr_impl = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FALSE);
     AXIS2_PARAM_CHECK(env->error, msg_id, AXIS2_FALSE);
     seq_mgr_impl = SANDESHA2_INTF_TO_IMPL(seq_mgr);
-    sql_retrieve = "select create_seq_msg_id, internal_seq_id,"\
+
+    sprintf(sql_retrieve, "select create_seq_msg_id, internal_seq_id,"\
         "seq_id, create_seq_msg_store_key, ref_msg_store_key from create_seq "\
-        "where create_seq_msg_id=?";
+        "where create_seq_msg_id='%s';", msg_id);
     return (sandesha2_create_seq_bean_t *) sandesha2_permanent_bean_mgr_retrieve(
-        seq_mgr_impl->bean_mgr, env, (void *) msg_id, 
-        sandesha2_create_seq_retrieve_callback, 
+        seq_mgr_impl->bean_mgr, env, sandesha2_create_seq_retrieve_callback, 
         sql_retrieve);
 }
 
@@ -380,12 +337,18 @@
     sandesha2_create_seq_bean_t *bean)
 {
     sandesha2_permanent_create_seq_mgr_t *seq_mgr_impl = NULL;
-    axis2_char_t *sql_update = NULL;
-    axis2_char_t *sql_retrieve = NULL;
+    axis2_char_t sql_retrieve[256];
+    axis2_char_t sql_update[1024];
     axis2_bool_t ret = AXIS2_FALSE;
 
     axis2_char_t *create_seq_msg_id = sandesha2_create_seq_bean_get_create_seq_msg_id(
         (sandesha2_rm_bean_t *) bean, env);
+    axis2_char_t *internal_seq_id = sandesha2_create_seq_bean_get_internal_seq_id(bean, env);
+    axis2_char_t *seq_id = sandesha2_create_seq_bean_get_seq_id(bean, env);
+    axis2_char_t *create_seq_msg_store_key = 
+        sandesha2_create_seq_bean_get_create_seq_msg_store_key(bean, env);
+    axis2_char_t *ref_msg_store_key = 
+        sandesha2_create_seq_bean_get_ref_msg_store_key(bean, env);
 
     AXIS2_LOG_INFO(env->log, 
         "Entry:[sandesha2]sandesha2_permanent_create_seq_mgr_update");
@@ -393,16 +356,15 @@
     AXIS2_PARAM_CHECK(env->error, bean, AXIS2_FALSE);
     seq_mgr_impl = SANDESHA2_INTF_TO_IMPL(seq_mgr);
 
-    sql_retrieve = "select create_seq_msg_id, internal_seq_id,"\
+    sprintf(sql_retrieve, "select create_seq_msg_id, internal_seq_id,"\
         "seq_id, create_seq_msg_store_key, ref_msg_store_key from create_seq "\
-        "where create_seq_msg_id=?";
-    sql_update = "update create_seq set internal_seq_id=?, seq_id=?, "\
-        "create_seq_msg_store_key=? ref_msg_store_key=? where"\
-        " create_seq_msg_id=?";
+        "where create_seq_msg_id='%s';", create_seq_msg_id);
+    sprintf(sql_update, "update create_seq set internal_seq_id='%s', seq_id='%s'"\
+        ",create_seq_msg_store_key='%s', ref_msg_store_key='%s' where "\
+        "create_seq_msg_id='%s';", internal_seq_id, seq_id, 
+        create_seq_msg_store_key, ref_msg_store_key, create_seq_msg_id);
     ret = sandesha2_permanent_bean_mgr_update(seq_mgr_impl->bean_mgr, env, 
-        (void *) create_seq_msg_id,(sandesha2_rm_bean_t *)bean, 
-        sandesha2_create_seq_retrieve_callback, 
-        sandesha2_create_seq_update_or_insert_callback, 
+        (sandesha2_rm_bean_t *)bean, sandesha2_create_seq_retrieve_callback, 
         sql_retrieve, sql_update);
     AXIS2_LOG_INFO(env->log, 
         "Exit:[sandesha2]sandesha2_permanent_create_seq_mgr_update:return:%d", 
@@ -428,7 +390,7 @@
         "seq_id,create_seq_msg_store_key, ref_msg_store_key from create_seq;";
     sql_count = "select count(*) as no_recs from create_seq;";
     ret = sandesha2_permanent_bean_mgr_find(seq_mgr_impl->bean_mgr, env, 
-        (sandesha2_rm_bean_t *) bean, sandesha2_create_seq_retrieve_callback,
+        (sandesha2_rm_bean_t *) bean, sandesha2_create_seq_find_callback,
         sandesha2_create_seq_count_callback, sql_find, sql_count);
     AXIS2_LOG_INFO(env->log, 
         "Exit:[sandesha2]sandesha2_permanent_create_seq_mgr_find");
@@ -452,7 +414,7 @@
     sql_count = "select count(*) as no_recs from create_seq;";
     return (sandesha2_create_seq_bean_t *) sandesha2_permanent_bean_mgr_find_unique(
         seq_mgr_impl->bean_mgr, env, (sandesha2_rm_bean_t *) bean, 
-        sandesha2_create_seq_retrieve_callback, sandesha2_create_seq_count_callback, 
+        sandesha2_create_seq_find_callback, sandesha2_create_seq_count_callback, 
         sql_find, sql_count);
 }
 



---------------------------------------------------------------------
To unsubscribe, e-mail: sandesha-dev-unsubscribe@ws.apache.org
For additional commands, e-mail: sandesha-dev-help@ws.apache.org