You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@subversion.apache.org by rh...@apache.org on 2012/07/05 19:40:10 UTC

svn commit: r1357760 - in /subversion/trunk/subversion/libsvn_wc: entries.c upgrade.c wc.h wc_db.c

Author: rhuijben
Date: Thu Jul  5 17:40:09 2012
New Revision: 1357760

URL: http://svn.apache.org/viewvc?rev=1357760&view=rev
Log:
Combine the code to convert from separate in-db values to a conflict skel in
one place instead of writing it a third time for the format bump code. Add
an initial version of the format bump code.

* subversion/libsvn_wc/entries.c
  (insert_actual_node): Use svn_wc__upgrade_conflict_skel_from_raw().

* subversion/libsvn_wc/upgrade.c
  (includes): Add conflicts.h
  (svn_wc__upgrade_conflict_skel_from_raw): New function.
  (bump_to_30): New function.
  (svn_wc__upgrade_sdb): Add disabled bump to 30.

* subversion/libsvn_wc/wc.h
  (svn_wc__upgrade_conflict_skel_from_raw): New function.

* subversion/libsvn_wc/wc_db.c
  (svn_wc__upgrade_conflict_skel_from_raw): Use
     svn_wc__upgrade_conflict_skel_from_raw instead of duplicating the code.

Modified:
    subversion/trunk/subversion/libsvn_wc/entries.c
    subversion/trunk/subversion/libsvn_wc/upgrade.c
    subversion/trunk/subversion/libsvn_wc/wc.h
    subversion/trunk/subversion/libsvn_wc/wc_db.c

Modified: subversion/trunk/subversion/libsvn_wc/entries.c
URL: http://svn.apache.org/viewvc/subversion/trunk/subversion/libsvn_wc/entries.c?rev=1357760&r1=1357759&r2=1357760&view=diff
==============================================================================
--- subversion/trunk/subversion/libsvn_wc/entries.c (original)
+++ subversion/trunk/subversion/libsvn_wc/entries.c Thu Jul  5 17:40:09 2012
@@ -1541,125 +1541,19 @@ insert_actual_node(svn_sqlite__db_t *sdb
   if (actual_node->tree_conflict_data)
     SVN_ERR(svn_sqlite__bind_text(stmt, 11, actual_node->tree_conflict_data));
 #else
-  /* ### TODO; Bind conflict skel in column 6 */
-  if (actual_node->conflict_old
-      || actual_node->conflict_new
-      || actual_node->conflict_working)
-    {
-      const char *old_abspath = NULL;
-      const char *new_abspath = NULL;
-      const char *wrk_abspath = NULL;
-
-      if (!conflict_data)
-        conflict_data = svn_wc__conflict_skel_create(scratch_pool);
-
-      if (actual_node->conflict_old)
-        SVN_ERR(svn_wc__db_from_relpath(&old_abspath, db, wri_abspath,
-                                        actual_node->conflict_old,
-                                        scratch_pool, scratch_pool));
-
-      if (actual_node->conflict_new)
-        SVN_ERR(svn_wc__db_from_relpath(&new_abspath, db, wri_abspath,
-                                        actual_node->conflict_new,
-                                        scratch_pool, scratch_pool));
-
-      if (actual_node->conflict_working)
-        SVN_ERR(svn_wc__db_from_relpath(&wrk_abspath, db, wri_abspath,
-                                        actual_node->conflict_working,
-                                        scratch_pool, scratch_pool));
-
-      SVN_ERR(svn_wc__conflict_skel_add_text_conflict(conflict_data,
-                                                      db, wri_abspath,
-                                                      wrk_abspath,
-                                                      old_abspath,
-                                                      new_abspath,
-                                                      scratch_pool,
-                                                      scratch_pool));
-    }
-
-  if (actual_node->prop_reject)
-    {
-      const char *prej_abspath;
-
-      if (!conflict_data)
-        conflict_data = svn_wc__conflict_skel_create(scratch_pool);
-
-      SVN_ERR(svn_wc__db_from_relpath(&prej_abspath, db, wri_abspath,
-                                      actual_node->prop_reject,
-                                      scratch_pool, scratch_pool));
-
-      SVN_ERR(svn_wc__conflict_skel_add_prop_conflict(conflict_data,
-                                                      db, wri_abspath,
-                                                      prej_abspath,
-                                                      NULL, NULL, NULL,
-                                                apr_hash_make(scratch_pool),
-                                                      scratch_pool,
-                                                      scratch_pool));
-    }
-
-  if (actual_node->tree_conflict_data)
-    {
-      svn_skel_t *tc_skel;
-      const svn_wc_conflict_description2_t *tc;
-      const char *local_abspath;
-
-      if (!conflict_data)
-        conflict_data = svn_wc__conflict_skel_create(scratch_pool);
-
-      tc_skel = svn_skel__parse(actual_node->tree_conflict_data,
-                                strlen(actual_node->tree_conflict_data),
-                                 scratch_pool);
-
-      SVN_ERR(svn_wc__db_from_relpath(&local_abspath, db, wri_abspath,
-                                      actual_node->local_relpath,
-                                       scratch_pool, scratch_pool));
-
-      SVN_ERR(svn_wc__deserialize_conflict(&tc, tc_skel,
-                                           svn_dirent_dirname(local_abspath,
-                                                              scratch_pool),
-                                           scratch_pool, scratch_pool));
-
-      SVN_ERR(svn_wc__conflict_skel_add_tree_conflict(conflict_data,
-                                                      db, wri_abspath,
-                                                      tc->reason,
-                                                      tc->action,
-                                                      scratch_pool,
-                                                      scratch_pool));
-
-      switch (tc->operation)
-        {
-          case svn_wc_operation_update:
-          default:
-            SVN_ERR(svn_wc__conflict_skel_set_op_update(conflict_data,
-                                                       tc->src_left_version,
-                                                       scratch_pool,
-                                                       scratch_pool));
-            break;
-          case svn_wc_operation_switch:
-            SVN_ERR(svn_wc__conflict_skel_set_op_switch(conflict_data,
-                                                        tc->src_left_version,
-                                                        scratch_pool,
-                                                        scratch_pool));
-            break;
-          case svn_wc_operation_merge:
-            SVN_ERR(svn_wc__conflict_skel_set_op_merge(conflict_data,
-                                                       tc->src_left_version,
-                                                       tc->src_right_version,
-                                                       scratch_pool,
-                                                       scratch_pool));
-            break;
-        }
-    }
-  else if (conflict_data)
-    {
-      SVN_ERR(svn_wc__conflict_skel_set_op_update(conflict_data, NULL,
-                                                  scratch_pool,
-                                                  scratch_pool));
-    }
+  SVN_ERR(svn_wc__upgrade_conflict_skel_from_raw(&conflict_data,
+                                                 db, wri_abspath,
+                                                 actual_node->local_relpath,
+                                                 actual_node->conflict_old,
+                                                 actual_node->conflict_working,
+                                                 actual_node->conflict_new,
+                                                 actual_node->prop_reject,
+                                                 actual_node->tree_conflict_data,
+                                                 scratch_pool, scratch_pool));
 
   if (conflict_data)
     {
-      svn_stringbuf_t *data =svn_skel__unparse(conflict_data, scratch_pool);
+      svn_stringbuf_t *data = svn_skel__unparse(conflict_data, scratch_pool);
 
       SVN_ERR(svn_sqlite__bind_blob(stmt, 6, data->data, data->len));
     }

Modified: subversion/trunk/subversion/libsvn_wc/upgrade.c
URL: http://svn.apache.org/viewvc/subversion/trunk/subversion/libsvn_wc/upgrade.c?rev=1357760&r1=1357759&r2=1357760&view=diff
==============================================================================
--- subversion/trunk/subversion/libsvn_wc/upgrade.c (original)
+++ subversion/trunk/subversion/libsvn_wc/upgrade.c Thu Jul  5 17:40:09 2012
@@ -31,6 +31,7 @@
 
 #include "wc.h"
 #include "adm_files.h"
+#include "conflicts.h"
 #include "entries.h"
 #include "wc_db.h"
 #include "tree_conflicts.h"
@@ -1364,6 +1365,202 @@ bump_to_29(void *baton, svn_sqlite__db_t
   return SVN_NO_ERROR;
 }
 
+svn_error_t *
+svn_wc__upgrade_conflict_skel_from_raw(svn_skel_t **conflicts,
+                                       svn_wc__db_t *db,
+                                       const char *wri_abspath,
+                                       const char *local_relpath,
+                                       const char *conflict_old,
+                                       const char *conflict_wrk,
+                                       const char *conflict_new,
+                                       const char *prej_file,
+                                       const char *tree_conflict_data,
+                                       apr_size_t tree_conflict_len,
+                                       apr_pool_t *result_pool,
+                                       apr_pool_t *scratch_pool)
+{
+  svn_skel_t *conflict_data = NULL;
+  
+  if (conflict_old || conflict_new || conflict_wrk)
+    {
+      const char *old_abspath = NULL;
+      const char *new_abspath = NULL;
+      const char *wrk_abspath = NULL;
+
+      conflict_data = svn_wc__conflict_skel_create(result_pool);
+
+      if (conflict_old)
+        SVN_ERR(svn_wc__db_from_relpath(&old_abspath, db, wri_abspath,
+                                        conflict_old,
+                                        scratch_pool, scratch_pool));
+
+      if (conflict_new)
+        SVN_ERR(svn_wc__db_from_relpath(&new_abspath, db, wri_abspath,
+                                        conflict_new,
+                                        scratch_pool, scratch_pool));
+
+      if (conflict_wrk)
+        SVN_ERR(svn_wc__db_from_relpath(&wrk_abspath, db, wri_abspath,
+                                        conflict_wrk,
+                                        scratch_pool, scratch_pool));
+
+      SVN_ERR(svn_wc__conflict_skel_add_text_conflict(conflict_data,
+                                                      db, wri_abspath,
+                                                      wrk_abspath,
+                                                      old_abspath,
+                                                      new_abspath,
+                                                      scratch_pool,
+                                                      scratch_pool));
+    }
+
+  if (prej_file)
+    {
+      const char *prej_abspath;
+
+      if (!conflict_data)
+        conflict_data = svn_wc__conflict_skel_create(result_pool);
+
+      SVN_ERR(svn_wc__db_from_relpath(&prej_abspath, db, wri_abspath,
+                                      prej_file,
+                                      scratch_pool, scratch_pool));
+
+      SVN_ERR(svn_wc__conflict_skel_add_prop_conflict(conflict_data,
+                                                      db, wri_abspath,
+                                                      prej_abspath,
+                                                      NULL, NULL, NULL,
+                                                apr_hash_make(scratch_pool),
+                                                      scratch_pool,
+                                                      scratch_pool));
+    }
+
+  if (tree_conflict_data)
+    {
+      svn_skel_t *tc_skel;
+      const svn_wc_conflict_description2_t *tc;
+      const char *local_abspath;
+
+      if (!conflict_data)
+        conflict_data = svn_wc__conflict_skel_create(scratch_pool);
+
+      tc_skel = svn_skel__parse(tree_conflict_data, tree_conflict_len,
+                                scratch_pool);
+
+      SVN_ERR(svn_wc__db_from_relpath(&local_abspath, db, wri_abspath,
+                                      local_relpath,
+                                      scratch_pool, scratch_pool));
+
+      SVN_ERR(svn_wc__deserialize_conflict(&tc, tc_skel,
+                                           svn_dirent_dirname(local_abspath,
+                                                              scratch_pool),
+                                           scratch_pool, scratch_pool));
+
+      SVN_ERR(svn_wc__conflict_skel_add_tree_conflict(conflict_data,
+                                                      db, wri_abspath,
+                                                      tc->reason,
+                                                      tc->action,
+                                                      scratch_pool,
+                                                      scratch_pool));
+
+      switch (tc->operation)
+        {
+          case svn_wc_operation_update:
+          default:
+            SVN_ERR(svn_wc__conflict_skel_set_op_update(conflict_data,
+                                                       tc->src_left_version,
+                                                       scratch_pool,
+                                                       scratch_pool));
+            break;
+          case svn_wc_operation_switch:
+            SVN_ERR(svn_wc__conflict_skel_set_op_switch(conflict_data,
+                                                        tc->src_left_version,
+                                                        scratch_pool,
+                                                        scratch_pool));
+            break;
+          case svn_wc_operation_merge:
+            SVN_ERR(svn_wc__conflict_skel_set_op_merge(conflict_data,
+                                                       tc->src_left_version,
+                                                       tc->src_right_version,
+                                                       scratch_pool,
+                                                       scratch_pool));
+            break;
+        }
+    }
+  else if (conflict_data)
+    {
+      SVN_ERR(svn_wc__conflict_skel_set_op_update(conflict_data, NULL,
+                                                  scratch_pool,
+                                                  scratch_pool));
+    }
+
+  *conflicts = conflict_data;
+  return SVN_NO_ERROR;
+}
+
+static svn_error_t *
+bump_to_30(void *baton, svn_sqlite__db_t *sdb, apr_pool_t *scratch_pool)
+{
+  struct bump_baton *bb = baton;
+  svn_boolean_t have_row;
+  apr_pool_t *iterpool = svn_pool_create(scratch_pool);
+  svn_sqlite__stmt_t *stmt;
+  svn_sqlite__stmt_t *stmt_store;
+  svn_wc__db_t *db; /* Read only temp db */
+  const char *wri_abspath = bb->wcroot_abspath;
+
+  SVN_ERR(svn_wc__db_open(&db, NULL, FALSE, FALSE,
+                          scratch_pool, scratch_pool));
+
+  SVN_ERR(svn_sqlite__get_statement(&stmt_store, sdb,
+                                    STMT_UPGRADE_30_SET_CONFLICT));
+
+  SVN_ERR(svn_sqlite__get_statement(&stmt, sdb,
+                                    STMT_UPGRADE_30_SELECT_CONFLICT_SEPARATE));
+  SVN_ERR(svn_sqlite__step(&have_row, stmt));
+
+  while (have_row)
+    {
+      svn_stringbuf_t *skel_data;
+      svn_skel_t *conflict_data;
+      apr_int64_t wc_id = svn_sqlite__column_int64(stmt, 0);
+      const char *local_relpath = svn_sqlite__column_text(stmt, 1, NULL);
+      const char *conflict_old = svn_sqlite__column_text(stmt, 2, NULL);
+      const char *conflict_wrk = svn_sqlite__column_text(stmt, 3, NULL);
+      const char *conflict_new = svn_sqlite__column_text(stmt, 4, NULL);
+      const char *prop_reject = svn_sqlite__column_text(stmt, 5, NULL);
+      apr_size_t tree_conflict_size;
+      const char *tree_conflict_data = svn_sqlite__column_blob(stmt, 6,
+                                               &tree_conflict_size, NULL);
+
+      svn_pool_clear(iterpool);
+
+      SVN_ERR(svn_wc__upgrade_conflict_skel_from_raw(&conflict_data,
+                                                     db, wri_abspath,
+                                                     local_relpath,
+                                                     conflict_old,
+                                                     conflict_wrk,
+                                                     conflict_new,
+                                                     prop_reject,
+                                                     tree_conflict_data,
+                                                     tree_conflict_size,
+                                                     iterpool, iterpool));
+
+      SVN_ERR_ASSERT(conflict_data != NULL);
+
+      skel_data = svn_skel__unparse(conflict_data, iterpool);
+
+      SVN_ERR(svn_sqlite__bindf(stmt_store, "isb", wc_id, local_relpath,
+                                skel_data->data, skel_data->len));
+      SVN_ERR(svn_sqlite__step_done(stmt_store));
+
+      SVN_ERR(svn_sqlite__step(&have_row, stmt));
+    }
+  SVN_ERR(svn_sqlite__reset(stmt));
+
+  SVN_ERR(svn_sqlite__exec_statements(sdb, STMT_UPGRADE_TO_30));
+  SVN_ERR(svn_wc__db_close(db));
+  return SVN_NO_ERROR;
+}
+
 
 struct upgrade_data_t {
   svn_sqlite__db_t *sdb;
@@ -1637,6 +1834,13 @@ svn_wc__upgrade_sdb(int *result_format,
         *result_format = 29;
         /* FALLTHROUGH  */
 
+#ifdef NOT_YET
+      case 29:
+        SVN_ERR(svn_sqlite__with_transaction(sdb, bump_to_30, &bb,
+                                             scratch_pool));
+        *result_format = 30;
+        /* FALLTHROUGH  */
+#endif
       /* ### future bumps go here.  */
 #if 0
       case XXX-1:

Modified: subversion/trunk/subversion/libsvn_wc/wc.h
URL: http://svn.apache.org/viewvc/subversion/trunk/subversion/libsvn_wc/wc.h?rev=1357760&r1=1357759&r2=1357760&view=diff
==============================================================================
--- subversion/trunk/subversion/libsvn_wc/wc.h (original)
+++ subversion/trunk/subversion/libsvn_wc/wc.h Thu Jul  5 17:40:09 2012
@@ -653,6 +653,20 @@ svn_wc__upgrade_sdb(int *result_format,
                     int start_format,
                     apr_pool_t *scratch_pool);
 
+/* Create a conflict skel from the old separated data */
+svn_error_t *
+svn_wc__upgrade_conflict_skel_from_raw(svn_skel_t **conflicts,
+                                       svn_wc__db_t *db,
+                                       const char *wri_abspath,
+                                       const char *local_relpath,
+                                       const char *conflict_old,
+                                       const char *conflict_wrk,
+                                       const char *conflict_new,
+                                       const char *prej_file,
+                                       const char *tree_conflict_data,
+                                       apr_size_t tree_conflict_len,
+                                       apr_pool_t *result_pool,
+                                       apr_pool_t *scratch_pool);
 
 svn_error_t *
 svn_wc__wipe_postupgrade(const char *dir_abspath,

Modified: subversion/trunk/subversion/libsvn_wc/wc_db.c
URL: http://svn.apache.org/viewvc/subversion/trunk/subversion/libsvn_wc/wc_db.c?rev=1357760&r1=1357759&r2=1357760&view=diff
==============================================================================
--- subversion/trunk/subversion/libsvn_wc/wc_db.c (original)
+++ subversion/trunk/subversion/libsvn_wc/wc_db.c Thu Jul  5 17:40:09 2012
@@ -12050,111 +12050,30 @@ svn_wc__db_read_conflict(svn_skel_t **co
     const char *conflict_new = svn_sqlite__column_text(stmt, 4, NULL);
     const char *conflict_wrk = svn_sqlite__column_text(stmt, 5, NULL);
     const char *conflict_prj = svn_sqlite__column_text(stmt, 6, NULL);
-    const char *tree_conflict = svn_sqlite__column_text(stmt, 7, NULL);
+    apr_size_t tree_conflict_len;
+    const char *tree_conflict_data;
     svn_skel_t *conflict_skel = NULL;
-    svn_error_t *err = NULL;
+    svn_error_t *err;
 
-    if (conflict_old || conflict_new || conflict_wrk)
-      {
-        conflict_skel = svn_wc__conflict_skel_create(result_pool);
-
-        if (conflict_old)
-          conflict_old = svn_dirent_join(wcroot->abspath, conflict_old,
-                                         scratch_pool);
-
-        if (conflict_new)
-          conflict_new = svn_dirent_join(wcroot->abspath, conflict_new,
-                                         scratch_pool);
-
-        if (conflict_wrk)
-          conflict_wrk = svn_dirent_join(wcroot->abspath, conflict_wrk,
-                                         scratch_pool);
-
-        err = svn_wc__conflict_skel_add_text_conflict(conflict_skel,
-                                                      db, local_abspath,
-                                                      conflict_wrk,
-                                                      conflict_old,
-                                                      conflict_new,
-                                                      result_pool,
-                                                      scratch_pool);
-      }
-
-    if (!err && conflict_prj)
-      {
-        if (!conflict_skel)
-          conflict_skel = svn_wc__conflict_skel_create(result_pool);
-
-        if (conflict_prj)
-          conflict_prj = svn_dirent_join(wcroot->abspath, conflict_prj,
-                                         scratch_pool);
-
-        err = svn_wc__conflict_skel_add_prop_conflict(conflict_skel,
-                                                      db, local_abspath,
-                                                      conflict_prj,
-                                                      NULL, NULL, NULL,
-                                                  apr_hash_make(scratch_pool),
-                                                      result_pool,
-                                                      scratch_pool);
-      }
-
-    if (!err && tree_conflict)
-      {
-        const svn_wc_conflict_description2_t *tc;
-        const svn_skel_t *tc_skel;
-        if (!conflict_skel)
-          conflict_skel = svn_wc__conflict_skel_create(result_pool);
-
-        tc_skel = svn_skel__parse(tree_conflict, strlen(tree_conflict),
-                                  scratch_pool);
-        err = svn_wc__deserialize_conflict(
-                          &tc, tc_skel,
-                          svn_dirent_dirname(local_abspath, scratch_pool),
-                          scratch_pool, scratch_pool);
-
-        if (!err)
-          err = svn_wc__conflict_skel_add_tree_conflict(conflict_skel,
-                                                        db, local_abspath,
-                                                        tc->reason,
-                                                        tc->action,
-                                                        result_pool,
-                                                        scratch_pool);
-
-        if (!err)
-          switch (tc->operation)
-            {
-              case svn_wc_operation_merge:
-                err = svn_wc__conflict_skel_set_op_merge(conflict_skel,
-                                                         tc->src_left_version,
-                                                         tc->src_right_version,
-                                                         result_pool,
-                                                         scratch_pool);
-                break;
-              case svn_wc_operation_update:
-              default:
-                err = svn_wc__conflict_skel_set_op_update(conflict_skel,
-                                                          tc->src_left_version,
-                                                          result_pool,
-                                                          scratch_pool);
-                break;
-              case svn_wc_operation_switch:
-                err = svn_wc__conflict_skel_set_op_switch(conflict_skel,
-                                                          tc->src_left_version,
-                                                          result_pool,
-                                                          scratch_pool);
-                break;
-            }
-      }
-    else if (!err && conflict_skel)
-      {
-        err = svn_wc__conflict_skel_set_op_update(conflict_skel, NULL,
-                                                  result_pool, scratch_pool);
-      }
+    tree_conflict_data = svn_sqlite__column_blob(stmt, 7, &tree_conflict_len,
+                                                 NULL);
 
-    if (err)
-      return svn_error_trace(
-                        svn_error_compose_create(err, svn_sqlite__reset(stmt)));
+    err = svn_wc__upgrade_conflict_skel_from_raw(&conflict_skel,
+                                                 db, local_abspath,
+                                                 local_relpath,
+                                                 conflict_old,
+                                                 conflict_wrk,
+                                                 conflict_new,
+                                                 conflict_prj,
+                                                 tree_conflict_data,
+                                                 tree_conflict_len,
+                                                 result_pool,
+                                                 scratch_pool);
 
     *conflict = conflict_skel;
+    
+    return svn_error_trace(
+                svn_error_compose_create(err, svn_sqlite__reset(stmt)));
   }
 #else
   {
@@ -12168,10 +12087,10 @@ svn_wc__db_read_conflict(svn_skel_t **co
       *conflict = svn_skel__parse(cfl_data, cfl_len, result_pool);
     else
       *conflict = NULL;
+
+    return svn_error_trace(svn_sqlite__reset(stmt));
   }
 #endif
-
-  return svn_error_trace(svn_sqlite__reset(stmt));
 }