SONAR-8867 enforce definition and metadata are inserted/updated separately

server/sonar-db-dao/src/main/java/org/sonar/db/rule/RuleDao.java

     return mapper(session).selectByQuery(ruleQuery);
   }
 
-  public void insert(DbSession session, RuleDto dto) {
-    RuleDefinitionDto ruleDefinitionDto = definitionOf(dto);
-    mapper(session).insert(ruleDefinitionDto);
-    dto.setId(ruleDefinitionDto.getId());
-    // FIXME it doesn't make sense to insert metadata when creating a new rule in table RULES unless it is a custom rule
-    mapper(session).updateMetadata(metadataOf(dto));
-  }
-
-  public void update(DbSession session, RuleDto dto) {
-    mapper(session).updateDefinition(definitionOf(dto).setId(dto.getId()));
-    RuleMetadataDto ruleMetadata = metadataOf(dto);
-    mapper(session).updateMetadata(ruleMetadata);
-  }
-
-  private static RuleMetadataDto metadataOf(RuleDto dto) {
-    return new RuleMetadataDto()
-        .setRuleId(dto.getId())
-        .setNoteData(dto.getNoteData())
-        .setNoteUserLogin(dto.getNoteUserLogin())
-        .setNoteCreatedAt(dto.getNoteCreatedAt())
-        .setNoteUpdatedAt(dto.getNoteUpdatedAt())
-        .setRemediationFunction(dto.getRemediationFunction())
-        .setRemediationGapMultiplier(dto.getRemediationGapMultiplier())
-        .setRemediationBaseEffort(dto.getRemediationBaseEffort())
-        .setTags(dto.getTags())
-        .setUpdatedAt(dto.getUpdatedAt());
-  }
-
-  private static RuleDefinitionDto definitionOf(RuleDto dto) {
-    return new RuleDefinitionDto()
-      .setRepositoryKey(dto.getRepositoryKey())
-      .setRuleKey(dto.getRuleKey())
-      .setDescription(dto.getDescription())
-      .setDescriptionFormat(dto.getDescriptionFormat())
-      .setStatus(dto.getStatus())
-      .setName(dto.getName())
-      .setConfigKey(dto.getConfigKey())
-      .setSeverity(dto.getSeverity())
-      .setIsTemplate(dto.isTemplate())
-      .setLanguage(dto.getLanguage())
-      .setTemplateId(dto.getTemplateId())
-      .setDefaultRemediationFunction(dto.getDefaultRemediationFunction())
-      .setDefaultRemediationGapMultiplier(dto.getDefaultRemediationGapMultiplier())
-      .setDefaultRemediationBaseEffort(dto.getDefaultRemediationBaseEffort())
-      .setGapDescription(dto.getGapDescription())
-      .setSystemTags(dto.getSystemTags())
-      .setType(dto.getType())
-      .setCreatedAt(dto.getCreatedAt())
-      .setUpdatedAt(dto.getUpdatedAt());
+  public void insert(DbSession session, RuleDefinitionDto dto) {
+    mapper(session).insert(dto);
+  }
+
+  public void update(DbSession session, RuleDefinitionDto dto) {
+    mapper(session).updateDefinition(dto);
+  }
+
+  public void update(DbSession session, RuleMetadataDto dto) {
+    mapper(session).updateMetadata(dto);
   }
 
   private static RuleMapper mapper(DbSession session) {
     return executeLargeInputs(ruleIds, mapper(dbSession)::selectParamsByRuleIds);
   }
 
-  public void insertRuleParam(DbSession session, RuleDto rule, RuleParamDto param) {
+  public void insertRuleParam(DbSession session, RuleDefinitionDto rule, RuleParamDto param) {
     checkNotNull(rule.getId(), "Rule id must be set");
     param.setRuleId(rule.getId());
     mapper(session).insertParameter(param);
   }
 
-  public RuleParamDto updateRuleParam(DbSession session, RuleDto rule, RuleParamDto param) {
+  public RuleParamDto updateRuleParam(DbSession session, RuleDefinitionDto rule, RuleParamDto param) {
     checkNotNull(rule.getId(), "Rule id must be set");
     checkNotNull(param.getId(), "Rule parameter is not yet persisted must be set");
     param.setRuleId(rule.getId());

server/sonar-db-dao/src/main/java/org/sonar/db/rule/RuleDto.java

 
   public RuleDto setUpdatedAt(long updatedAt) {
     definition.setUpdatedAt(updatedAt);
+    metadata.setUpdatedAt(updatedAt);
     return this;
   }
 

server/sonar-db-dao/src/main/java/org/sonar/db/rule/RuleParamDto.java

     return new ReflectionToStringBuilder(this, ToStringStyle.SHORT_PREFIX_STYLE).toString();
   }
 
-  public static RuleParamDto createFor(RuleDto rule) {
+  public static RuleParamDto createFor(RuleDefinitionDto rule) {
     // Should eventually switch to RuleKey (RuleKey is available before insert)
     return new RuleParamDto().setRuleId(rule.getId());
   }

server/sonar-db-dao/src/test/java/org/sonar/db/issue/IssueDaoTest.java

   }
 
   private void prepareTables() {
-    dbTester.getDbClient().ruleDao().insert(dbTester.getSession(), RULE);
+    dbTester.rules().insertRule(RULE);
     OrganizationDto organizationDto = dbTester.organizations().insert();
     ComponentDto projectDto = dbTester.components().insertProject(organizationDto, (t) -> t.setUuid(PROJECT_UUID).setKey(PROJECT_KEY));
     dbTester.components().insertComponent(ComponentTesting.newFileDto(projectDto).setUuid(FILE_UUID).setKey(FILE_KEY));

server/sonar-db-dao/src/test/java/org/sonar/db/issue/IssueMapperTest.java

     file2 = ComponentTesting.newFileDto(project, null).setUuid("file2 uuid");
     dbTester.getDbClient().componentDao().insert(dbSession, file2);
     rule = RuleTesting.newXooX1();
-    dbTester.getDbClient().ruleDao().insert(dbSession, rule);
+    dbTester.rules().insertRule(rule);
     dbSession.commit();
   }
 

server/sonar-db-dao/src/test/java/org/sonar/db/qualityprofile/ActiveRuleDaoTest.java

 
     dbClient.qualityProfileDao().insert(dbSession, profile1);
     dbClient.qualityProfileDao().insert(dbSession, profile2);
-    dbClient.ruleDao().insert(dbSession, rule1);
-    dbClient.ruleDao().insert(dbSession, rule2);
-    dbClient.ruleDao().insert(dbSession, rule3);
+    dbTester.rules().insertRule(rule1);
+    dbTester.rules().insertRule(rule2);
+    dbTester.rules().insertRule(rule3);
 
     rule1Param1 = new RuleParamDto()
       .setName("param1")
       .setDefaultValue("value1")
       .setType(RuleParamType.STRING.toString());
-    dbClient.ruleDao().insertRuleParam(dbSession, rule1, rule1Param1);
+    dbClient.ruleDao().insertRuleParam(dbSession, rule1.getDefinition(), rule1Param1);
 
     rule1Param2 = new RuleParamDto()
       .setRuleId(rule1.getId())
       .setName("param2")
       .setDefaultValue("2")
       .setType(RuleParamType.INTEGER.toString());
-    dbClient.ruleDao().insertRuleParam(dbSession, rule1, rule1Param2);
+    dbClient.ruleDao().insertRuleParam(dbSession, rule1.getDefinition(), rule1Param2);
 
     rule2Param1 = new RuleParamDto()
       .setRuleId(rule2.getId())
       .setName("param1")
       .setDefaultValue("1")
       .setType(RuleParamType.INTEGER.toString());
-    dbClient.ruleDao().insertRuleParam(dbSession, rule2, rule2Param1);
+    dbClient.ruleDao().insertRuleParam(dbSession, rule2.getDefinition(), rule2Param1);
 
     dbSession.commit();
   }
   @Test
   public void select_by_profile_ignore_removed_rules() {
     RuleDto removedRule = RuleTesting.newDto(RuleKey.of("removed", "rule")).setStatus(RuleStatus.REMOVED);
-    dbClient.ruleDao().insert(dbTester.getSession(), removedRule);
+    dbTester.rules().insertRule(removedRule);
     ActiveRuleDto activeRule = createFor(profile1, removedRule).setSeverity(BLOCKER);
     underTest.insert(dbTester.getSession(), activeRule);
     dbSession.commit();

server/sonar-db-dao/src/test/java/org/sonar/db/rule/RuleDaoTest.java

 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.guava.api.Assertions.assertThat;
 
-
 public class RuleDaoTest {
 
   @Rule
     dbTester.prepareDbUnit(getClass(), "shared.xml");
 
     assertThat(underTest.selectByIds(dbTester.getSession(), asList(1))).hasSize(1);
-    assertThat(underTest.selectByIds(dbTester.getSession(), asList(1,2))).hasSize(2);
-    assertThat(underTest.selectByIds(dbTester.getSession(), asList(1,2,3))).hasSize(2);
+    assertThat(underTest.selectByIds(dbTester.getSession(), asList(1, 2))).hasSize(2);
+    assertThat(underTest.selectByIds(dbTester.getSession(), asList(1, 2, 3))).hasSize(2);
 
     assertThat(underTest.selectByIds(dbTester.getSession(), asList(123))).isEmpty();
   }
 
   @Test
   public void insert() throws Exception {
-    RuleDto newRule = new RuleDto()
+    RuleDefinitionDto newRule = new RuleDefinitionDto()
       .setRuleKey("NewRuleKey")
       .setRepositoryKey("plugin")
       .setName("new name")
       .setIsTemplate(true)
       .setLanguage("dart")
       .setTemplateId(3)
-      .setNoteData("My note")
-      .setNoteUserLogin("admin")
-      .setNoteCreatedAt(DateUtils.parseDate("2013-12-19"))
-      .setNoteUpdatedAt(DateUtils.parseDate("2013-12-20"))
-      .setRemediationFunction(DebtRemediationFunction.Type.LINEAR.toString())
       .setDefaultRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.toString())
-      .setRemediationGapMultiplier("1h")
       .setDefaultRemediationGapMultiplier("5d")
-      .setRemediationBaseEffort("5min")
       .setDefaultRemediationBaseEffort("10h")
       .setGapDescription("squid.S115.effortToFix")
-      .setTags(newHashSet("tag1", "tag2"))
       .setSystemTags(newHashSet("systag1", "systag2"))
       .setType(RuleType.BUG)
       .setCreatedAt(1500000000000L)
     assertThat(ruleDto.getLanguage()).isEqualTo("dart");
     assertThat(ruleDto.isTemplate()).isTrue();
     assertThat(ruleDto.getTemplateId()).isEqualTo(3);
-    assertThat(ruleDto.getNoteData()).isEqualTo("My note");
-    assertThat(ruleDto.getNoteUserLogin()).isEqualTo("admin");
-    assertThat(ruleDto.getNoteCreatedAt()).isNotNull();
-    assertThat(ruleDto.getNoteUpdatedAt()).isNotNull();
-    assertThat(ruleDto.getRemediationFunction()).isEqualTo("LINEAR");
+    assertThat(ruleDto.getNoteData()).isNull();
+    assertThat(ruleDto.getNoteUserLogin()).isNull();
+    assertThat(ruleDto.getNoteCreatedAt()).isNull();
+    assertThat(ruleDto.getNoteUpdatedAt()).isNull();
+    assertThat(ruleDto.getRemediationFunction()).isNull();
     assertThat(ruleDto.getDefaultRemediationFunction()).isEqualTo("LINEAR_OFFSET");
-    assertThat(ruleDto.getRemediationGapMultiplier()).isEqualTo("1h");
+    assertThat(ruleDto.getRemediationGapMultiplier()).isNull();
     assertThat(ruleDto.getDefaultRemediationGapMultiplier()).isEqualTo("5d");
-    assertThat(ruleDto.getRemediationBaseEffort()).isEqualTo("5min");
+    assertThat(ruleDto.getRemediationBaseEffort()).isNull();
     assertThat(ruleDto.getDefaultRemediationBaseEffort()).isEqualTo("10h");
     assertThat(ruleDto.getGapDescription()).isEqualTo("squid.S115.effortToFix");
-    assertThat(ruleDto.getTags()).containsOnly("tag1", "tag2");
+    assertThat(ruleDto.getTags()).isEmpty();
     assertThat(ruleDto.getSystemTags()).containsOnly("systag1", "systag2");
     assertThat(ruleDto.getType()).isEqualTo(RuleType.BUG.getDbConstant());
     assertThat(ruleDto.getCreatedAt()).isEqualTo(1500000000000L);
   }
 
   @Test
-  public void update() {
+  public void update_RuleDefinitionDto() {
     dbTester.prepareDbUnit(getClass(), "update.xml");
 
-    RuleDto ruleToUpdate = new RuleDto()
+    RuleDefinitionDto ruleToUpdate = new RuleDefinitionDto()
       .setId(1)
       .setRuleKey("NewRuleKey")
       .setRepositoryKey("plugin")
       .setIsTemplate(true)
       .setLanguage("dart")
       .setTemplateId(3)
-      .setNoteData("My note")
-      .setNoteUserLogin("admin")
-      .setNoteCreatedAt(DateUtils.parseDate("2013-12-19"))
-      .setNoteUpdatedAt(DateUtils.parseDate("2013-12-20"))
-      .setRemediationFunction(DebtRemediationFunction.Type.LINEAR.toString())
       .setDefaultRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.toString())
-      .setRemediationGapMultiplier("1h")
       .setDefaultRemediationGapMultiplier("5d")
-      .setRemediationBaseEffort("5min")
       .setDefaultRemediationBaseEffort("10h")
       .setGapDescription("squid.S115.effortToFix")
-      .setTags(newHashSet("tag1", "tag2"))
       .setSystemTags(newHashSet("systag1", "systag2"))
       .setType(RuleType.BUG)
       .setUpdatedAt(2000000000000L);
     assertThat(ruleDto.getLanguage()).isEqualTo("dart");
     assertThat(ruleDto.isTemplate()).isTrue();
     assertThat(ruleDto.getTemplateId()).isEqualTo(3);
+    assertThat(ruleDto.getNoteData()).isNull();
+    assertThat(ruleDto.getNoteUserLogin()).isNull();
+    assertThat(ruleDto.getNoteCreatedAt()).isNull();
+    assertThat(ruleDto.getNoteUpdatedAt()).isNull();
+    assertThat(ruleDto.getRemediationFunction()).isNull();
+    assertThat(ruleDto.getDefaultRemediationFunction()).isEqualTo("LINEAR_OFFSET");
+    assertThat(ruleDto.getRemediationGapMultiplier()).isNull();
+    assertThat(ruleDto.getDefaultRemediationGapMultiplier()).isEqualTo("5d");
+    assertThat(ruleDto.getRemediationBaseEffort()).isNull();
+    assertThat(ruleDto.getDefaultRemediationBaseEffort()).isEqualTo("10h");
+    assertThat(ruleDto.getGapDescription()).isEqualTo("squid.S115.effortToFix");
+    assertThat(ruleDto.getTags()).isEmpty();
+    assertThat(ruleDto.getSystemTags()).containsOnly("systag1", "systag2");
+    assertThat(ruleDto.getType()).isEqualTo(RuleType.BUG.getDbConstant());
+    assertThat(ruleDto.getCreatedAt()).isEqualTo(1500000000000L);
+    assertThat(ruleDto.getUpdatedAt()).isEqualTo(2000000000000L);
+  }
+
+  @Test
+  public void update_RuleMetadataDto() {
+    dbTester.prepareDbUnit(getClass(), "update.xml");
+
+    RuleMetadataDto ruleToUpdate = new RuleMetadataDto()
+      .setRuleId(1)
+      .setNoteData("My note")
+      .setNoteUserLogin("admin")
+      .setNoteCreatedAt(DateUtils.parseDate("2013-12-19"))
+      .setNoteUpdatedAt(DateUtils.parseDate("2013-12-20"))
+      .setRemediationFunction(DebtRemediationFunction.Type.LINEAR.toString())
+      .setRemediationGapMultiplier("1h")
+      .setRemediationBaseEffort("5min")
+      .setTags(newHashSet("tag1", "tag2"))
+      .setUpdatedAt(2000000000000L);
+
+    underTest.update(dbTester.getSession(), ruleToUpdate);
+    dbTester.getSession().commit();
+
+    RuleDto ruleDto = underTest.selectOrFailByKey(dbTester.getSession(), RuleKey.of("checkstyle", "AvoidNull"));
+    assertThat(ruleDto.getName()).isEqualTo("Avoid Null");
+    assertThat(ruleDto.getDescription()).isEqualTo("Should avoid NULL");
+    assertThat(ruleDto.getDescriptionFormat()).isNull();
+    assertThat(ruleDto.getStatus()).isEqualTo(RuleStatus.READY);
+    assertThat(ruleDto.getRuleKey()).isEqualTo("AvoidNull");
+    assertThat(ruleDto.getRepositoryKey()).isEqualTo("checkstyle");
+    assertThat(ruleDto.getConfigKey()).isEqualTo("AvoidNull");
+    assertThat(ruleDto.getSeverity()).isEqualTo(2);
+    assertThat(ruleDto.getLanguage()).isEqualTo("golo");
+    assertThat(ruleDto.isTemplate()).isFalse();
+    assertThat(ruleDto.getTemplateId()).isNull();
     assertThat(ruleDto.getNoteData()).isEqualTo("My note");
     assertThat(ruleDto.getNoteUserLogin()).isEqualTo("admin");
     assertThat(ruleDto.getNoteCreatedAt()).isNotNull();
     assertThat(ruleDto.getNoteUpdatedAt()).isNotNull();
     assertThat(ruleDto.getRemediationFunction()).isEqualTo("LINEAR");
-    assertThat(ruleDto.getDefaultRemediationFunction()).isEqualTo("LINEAR_OFFSET");
+    assertThat(ruleDto.getDefaultRemediationFunction()).isNull();
     assertThat(ruleDto.getRemediationGapMultiplier()).isEqualTo("1h");
-    assertThat(ruleDto.getDefaultRemediationGapMultiplier()).isEqualTo("5d");
+    assertThat(ruleDto.getDefaultRemediationGapMultiplier()).isNull();
     assertThat(ruleDto.getRemediationBaseEffort()).isEqualTo("5min");
-    assertThat(ruleDto.getDefaultRemediationBaseEffort()).isEqualTo("10h");
-    assertThat(ruleDto.getGapDescription()).isEqualTo("squid.S115.effortToFix");
+    assertThat(ruleDto.getDefaultRemediationBaseEffort()).isNull();
+    assertThat(ruleDto.getGapDescription()).isNull();
     assertThat(ruleDto.getTags()).containsOnly("tag1", "tag2");
-    assertThat(ruleDto.getSystemTags()).containsOnly("systag1", "systag2");
-    assertThat(ruleDto.getType()).isEqualTo(RuleType.BUG.getDbConstant());
+    assertThat(ruleDto.getSystemTags()).isEmpty();
+    assertThat(ruleDto.getType()).isEqualTo(0);
     assertThat(ruleDto.getCreatedAt()).isEqualTo(1500000000000L);
     assertThat(ruleDto.getUpdatedAt()).isEqualTo(2000000000000L);
   }
     dbTester.prepareDbUnit(getClass(), "select_parameters_by_rule_key.xml");
 
     assertThat(underTest.selectRuleParamsByRuleKeys(dbTester.getSession(),
-      Arrays.asList(RuleKey.of("checkstyle", "AvoidNull"), RuleKey.of("unused", "Unused"))
-    )).hasSize(2);
+      Arrays.asList(RuleKey.of("checkstyle", "AvoidNull"), RuleKey.of("unused", "Unused")))).hasSize(2);
 
     assertThat(underTest.selectRuleParamsByRuleKeys(dbTester.getSession(),
-      singletonList(RuleKey.of("unknown", "Unknown"))
-    )).isEmpty();
+      singletonList(RuleKey.of("unknown", "Unknown")))).isEmpty();
   }
 
   @Test
   public void insert_parameter() {
     dbTester.prepareDbUnit(getClass(), "insert_parameter.xml");
-    RuleDto rule1 = underTest.selectOrFailByKey(dbTester.getSession(), RuleKey.of("plugin", "NewRuleKey"));
+    RuleDefinitionDto rule1 = underTest.selectOrFailByKey(dbTester.getSession(), RuleKey.of("plugin", "NewRuleKey"))
+      .getDefinition();
 
     RuleParamDto param = RuleParamDto.createFor(rule1)
       .setName("max")
   public void update_parameter() {
     dbTester.prepareDbUnit(getClass(), "update_parameter.xml");
 
-    RuleDto rule1 = underTest.selectOrFailByKey(dbTester.getSession(), RuleKey.of("checkstyle", "AvoidNull"));
+    RuleDefinitionDto rule1 = underTest.selectOrFailByKey(dbTester.getSession(), RuleKey.of("checkstyle", "AvoidNull"))
+      .getDefinition();
 
     List<RuleParamDto> params = underTest.selectRuleParamsByRuleKey(dbTester.getSession(), rule1.getKey());
     assertThat(params).hasSize(1);

server/sonar-db-dao/src/test/java/org/sonar/db/rule/RuleDbTester.java

 import org.apache.commons.lang.RandomStringUtils;
 import org.sonar.api.server.rule.RuleParamType;
 import org.sonar.db.DbTester;
+import org.sonar.db.organization.OrganizationDto;
 
 import static org.sonar.db.rule.RuleTesting.newRuleDto;
 
   }
 
   public RuleDto insertRule(RuleDto ruleDto) {
-    db.getDbClient().ruleDao().insert(db.getSession(), ruleDto);
+    RuleDao ruleDao = db.getDbClient().ruleDao();
+    ruleDao.insert(db.getSession(), ruleDto.getDefinition());
     db.commit();
+    RuleMetadataDto metadata = ruleDto.getMetadata();
+    if (metadata.getOrganizationUuid() != null) {
+      ruleDao.update(db.getSession(), metadata.setRuleId(ruleDto.getId()));
+      db.commit();
+    }
     return ruleDto;
   }
 
     });
   }
 
+  public RuleDto insertRule(OrganizationDto organization, Consumer<RuleDto> populateRuleDto) {
+    RuleDto ruleDto = newRuleDto(organization);
+    populateRuleDto.accept(ruleDto);
+    return insertRule(ruleDto);
+  }
+
   public RuleDto insertRule(Consumer<RuleDto> populateRuleDto) {
     RuleDto ruleDto = newRuleDto();
     populateRuleDto.accept(ruleDto);
-    db.getDbClient().ruleDao().insert(db.getSession(), ruleDto);
-    db.commit();
-    return ruleDto;
+    return insertRule(ruleDto);
   }
 
   public RuleParamDto insertRuleParam(RuleDto rule) {
     param.setRuleId(rule.getId());
     param.setName(RandomStringUtils.random(10));
     param.setType(RuleParamType.STRING.type());
-    db.getDbClient().ruleDao().insertRuleParam(db.getSession(), rule, param);
+    db.getDbClient().ruleDao().insertRuleParam(db.getSession(), rule.getDefinition(), param);
     db.commit();
     return param;
   }

server/sonar-db-dao/src/test/java/org/sonar/db/rule/RuleTesting.java

     return newDto(RuleKey.of(randomAlphanumeric(30), randomAlphanumeric(30)));
   }
 
+
+  public static RuleDto newRuleDto(OrganizationDto organization) {
+    return newDto(RuleKey.of(randomAlphanumeric(30), randomAlphanumeric(30)), organization);
+  }
+
   /**
    * Creates a new rule to be used as a template for a custom rule.
    */

server/sonar-server/src/main/java/org/sonar/server/rule/RegisterRules.java

 
 import com.google.common.base.Function;
 import com.google.common.base.Optional;
-import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Maps;
 import java.util.ArrayList;
 import org.sonar.db.DbSession;
 import org.sonar.db.qualityprofile.ActiveRuleDto;
 import org.sonar.db.qualityprofile.ActiveRuleParamDto;
+import org.sonar.db.rule.RuleDefinitionDto;
 import org.sonar.db.rule.RuleDto;
 import org.sonar.db.rule.RuleDto.Format;
+import org.sonar.db.rule.RuleMetadataDto;
 import org.sonar.db.rule.RuleParamDto;
 import org.sonar.db.rule.RuleRepositoryDto;
 import org.sonar.server.qualityprofile.ActiveRuleChange;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 import static com.google.common.collect.Lists.newArrayList;
-import static com.google.common.collect.Sets.intersection;
 
 /**
  * Register rules at server startup
   private void registerRule(RulesDefinition.Rule ruleDef, Map<RuleKey, RuleDto> allRules, DbSession session) {
     RuleKey ruleKey = RuleKey.of(ruleDef.repository().key(), ruleDef.key());
 
-    RuleDto rule = allRules.containsKey(ruleKey) ? allRules.remove(ruleKey) : createRuleDto(ruleDef, session);
+    RuleDto existingRule = allRules.remove(ruleKey);
+    RuleDefinitionDto rule = existingRule == null ? createRuleDto(ruleDef, session) : existingRule.getDefinition();
 
     boolean executeUpdate = false;
     if (mergeRule(ruleDef, rule)) {
     return repositories;
   }
 
-  private RuleDto createRuleDto(RulesDefinition.Rule ruleDef, DbSession session) {
-    RuleDto ruleDto = RuleDto.createFor(RuleKey.of(ruleDef.repository().key(), ruleDef.key()))
+  private RuleDefinitionDto createRuleDto(RulesDefinition.Rule ruleDef, DbSession session) {
+    RuleDefinitionDto ruleDto = new RuleDefinitionDto()
+      .setRuleKey(RuleKey.of(ruleDef.repository().key(), ruleDef.key()))
       .setIsTemplate(ruleDef.template())
       .setConfigKey(ruleDef.internalKey())
       .setLanguage(ruleDef.repository().language())
     return ruleDto;
   }
 
-  private boolean mergeRule(RulesDefinition.Rule def, RuleDto dto) {
+  private boolean mergeRule(RulesDefinition.Rule def, RuleDefinitionDto dto) {
     boolean changed = false;
     if (!StringUtils.equals(dto.getName(), def.name())) {
       dto.setName(def.name());
     return changed;
   }
 
-  private boolean mergeDescription(RulesDefinition.Rule def, RuleDto dto) {
+  private boolean mergeDescription(RulesDefinition.Rule def, RuleDefinitionDto dto) {
     boolean changed = false;
     if (def.htmlDescription() != null && !StringUtils.equals(dto.getDescription(), def.htmlDescription())) {
       dto.setDescription(def.htmlDescription());
     return changed;
   }
 
-  private boolean mergeDebtDefinitions(RulesDefinition.Rule def, RuleDto dto) {
+  private boolean mergeDebtDefinitions(RulesDefinition.Rule def, RuleDefinitionDto dto) {
     // Debt definitions are set to null if the sub-characteristic and the remediation function are null
     DebtRemediationFunction debtRemediationFunction = def.debtRemediationFunction();
     boolean hasDebt = debtRemediationFunction != null;
     return mergeDebtDefinitions(dto, null, null, null, null);
   }
 
-  private boolean mergeDebtDefinitions(RuleDto dto, @Nullable String remediationFunction,
+  private boolean mergeDebtDefinitions(RuleDefinitionDto dto, @Nullable String remediationFunction,
     @Nullable String remediationCoefficient, @Nullable String remediationOffset, @Nullable String effortToFixDescription) {
     boolean changed = false;
 
     return changed;
   }
 
-  private void mergeParams(RulesDefinition.Rule ruleDef, RuleDto rule, DbSession session) {
+  private void mergeParams(RulesDefinition.Rule ruleDef, RuleDefinitionDto rule, DbSession session) {
     List<RuleParamDto> paramDtos = dbClient.ruleDao().selectRuleParamsByRuleKey(session, rule.getKey());
     Map<String, RuleParamDto> existingParamsByName = Maps.newHashMap();
 
     return changed;
   }
 
-  private static boolean mergeTags(RulesDefinition.Rule ruleDef, RuleDto dto) {
+  private static boolean mergeTags(RulesDefinition.Rule ruleDef, RuleDefinitionDto dto) {
     boolean changed = false;
 
     if (RuleStatus.REMOVED == ruleDef.status()) {
-      dto.setSystemTags(Collections.<String>emptySet());
+      dto.setSystemTags(Collections.emptySet());
       changed = true;
     } else if (dto.getSystemTags().size() != ruleDef.tags().size() ||
-      !dto.getSystemTags().containsAll(ruleDef.tags())
-      || !intersection(dto.getTags(), ruleDef.tags()).isEmpty()) {
+      !dto.getSystemTags().containsAll(ruleDef.tags())) {
       dto.setSystemTags(ruleDef.tags());
-      // remove end-user tags that are now declared as system
-      RuleTagHelper.applyTags(dto, ImmutableSet.copyOf(dto.getTags()));
+      // FIXME this can't be implemented easily with organization support: remove end-user tags that are now declared as system
+      // RuleTagHelper.applyTags(dto, ImmutableSet.copyOf(dto.getTags()));
       changed = true;
     }
     return changed;
       checkNotNull(templateId, "Template id of the custom rule '%s' is null", customRule);
       Optional<RuleDto> template = dbClient.ruleDao().selectById(templateId, session);
       if (template.isPresent() && template.get().getStatus() != RuleStatus.REMOVED) {
-        if (updateCustomRuleFromTemplateRule(customRule, template.get())) {
-          update(session, customRule);
+        if (updateCustomRuleFromTemplateRule(customRule, template.get().getDefinition())) {
+          update(session, customRule.getDefinition());
         }
       } else {
         removeRule(session, removedRules, customRule);
   private void removeRule(DbSession session, List<RuleDto> removedRules, RuleDto rule) {
     LOG.info(String.format("Disable rule %s", rule.getKey()));
     rule.setStatus(RuleStatus.REMOVED);
-    rule.setSystemTags(Collections.<String>emptySet());
-    rule.setTags(Collections.<String>emptySet());
-    update(session, rule);
+    rule.setSystemTags(Collections.emptySet());
+    rule.setTags(Collections.emptySet());
+    update(session, rule.getDefinition());
+    update(session, rule.getMetadata());
     removedRules.add(rule);
     if (removedRules.size() % 100 == 0) {
       session.commit();
     }
   }
 
-  private static boolean updateCustomRuleFromTemplateRule(RuleDto customRule, RuleDto templateRule) {
+  private static boolean updateCustomRuleFromTemplateRule(RuleDto customRule, RuleDefinitionDto templateRule) {
     boolean changed = false;
     if (!StringUtils.equals(customRule.getLanguage(), templateRule.getLanguage())) {
       customRule.setLanguage(templateRule.getLanguage());
     return changes;
   }
 
-  private void update(DbSession session, RuleDto rule) {
+  private void update(DbSession session, RuleDefinitionDto rule) {
+    rule.setUpdatedAt(system2.now());
+    dbClient.ruleDao().update(session, rule);
+  }
+
+  private void update(DbSession session, RuleMetadataDto rule) {
     rule.setUpdatedAt(system2.now());
     dbClient.ruleDao().update(session, rule);
   }

server/sonar-server/src/main/java/org/sonar/server/rule/RuleCreator.java

 import com.google.common.base.Strings;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Set;
 import javax.annotation.CheckForNull;
 import javax.annotation.Nullable;
 import org.sonar.api.rule.RuleKey;
 import org.sonar.api.utils.System2;
 import org.sonar.db.DbClient;
 import org.sonar.db.DbSession;
+import org.sonar.db.rule.RuleDefinitionDto;
 import org.sonar.db.rule.RuleDto;
 import org.sonar.db.rule.RuleDto.Format;
+import org.sonar.db.rule.RuleMetadataDto;
 import org.sonar.db.rule.RuleParamDto;
 import org.sonar.server.exceptions.BadRequestException;
 import org.sonar.server.rule.index.RuleIndexer;
 
     Optional<RuleDto> existingRule = loadRule(customRuleKey, dbSession);
     if (existingRule.isPresent()) {
-      updateExistingRule(existingRule.get(), newRule, dbSession);
+      updateExistingRule(existingRule.get().getDefinition(), newRule, dbSession);
     } else {
       createCustomRule(customRuleKey, newRule, templateRule, dbSession);
     }
   }
 
   private RuleKey createCustomRule(RuleKey ruleKey, NewCustomRule newRule, RuleDto templateRuleDto, DbSession dbSession) {
-    RuleDto ruleDto = RuleDto.createFor(ruleKey)
+    RuleDefinitionDto ruleDefinition = new RuleDefinitionDto()
+      .setRuleKey(ruleKey)
       .setTemplateId(templateRuleDto.getId())
       .setConfigKey(templateRuleDto.getConfigKey())
       .setName(newRule.name())
       .setDefaultRemediationGapMultiplier(templateRuleDto.getDefaultRemediationGapMultiplier())
       .setDefaultRemediationBaseEffort(templateRuleDto.getDefaultRemediationBaseEffort())
       .setGapDescription(templateRuleDto.getGapDescription())
-      .setTags(templateRuleDto.getTags())
       .setSystemTags(templateRuleDto.getSystemTags())
       .setType(templateRuleDto.getType())
       .setCreatedAt(system2.now())
       .setUpdatedAt(system2.now());
-    dbClient.ruleDao().insert(dbSession, ruleDto);
+    dbClient.ruleDao().insert(dbSession, ruleDefinition);
+    Set<String> tags = templateRuleDto.getTags();
+    if (!tags.isEmpty()) {
+      RuleMetadataDto ruleMetadata = new RuleMetadataDto()
+        .setRuleId(ruleDefinition.getId())
+        .setTags(tags)
+        .setUpdatedAt(system2.now());
+      dbClient.ruleDao().update(dbSession, ruleMetadata);
+    }
 
     for (RuleParamDto templateRuleParamDto : dbClient.ruleDao().selectRuleParamsByRuleKey(dbSession, templateRuleDto.getKey())) {
       String customRuleParamValue = Strings.emptyToNull(newRule.parameter(templateRuleParamDto.getName()));
-      createCustomRuleParams(customRuleParamValue, ruleDto, templateRuleParamDto, dbSession);
+      createCustomRuleParams(customRuleParamValue, ruleDefinition, templateRuleParamDto, dbSession);
     }
     return ruleKey;
   }
 
-  private void createCustomRuleParams(@Nullable String paramValue, RuleDto ruleDto, RuleParamDto templateRuleParam, DbSession dbSession) {
+  private void createCustomRuleParams(@Nullable String paramValue, RuleDefinitionDto ruleDto, RuleParamDto templateRuleParam, DbSession dbSession) {
     RuleParamDto ruleParamDto = RuleParamDto.createFor(ruleDto)
       .setName(templateRuleParam.getName())
       .setType(templateRuleParam.getType())
     dbClient.ruleDao().insertRuleParam(dbSession, ruleDto, ruleParamDto);
   }
 
-  private void updateExistingRule(RuleDto ruleDto, NewCustomRule newRule, DbSession dbSession) {
+  private void updateExistingRule(RuleDefinitionDto ruleDto, NewCustomRule newRule, DbSession dbSession) {
     if (ruleDto.getStatus().equals(RuleStatus.REMOVED)) {
       if (newRule.isPreventReactivation()) {
         throw new ReactivationException(format("A removed rule with the key '%s' already exists", ruleDto.getKey().rule()), ruleDto.getKey());

server/sonar-server/src/main/java/org/sonar/server/rule/RuleDeleter.java

 
       rule.setStatus(RuleStatus.REMOVED);
       rule.setUpdatedAt(system2.now());
-      dbClient.ruleDao().update(dbSession, rule);
+      dbClient.ruleDao().update(dbSession, rule.getDefinition());
+      dbClient.ruleDao().update(dbSession, rule.getMetadata());
 
       dbSession.commit();
       ruleIndexer.index();

server/sonar-server/src/main/java/org/sonar/server/rule/RuleUpdater.java

 
       // Update rule param
       ruleParamDto.setDefaultValue(value);
-      dbClient.ruleDao().updateRuleParam(dbSession, customRule, ruleParamDto);
+      dbClient.ruleDao().updateRuleParam(dbSession, customRule.getDefinition(), ruleParamDto);
 
       if (value != null) {
         // Update linked active rule params or create new one
 
   private void update(DbSession session, RuleDto rule) {
     rule.setUpdatedAt(system.now());
-    dbClient.ruleDao().update(session, rule);
+    dbClient.ruleDao().update(session, rule.getDefinition());
+    dbClient.ruleDao().update(session, rule.getMetadata());
   }
 
 }

server/sonar-server/src/test/java/org/sonar/server/component/ComponentCleanerServiceTest.java

     ComponentDto project = newProjectDto(db.organizations().insert(), "project-uuid-" + suffix)
       .setKey("project-key-" + suffix);
     RuleDto rule = RuleTesting.newDto(RuleKey.of("sonarqube", "rule-" + suffix));
-    dbClient.ruleDao().insert(dbSession, rule);
+    dbClient.ruleDao().insert(dbSession, rule.getDefinition());
     IssueDto issue = IssueTesting.newDto(rule, project, project).setKee("issue-key-" + suffix).setUpdatedAt(new Date().getTime());
     dbClient.componentDao().insert(dbSession, project);
     SnapshotDto snapshot = dbClient.snapshotDao().insert(dbSession, SnapshotTesting.newAnalysis(project));

server/sonar-server/src/test/java/org/sonar/server/computation/task/projectanalysis/issue/IntegrateIssuesVisitorTest.java

     dbTester.getDbClient().componentDao().insert(dbTester.getSession(), project, file);
 
     RuleDto ruleDto = RuleTesting.newDto(ruleKey);
-    dbTester.getDbClient().ruleDao().insert(dbTester.getSession(), ruleDto);
+    dbTester.rules().insertRule(ruleDto);
     ruleRepositoryRule.add(ruleKey);
 
     IssueDto issue = IssueTesting.newDto(ruleDto, file, project)

server/sonar-server/src/test/java/org/sonar/server/computation/task/projectanalysis/step/PersistIssuesStepTest.java

   @Test
   public void insert_new_issue() {
     RuleDto rule = RuleTesting.newDto(RuleKey.of("xoo", "S01"));
-    dbClient.ruleDao().insert(session, rule);
+    dbTester.rules().insertRule(rule);
     OrganizationDto organizationDto = dbTester.organizations().insert();
     ComponentDto project = ComponentTesting.newProjectDto(organizationDto);
     dbClient.componentDao().insert(session, project);

server/sonar-server/src/test/java/org/sonar/server/issue/IssueServiceMediumTest.java

   }
 
   private RuleDto newRule(RuleDto rule) {
-    tester.get(RuleDao.class).insert(session, rule);
+    RuleDao ruleDao = tester.get(RuleDao.class);
+    ruleDao.insert(session, rule.getDefinition());
+    if (rule.getOrganizationUuid() != null) {
+      ruleDao.update(session, rule.getMetadata().setRuleId(rule.getId()));
+    }
     session.commit();
     ruleIndexer.index();
     return rule;

server/sonar-server/src/test/java/org/sonar/server/issue/ws/SearchActionComponentsMediumTest.java

       .setName("Rule name")
       .setDescription("Rule desc")
       .setStatus(RuleStatus.READY);
-    tester.get(RuleDao.class).insert(session, rule);
+    tester.get(RuleDao.class).insert(session, rule.getDefinition());
     session.commit();
     return rule;
   }

server/sonar-server/src/test/java/org/sonar/server/issue/ws/SearchActionMediumTest.java

       .setName("Rule name")
       .setDescription("Rule desc")
       .setStatus(RuleStatus.READY);
-    tester.get(RuleDao.class).insert(session, rule);
+    tester.get(RuleDao.class).insert(session, rule.getDefinition());
     session.commit();
     return rule;
   }

server/sonar-server/src/test/java/org/sonar/server/issue/ws/TagsActionTest.java

 
   @Rule
   public UserSessionRule userSession = UserSessionRule.standalone();
-
   @Rule
   public DbTester db = DbTester.create();
-
   @Rule
   public EsTester es = new EsTester(new IssueIndexDefinition(new MapSettings()), new RuleIndexDefinition(new MapSettings()));
 
 
   @Test
   public void return_tags_from_rules() throws Exception {
-    db.rules().insertRule(rule -> rule.setSystemTags(ImmutableSet.of("tag1")).setTags(ImmutableSet.of("tag2")));
-    db.rules().insertRule(rule -> rule.setSystemTags(ImmutableSet.of("tag3")).setTags(ImmutableSet.of("tag4", "tag5")));
+    db.rules().insertRule(db.getDefaultOrganization(), rule -> rule.setSystemTags(ImmutableSet.of("tag1")).setTags(ImmutableSet.of("tag2")));
+    db.rules().insertRule(db.getDefaultOrganization(), rule -> rule.setSystemTags(ImmutableSet.of("tag3")).setTags(ImmutableSet.of("tag4", "tag5")));
     ruleIndexer.index();
 
     String result = tester.newRequest().execute().getInput();
     insertIssueWithBrowsePermission(insertRuleWithoutTags(), "tag1", "tag2");
     insertIssueWithBrowsePermission(insertRuleWithoutTags(), "tag3", "tag4", "tag5");
     issueIndexer.indexOnStartup(null);
-    db.rules().insertRule(rule -> rule.setSystemTags(ImmutableSet.of("tag6")).setTags(ImmutableSet.of("tag7")));
+    db.rules().insertRule(db.getDefaultOrganization(), rule -> rule.setSystemTags(ImmutableSet.of("tag6")).setTags(ImmutableSet.of("tag7")));
     ruleIndexer.index();
 
     String result = tester.newRequest().execute().getInput();
   public void test_example() throws Exception {
     insertIssueWithBrowsePermission(insertRuleWithoutTags(), "convention");
     issueIndexer.indexOnStartup(null);
-    db.rules().insertRule(rule -> rule.setSystemTags(ImmutableSet.of("cwe")).setTags(ImmutableSet.of("security")));
+    db.rules().insertRule(db.getDefaultOrganization(), rule -> rule.setSystemTags(ImmutableSet.of("cwe")).setTags(ImmutableSet.of("security")));
     ruleIndexer.index();
 
     String result = tester.newRequest().execute().getInput();
   }
 
   private RuleDto insertRuleWithoutTags() {
-    RuleDto ruleDto = newRuleDto().setTags(emptySet()).setSystemTags(emptySet());
+    RuleDto ruleDto = newRuleDto(db.getDefaultOrganization()).setTags(emptySet()).setSystemTags(emptySet());
     db.rules().insertRule(ruleDto);
     return ruleDto;
   }

server/sonar-server/src/test/java/org/sonar/server/qualityprofile/QProfileBackuperMediumTest.java

 import org.sonar.db.rule.RuleDto;
 import org.sonar.db.rule.RuleParamDto;
 import org.sonar.server.qualityprofile.index.ActiveRuleIndexer;
-import org.sonar.server.qualityprofile.ws.QProfileWsSupport;
 import org.sonar.server.rule.index.RuleIndex;
 import org.sonar.server.rule.index.RuleIndexer;
 import org.sonar.server.rule.index.RuleQuery;
     // create pre-defined rules
     RuleDto xooRule1 = newXooX1().setSeverity("MINOR").setLanguage("xoo");
     RuleDto xooRule2 = newXooX2().setSeverity("MAJOR").setLanguage("xoo");
-    db.ruleDao().insert(dbSession, xooRule1);
-    db.ruleDao().insert(dbSession, xooRule2);
-    db.ruleDao().insertRuleParam(dbSession, xooRule1, RuleParamDto.createFor(xooRule1)
+    db.ruleDao().insert(dbSession, xooRule1.getDefinition());
+    db.ruleDao().insert(dbSession, xooRule2.getDefinition());
+    db.ruleDao().insertRuleParam(dbSession, xooRule1.getDefinition(), RuleParamDto.createFor(xooRule1.getDefinition())
       .setName("max").setDefaultValue("10").setType(RuleParamType.INTEGER.type()));
     dbSession.commit();
     dbSession.clearCache();
   public void backup() throws Exception {
     RuleKey blahRuleKey = RuleKey.of("blah", "my-rule");
     RuleDto blahRule = newDto(blahRuleKey).setSeverity("INFO").setLanguage("xoo");
-    db.ruleDao().insert(dbSession, blahRule);
+    db.ruleDao().insert(dbSession, blahRule.getDefinition());
     dbSession.commit();
     dbSession.clearCache();
     ruleIndexer.index();

server/sonar-server/src/test/java/org/sonar/server/qualityprofile/QProfileComparisonMediumTest.java

 
     xooRule1 = RuleTesting.newXooX1().setSeverity("MINOR");
     xooRule2 = RuleTesting.newXooX2().setSeverity("MAJOR");
-    db.ruleDao().insert(dbSession, xooRule1);
-    db.ruleDao().insert(dbSession, xooRule2);
-    db.ruleDao().insertRuleParam(dbSession, xooRule1, RuleParamDto.createFor(xooRule1)
+    db.ruleDao().insert(dbSession, xooRule1.getDefinition());
+    db.ruleDao().insert(dbSession, xooRule2.getDefinition());
+    db.ruleDao().insertRuleParam(dbSession, xooRule1.getDefinition(), RuleParamDto.createFor(xooRule1.getDefinition())
       .setName("max").setType(RuleParamType.INTEGER.type()));
-    db.ruleDao().insertRuleParam(dbSession, xooRule1, RuleParamDto.createFor(xooRule1)
+    db.ruleDao().insertRuleParam(dbSession, xooRule1.getDefinition(), RuleParamDto.createFor(xooRule1.getDefinition())
       .setName("min").setType(RuleParamType.INTEGER.type()));
 
     left = QProfileTesting.newXooP1("org-123");

server/sonar-server/src/test/java/org/sonar/server/qualityprofile/QProfileCopierMediumTest.java

     // create pre-defined rules
     RuleDto xooRule1 = RuleTesting.newXooX1().setSeverity("MINOR");
     RuleDto xooRule2 = RuleTesting.newXooX2().setSeverity("MAJOR");
-    db.ruleDao().insert(dbSession, xooRule1);
-    db.ruleDao().insert(dbSession, xooRule2);
-    db.ruleDao().insertRuleParam(dbSession, xooRule1, RuleParamDto.createFor(xooRule1)
+    db.ruleDao().insert(dbSession, xooRule1.getDefinition());
+    db.ruleDao().insert(dbSession, xooRule2.getDefinition());
+    db.ruleDao().insertRuleParam(dbSession, xooRule1.getDefinition(), RuleParamDto.createFor(xooRule1.getDefinition())
       .setName("max").setDefaultValue("10").setType(RuleParamType.INTEGER.type()));
 
     // create pre-defined profile

server/sonar-server/src/test/java/org/sonar/server/qualityprofile/RuleActivatorMediumTest.java

     RuleDto xooRule2 = newXooX2().setSeverity("INFO");
     RuleDto xooTemplateRule1 = newTemplateRule(TEMPLATE_RULE_KEY)
       .setSeverity("MINOR").setLanguage("xoo");
-    db.ruleDao().insert(dbSession, javaRule);
-    db.ruleDao().insert(dbSession, xooRule1);
-    db.ruleDao().insert(dbSession, xooRule2);
-    db.ruleDao().insert(dbSession, xooTemplateRule1);
-    db.ruleDao().insertRuleParam(dbSession, xooRule1, RuleParamDto.createFor(xooRule1)
+    db.ruleDao().insert(dbSession, javaRule.getDefinition());
+    db.ruleDao().insert(dbSession, xooRule1.getDefinition());
+    db.ruleDao().insert(dbSession, xooRule2.getDefinition());
+    db.ruleDao().insert(dbSession, xooTemplateRule1.getDefinition());
+    db.ruleDao().insertRuleParam(dbSession, xooRule1.getDefinition(), RuleParamDto.createFor(xooRule1.getDefinition())
       .setName("max").setDefaultValue("10").setType(RuleParamType.INTEGER.type()));
-    db.ruleDao().insertRuleParam(dbSession, xooRule1, RuleParamDto.createFor(xooRule1)
+    db.ruleDao().insertRuleParam(dbSession, xooRule1.getDefinition(), RuleParamDto.createFor(xooRule1.getDefinition())
       .setName("min").setType(RuleParamType.INTEGER.type()));
-    db.ruleDao().insertRuleParam(dbSession, xooTemplateRule1, RuleParamDto.createFor(xooTemplateRule1)
+    db.ruleDao().insertRuleParam(dbSession, xooTemplateRule1.getDefinition(), RuleParamDto.createFor(xooTemplateRule1.getDefinition())
       .setName("format").setType(RuleParamType.STRING.type()));
 
     RuleDto xooCustomRule1 = newCustomRule(xooTemplateRule1).setRuleKey(CUSTOM_RULE_KEY.rule())
       .setSeverity("MINOR").setLanguage("xoo");
-    db.ruleDao().insert(dbSession, xooCustomRule1);
-    db.ruleDao().insertRuleParam(dbSession, xooCustomRule1, RuleParamDto.createFor(xooTemplateRule1)
+    db.ruleDao().insert(dbSession, xooCustomRule1.getDefinition());
+    db.ruleDao().insertRuleParam(dbSession, xooCustomRule1.getDefinition(), RuleParamDto.createFor(xooTemplateRule1.getDefinition())
       .setName("format").setDefaultValue("txt").setType(RuleParamType.STRING.type()));
 
     // create pre-defined profile P1
   public void fail_to_activate_if_rule_with_removed_status() {
     RuleDto ruleDto = db.ruleDao().selectOrFailByKey(dbSession, XOO_X1);
     ruleDto.setStatus(RuleStatus.REMOVED);
-    db.ruleDao().update(dbSession, ruleDto);
+    db.ruleDao().update(dbSession, ruleDto.getDefinition());
     dbSession.commit();
     dbSession.clearCache();
 
     // set rule as removed
     RuleDto rule = db.ruleDao().selectOrFailByKey(dbSession, XOO_X1);
     rule.setStatus(RuleStatus.REMOVED);
-    db.ruleDao().update(dbSession, rule);
+    db.ruleDao().update(dbSession, rule.getDefinition());
     dbSession.commit();
     dbSession.clearCache();
 
     // Generate more rules than the search's max limit
     int bulkSize = SearchOptions.MAX_LIMIT + 10;
     for (int i = 0; i < bulkSize; i++) {
-      db.ruleDao().insert(dbSession, newDto(RuleKey.of("bulk", "r_" + i)).setLanguage("xoo"));
+      db.ruleDao().insert(dbSession, newDto(RuleKey.of("bulk", "r_" + i)).setLanguage("xoo").getDefinition());
     }
     dbSession.commit();
     ruleIndexer.index();
     // mark rule x1 as REMOVED
     RuleDto rule = db.ruleDao().selectOrFailByKey(dbSession, XOO_X1);
     rule.setStatus(RuleStatus.REMOVED);
-    db.ruleDao().update(dbSession, rule);
+    db.ruleDao().update(dbSession, rule.getDefinition());
     dbSession.commit();
     dbSession.clearCache();
 

server/sonar-server/src/test/java/org/sonar/server/qualityprofile/index/ActiveRuleIndexerTest.java

 
     // Index one active rule
     RuleDto rule = RuleTesting.newDto(RULE_KEY_1);
-    dbTester.getDbClient().ruleDao().insert(dbTester.getSession(), rule);
+    dbTester.rules().insertRule(rule);
     QualityProfileDto profile = QualityProfileDto.createFor("qp")
       .setOrganizationUuid(organization.getUuid())
       .setLanguage("xoo")
 
     // Index another active rule
     RuleDto rule2 = RuleTesting.newDto(RULE_KEY_2);
-    dbTester.getDbClient().ruleDao().insert(dbTester.getSession(), rule2);
+    dbTester.rules().insertRule(rule2);
     ActiveRuleDto activeRule2 = ActiveRuleDto.createFor(profile, rule2).setSeverity(Severity.CRITICAL)
       .setCreatedAt(now).setUpdatedAt(now);
     dbTester.getDbClient().activeRuleDao().insert(dbTester.getSession(), activeRule2);

server/sonar-server/src/test/java/org/sonar/server/qualityprofile/ws/ChangeParentActionTest.java

       .setLanguage(language.getKey())
       .setSeverity(Severity.BLOCKER)
       .setStatus(RuleStatus.READY);
-    dbClient.ruleDao().insert(dbSession, rule);
+    dbClient.ruleDao().insert(dbSession, rule.getDefinition());
     dbSession.commit();
     return rule;
   }

server/sonar-server/src/test/java/org/sonar/server/qualityprofile/ws/ChangelogLoaderTest.java

 
   private void insertRule(RuleKey key, String name) {
     RuleDto dto = RuleTesting.newDto(key).setName(name);
-    dbTester.getDbClient().ruleDao().insert(dbTester.getSession(), dto);
+    dbTester.rules().insertRule(dto);
     dbTester.getSession().commit();
   }
 

server/sonar-server/src/test/java/org/sonar/server/qualityprofile/ws/CompareActionMediumTest.java

 import org.sonar.db.qualityprofile.ActiveRuleDto;
 import org.sonar.db.qualityprofile.ActiveRuleParamDto;
 import org.sonar.db.qualityprofile.QualityProfileDto;
+import org.sonar.db.rule.RuleDefinitionDto;
 import org.sonar.db.rule.RuleDto;
 import org.sonar.db.rule.RuleParamDto;
 import org.sonar.db.rule.RuleRepositoryDto;
       .setLanguage(lang)
       .setSeverity(Severity.BLOCKER)
       .setStatus(RuleStatus.READY);
-    db.ruleDao().insert(session, rule);
-    RuleParamDto param = RuleParamDto.createFor(rule).setName("param_" + id).setType(RuleParamType.STRING.toString());
-    db.ruleDao().insertRuleParam(session, rule, param);
+    RuleDefinitionDto ruleDefinition = rule.getDefinition();
+    db.ruleDao().insert(session, ruleDefinition);
+    RuleParamDto param = RuleParamDto.createFor(ruleDefinition).setName("param_" + id).setType(RuleParamType.STRING.toString());
+    db.ruleDao().insertRuleParam(session, ruleDefinition, param);
     return rule;
   }
 
   private RuleDto createRuleWithParam(String lang, String id) {
     RuleDto rule = createRule(lang, id);
-    RuleParamDto param = RuleParamDto.createFor(rule).setName("param_" + id).setType(RuleParamType.STRING.toString());
-    db.ruleDao().insertRuleParam(session, rule, param);
+    RuleParamDto param = RuleParamDto.createFor(rule.getDefinition())
+      .setName("param_" + id)
+      .setType(RuleParamType.STRING.toString());
+    db.ruleDao().insertRuleParam(session, rule.getDefinition(), param);
     return rule;
   }
 

server/sonar-server/src/test/java/org/sonar/server/qualityprofile/ws/CreateActionTest.java

 import org.sonar.db.DbTester;
 import org.sonar.db.organization.OrganizationDto;
 import org.sonar.db.qualityprofile.QualityProfileDto;
-import org.sonar.db.rule.RuleDto;
+import org.sonar.db.rule.RuleDefinitionDto;
 import org.sonar.db.rule.RuleTesting;
 import org.sonar.server.es.EsTester;
 import org.sonar.server.exceptions.BadRequestException;
 public class CreateActionTest {
 
   private static final String XOO_LANGUAGE = "xoo";
-  private static final RuleDto RULE = RuleTesting.newXooX1().setSeverity("MINOR").setLanguage(XOO_LANGUAGE);
+  private static final RuleDefinitionDto RULE = RuleTesting.newXooX1()
+    .setSeverity("MINOR")
+    .setLanguage(XOO_LANGUAGE)
+    .getDefinition();
   private System2 system2 = System2.INSTANCE;
 
   @Rule
     assertThat(response.getMediaType()).isEqualTo(MediaTypes.JSON);
   }
 
-  private void insertRule(RuleDto ruleDto) {
+  private void insertRule(RuleDefinitionDto ruleDto) {
     dbClient.ruleDao().insert(dbSession, ruleDto);
     dbSession.commit();
     ruleIndexer.index();

server/sonar-server/src/test/java/org/sonar/server/qualityprofile/ws/InheritanceActionTest.java

     RuleDto rule = RuleTesting.newRuleDto()
       .setSeverity("MINOR")
       .setLanguage(profile1.getLanguage());
-    dbClient.ruleDao().insert(dbSession, rule);
+    dbClient.ruleDao().insert(dbSession, rule.getDefinition());
     dbSession.commit();
 
     userSession.logIn()
       .setStatus(RuleStatus.READY)
       .setUpdatedAt(now)
       .setCreatedAt(now);
-    dbClient.ruleDao().insert(dbSession, rule);
+    dbClient.ruleDao().insert(dbSession, rule.getDefinition());
     return rule;
   }
 

server/sonar-server/src/test/java/org/sonar/server/qualityprofile/ws/QProfilesWsMediumTest.java

       .setLanguage(lang)
       .setSeverity(Severity.BLOCKER)
       .setStatus(RuleStatus.READY);
-    db.ruleDao().insert(session, rule);
+    db.ruleDao().insert(session, rule.getDefinition());
     return rule;
   }
 

server/sonar-server/src/test/java/org/sonar/server/rule/DefaultRuleFinderTest.java

 
   @Before
   public void setup() {
-    dbClient.ruleDao().insert(session, rule1);
-    dbClient.ruleDao().insert(session, rule2);
-    dbClient.ruleDao().insert(session, rule3);
-    dbClient.ruleDao().insert(session, rule4);
+    dbTester.rules().insertRule(rule1);
+    dbTester.rules().insertRule(rule2);
+    dbTester.rules().insertRule(rule3);
+    dbTester.rules().insertRule(rule4);
     session.commit();
   }
 

server/sonar-server/src/test/java/org/sonar/server/rule/RegisterRulesMediumTest.java

     assertThat(rule.getSystemTags()).containsOnly("tag1");
     assertThat(rule.getTags()).containsOnly("tag2");
 
-    // Definition updated -> user tag "tag2" becomes a system tag
-    register(new Rules() {
-      @Override
-      public void init(RulesDefinition.NewRepository repository) {
-        repository.createRule("x1").setName("x1 name").setHtmlDescription("x1 desc").setTags("tag1", "tag2");
-      }
-    });
-    rule = ruleDao.selectOrFailByKey(dbSession, RuleTesting.XOO_X1);
-    assertThat(rule.getSystemTags()).containsOnly("tag1", "tag2");
-    assertThat(rule.getTags()).isEmpty();
+    // FIXME: not supported anymore because information specific to an organization: Definition updated -> user tag "tag2" becomes a system tag
+//    register(new Rules() {
+//      @Override
+//      public void init(RulesDefinition.NewRepository repository) {
+//        repository.createRule("x1").setName("x1 name").setHtmlDescription("x1 desc").setTags("tag1", "tag2");
+//      }
+//    });
+//    rule = ruleDao.selectOrFailByKey(dbSession, RuleTesting.XOO_X1);
+//    assertThat(rule.getSystemTags()).containsOnly("tag1", "tag2");
+//    assertThat(rule.getTags()).isEmpty();
   }
 
   @Test

server/sonar-server/src/test/java/org/sonar/server/rule/RegisterRulesTest.java

 import org.sonar.db.DbClient;
 import org.sonar.db.DbSession;
 import org.sonar.db.DbTester;
+import org.sonar.db.rule.RuleDefinitionDto;
 import org.sonar.db.rule.RuleDto;
 import org.sonar.db.rule.RuleParamDto;
 import org.sonar.db.rule.RuleRepositoryDto;
     rule1.setTags(newHashSet("usertag1", "usertag2"));
     rule1.setNoteData("user *note*");
     rule1.setNoteUserLogin("marius");
-    dbClient.ruleDao().update(dbTester.getSession(), rule1);
+    dbClient.ruleDao().update(dbTester.getSession(), rule1.getMetadata());
     dbTester.getSession().commit();
 
     when(system.now()).thenReturn(DATE2.getTime());
     execute(new FakeRepositoryV2());
 
     // On MySQL, need to update a rule otherwise rule2 will be seen as READY, but why ???
-    dbClient.ruleDao().update(dbTester.getSession(), dbClient.ruleDao().selectOrFailByKey(dbTester.getSession(), RULE_KEY1));
+    dbClient.ruleDao().update(dbTester.getSession(), dbClient.ruleDao().selectOrFailByKey(dbTester.getSession(), RULE_KEY1).getDefinition());
     dbTester.getSession().commit();
 
     // rule2 is removed
   @Test
   public void remove_system_tags_when_plugin_does_not_provide_any() {
     // Rule already exists in DB, with some system tags
-    dbClient.ruleDao().insert(dbTester.getSession(), new RuleDto()
+    dbClient.ruleDao().insert(dbTester.getSession(), new RuleDefinitionDto()
       .setRuleKey("rule1")
       .setRepositoryKey("findbugs")
       .setName("Rule One")
       .setDescription("Rule one description")
       .setDescriptionFormat(RuleDto.Format.HTML)
-      .setSystemTags(newHashSet("tag1", "tag2"))
-      );
+      .setSystemTags(newHashSet("tag1", "tag2")));
     dbTester.getSession().commit();
 
     // Synchronize rule without tag

server/sonar-server/src/test/java/org/sonar/server/rule/RuleCreatorMediumTest.java

       .setDescription("Old description")
       .setDescriptionFormat(Format.MARKDOWN)
       .setSeverity(Severity.INFO);
-    dao.insert(dbSession, rule);
-    dao.insertRuleParam(dbSession, rule, dao.selectRuleParamsByRuleKey(dbSession, templateRule.getKey()).get(0).setDefaultValue("a.*"));
+    dao.insert(dbSession, rule.getDefinition());
+    dao.insertRuleParam(dbSession, rule.getDefinition(), dao.selectRuleParamsByRuleKey(dbSession, templateRule.getKey()).get(0).setDefaultValue("a.*"));
     dbSession.commit();
     dbSession.clearCache();
 
       .setName("Old name")
       .setDescription("Old description")
       .setSeverity(Severity.INFO);
-    dao.insert(dbSession, rule);
-    dao.insertRuleParam(dbSession, rule, dao.selectRuleParamsByRuleKey(dbSession, templateRule.getKey()).get(0).setDefaultValue("a.*"));
+    dao.insert(dbSession, rule.getDefinition());
+    dao.insertRuleParam(dbSession, rule.getDefinition(), dao.selectRuleParamsByRuleKey(dbSession, templateRule.getKey()).get(0).setDefaultValue("a.*"));
     dbSession.commit();
     dbSession.clearCache();
 
   public void fail_to_create_custom_rule_when_wrong_rule_template() {
     // insert rule
     RuleDto rule = RuleTesting.newDto(RuleKey.of("java", "S001")).setIsTemplate(false);
-    dao.insert(dbSession, rule);
+    dao.insert(dbSession, rule.getDefinition());
     dbSession.commit();
 
     // Create custom rule with unknown template rule
       .setSystemTags(Sets.newHashSet("tag1", "tag4"))
       .setCreatedAt(new Date().getTime())
       .setUpdatedAt(new Date().getTime());
-    dao.insert(dbSession, templateRule);
-    RuleParamDto ruleParamDto = RuleParamDto.createFor(templateRule).setName("regex").setType("STRING").setDescription("Reg ex").setDefaultValue(".*");
-    dao.insertRuleParam(dbSession, templateRule, ruleParamDto);
+    dao.insert(dbSession, templateRule.getDefinition());
+    dao.update(dbSession, templateRule.getMetadata().setRuleId(templateRule.getId()));
+    RuleParamDto ruleParamDto = RuleParamDto.createFor(templateRule.getDefinition()).setName("regex").setType("STRING").setDescription("Reg ex").setDefaultValue(".*");
+    dao.insertRuleParam(dbSession, templateRule.getDefinition(), ruleParamDto);
     dbSession.commit();
     ruleIndexer.index();
     return templateRule;
       .setGapDescription("desc")
       .setCreatedAt(new Date().getTime())
       .setUpdatedAt(new Date().getTime());
-    dao.insert(dbSession, templateRule);
-    RuleParamDto ruleParamDto = RuleParamDto.createFor(templateRule)
+    dao.insert(dbSession, templateRule.getDefinition());
+    RuleParamDto ruleParamDto = RuleParamDto.createFor(templateRule.getDefinition())
       .setName("myIntegers").setType("INTEGER,multiple=true,values=1;2;3").setDescription("My Integers").setDefaultValue("1");
-    dao.insertRuleParam(dbSession, templateRule, ruleParamDto);
+    dao.insertRuleParam(dbSession, templateRule.getDefinition(), ruleParamDto);
     dbSession.commit();
     ruleIndexer.index();
     return templateRule;
       .setGapDescription("desc")
       .setCreatedAt(new Date().getTime())
       .setUpdatedAt(new Date().getTime());
-    dao.insert(dbSession, templateRule);
-    RuleParamDto ruleParam1Dto = RuleParamDto.createFor(templateRule)
+    dao.insert(dbSession, templateRule.getDefinition());
+    RuleParamDto ruleParam1Dto = RuleParamDto.createFor(templateRule.getDefinition())
       .setName("first").setType("INTEGER").setDescription("First integer").setDefaultValue("0");
-    dao.insertRuleParam(dbSession, templateRule, ruleParam1Dto);
-    RuleParamDto ruleParam2Dto = RuleParamDto.createFor(templateRule)
+    dao.insertRuleParam(dbSession, templateRule.getDefinition(), ruleParam1Dto);
+    RuleParamDto ruleParam2Dto = RuleParamDto.createFor(templateRule.getDefinition())
       .setName("second").setType("INTEGER").setDescription("Second integer").setDefaultValue("0");
-    dao.insertRuleParam(dbSession, templateRule, ruleParam2Dto);
+    dao.insertRuleParam(dbSession, templateRule.getDefinition(), ruleParam2Dto);
     dbSession.commit();
     return templateRule;
   }

server/sonar-server/src/test/java/org/sonar/server/rule/RuleDeleterMediumTest.java

       .setLanguage("xoo")
       .setCreatedAt(PAST)
       .setUpdatedAt(PAST);
-    dao.insert(dbSession, templateRule);
+    dao.insert(dbSession, templateRule.getDefinition());
 
     // Create custom rule
     RuleDto customRule = RuleTesting.newCustomRule(templateRule)
       .setLanguage("xoo")
       .setCreatedAt(PAST)
       .setUpdatedAt(PAST);
-    dao.insert(dbSession, customRule);
+    dao.insert(dbSession, customRule.getDefinition());
 
     // Create a quality profile
     QualityProfileDto profileDto = QProfileTesting.newXooP1("org-123");
   public void fail_to_delete_if_not_custom() {
     // Create rule
     RuleKey ruleKey = RuleKey.of("java", "S001");
-    dao.insert(dbSession, RuleTesting.newDto(ruleKey));
+    dao.insert(dbSession, RuleTesting.newDto(ruleKey).getDefinition());
     dbSession.commit();
 
     try {

server/sonar-server/src/test/java/org/sonar/server/rule/RuleServiceMediumTest.java

 import org.sonar.db.DbClient;
 import org.sonar.db.DbSession;
 import org.sonar.db.rule.RuleDao;
+import org.sonar.db.rule.RuleDto;
 import org.sonar.db.rule.RuleTesting;
 import org.sonar.server.rule.index.RuleIndexer;
 import org.sonar.server.tester.ServerTester;
   }
 
   private void insertRule(RuleKey key, Set<String> tags, Set<String> systemTags) {
-    dao.insert(dbSession,
-      RuleTesting.newDto(key).setTags(tags).setSystemTags(systemTags));
+    RuleDto ruleDto = RuleTesting.newDto(key).setTags(tags).setSystemTags(systemTags);
+    dao.insert(dbSession, ruleDto.getDefinition());
+    dao.update(dbSession, ruleDto.getMetadata().setRuleId(ruleDto.getId()));
     dbSession.commit();
     ruleIndexer.index();
   }

server/sonar-server/src/test/java/org/sonar/server/rule/RuleUpdaterMediumTest.java

 import org.sonar.db.qualityprofile.ActiveRuleParamDto;
 import org.sonar.db.qualityprofile.QualityProfileDto;
 import org.sonar.db.rule.RuleDao;
+import org.sonar.db.rule.RuleDefinitionDto;
 import org.sonar.db.rule.RuleDto;
 import org.sonar.db.rule.RuleParamDto;
 import org.sonar.db.rule.RuleTesting;
 
   @Test
   public void do_not_update_rule_with_removed_status() {
-    ruleDao.insert(dbSession, RuleTesting.newDto(RULE_KEY).setStatus(RuleStatus.REMOVED));
+    ruleDao.insert(dbSession, RuleTesting.newDto(RULE_KEY).setStatus(RuleStatus.REMOVED).getDefinition());
     dbSession.commit();
 
     RuleUpdate update = RuleUpdate.createForPluginRule(RULE_KEY).setTags(Sets.newHashSet("java9"));
 
   @Test
   public void no_changes() {
-    ruleDao.insert(dbSession, RuleTesting.newDto(RULE_KEY)
+    RuleDto ruleDto = RuleTesting.newDto(RULE_KEY)
       // the following fields are not supposed to be updated
       .setNoteData("my *note*")
       .setNoteUserLogin("me")
       .setTags(ImmutableSet.of("tag1"))
       .setRemediationFunction(DebtRemediationFunction.Type.CONSTANT_ISSUE.name())
       .setRemediationGapMultiplier("1d")
-      .setRemediationBaseEffort("5min"));
+      .setRemediationBaseEffort("5min");
+    ruleDao.insert(dbSession, ruleDto.getDefinition());
+    ruleDao.update(dbSession, ruleDto.getMetadata().setRuleId(ruleDto.getId()));
     dbSession.commit();
 
     RuleUpdate update = RuleUpdate.createForPluginRule(RULE_KEY);
   public void set_markdown_note() {
     userSessionRule.logIn("me");
 
-    ruleDao.insert(dbSession, RuleTesting.newDto(RULE_KEY)
+    RuleDto ruleDto = RuleTesting.newDto(RULE_KEY)
       .setNoteData(null)
       .setNoteUserLogin(null)
 
       .setTags(ImmutableSet.of("tag1"))
       .setRemediationFunction(DebtRemediationFunction.Type.CONSTANT_ISSUE.name())
       .setRemediationGapMultiplier("1d")
-      .setRemediationBaseEffort("5min"));
+      .setRemediationBaseEffort("5min");
+    ruleDao.insert(dbSession, ruleDto.getDefinition());
+    ruleDao.update(dbSession, ruleDto.getMetadata().setRuleId(ruleDto.getId()));
     dbSession.commit();
 
     RuleUpdate update = RuleUpdate.createForPluginRule(RULE_KEY);
 
   @Test
   public void remove_markdown_note() {
-    ruleDao.insert(dbSession, RuleTesting.newDto(RULE_KEY)
+    RuleDto ruleDto = RuleTesting.newDto(RULE_KEY)
       .setNoteData("my *note*")
-      .setNoteUserLogin("me"));
+      .setNoteUserLogin("me");
+    ruleDao.insert(dbSession, ruleDto.getDefinition());
+    ruleDao.update(dbSession, ruleDto.getMetadata().setRuleId(ruleDto.getId()));
     dbSession.commit();
 
     RuleUpdate update = RuleUpdate.createForPluginRule(RULE_KEY).setMarkdownNote(null);
     // insert db
     ruleDao.insert(dbSession, RuleTesting.newDto(RULE_KEY)
       .setTags(Sets.newHashSet("security"))
-      .setSystemTags(Sets.newHashSet("java8", "javadoc")));
+      .setSystemTags(Sets.newHashSet("java8", "javadoc")).getDefinition());
     dbSession.commit();
 
     // java8 is a system tag -> ignore
 
   @Test
   public void remove_tags() {
-    ruleDao.insert(dbSession, RuleTesting.newDto(RULE_KEY)
+    RuleDto ruleDto = RuleTesting.newDto(RULE_KEY)
       .setTags(Sets.newHashSet("security"))
-      .setSystemTags(Sets.newHashSet("java8", "javadoc")));
+      .setSystemTags(Sets.newHashSet("java8", "javadoc"));
+    ruleDao.insert(dbSession, ruleDto.getDefinition());
+    ruleDao.update(dbSession, ruleDto.getMetadata());
     dbSession.commit();
 
     RuleUpdate update = RuleUpdate.createForPluginRule(RULE_KEY).setTags(null);
       .setDefaultRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.name())
       .setDefaultRemediationGapMultiplier("1d")
       .setDefaultRemediationBaseEffort("5min")
-      .setRemediationFunction(null)
-      .setRemediationGapMultiplier(null)
-      .setRemediationBaseEffort(null));
+      .getDefinition());
     dbSession.commit();
 
     DefaultDebtRemediationFunction fn = new DefaultDebtRemediationFunction(DebtRemediationFunction.Type.CONSTANT_ISSUE, null, "1min");
       .setDefaultRemediationFunction(DebtRemediationFunction.Type.LINEAR.name())
       .setDefaultRemediationGapMultiplier("1d")
       .setDefaultRemediationBaseEffort(null)
-      .setRemediationFunction(null)
-      .setRemediationGapMultiplier(null)
-      .setRemediationBaseEffort(null));
+      .getDefinition());
     dbSession.commit();
 
     RuleUpdate update = RuleUpdate.createForPluginRule(RULE_KEY)
       .setDefaultRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.name())
       .setDefaultRemediationGapMultiplier("1d")
       .setDefaultRemediationBaseEffort("5min")
-      .setRemediationFunction(null)
-      .setRemediationGapMultiplier(null)
-      .setRemediationBaseEffort(null));
+      .getDefinition());
     dbSession.commit();
 
     RuleUpdate update = RuleUpdate.createForPluginRule(RULE_KEY)
 
   @Test
   public void reset_remediation_function() {
-    ruleDao.insert(dbSession, RuleTesting.newDto(RULE_KEY)
+    RuleDto ruleDto = RuleTesting.newDto(RULE_KEY)
       .setDefaultRemediationFunction(DebtRemediationFunction.Type.LINEAR.name())
       .setDefaultRemediationGapMultiplier("1d")
       .setDefaultRemediationBaseEffort("5min")
       .setRemediationFunction(DebtRemediationFunction.Type.CONSTANT_ISSUE.name())
       .setRemediationGapMultiplier(null)
-      .setRemediationBaseEffort("1min"));
+      .setRemediationBaseEffort("1min");
+    ruleDao.insert(dbSession, ruleDto.getDefinition());
+    ruleDao.update(dbSession, ruleDto.getMetadata().setRuleId(ruleDto.getId()));
     dbSession.commit();
 
     RuleUpdate update = RuleUpdate.createForPluginRule(RULE_KEY).setDebtRemediationFunction(null);
   public void update_custom_rule() {
     // Create template rule
     RuleDto templateRule = RuleTesting.newTemplateRule(RuleKey.of("java", "S001"));
-    ruleDao.insert(dbSession, templateRule);
-    RuleParamDto templateRuleParam1 = RuleParamDto.createFor(templateRule).setName("regex").setType("STRING").setDescription("Reg ex").setDefaultValue(".*");
-    RuleParamDto templateRuleParam2 = RuleParamDto.createFor(templateRule).setName("format").setType("STRING").setDescription("Format");
-    ruleDao.insertRuleParam(dbSession, templateRule, templateRuleParam1);
-    ruleDao.insertRuleParam(dbSession, templateRule, templateRuleParam2);
+    ruleDao.insert(dbSession, templateRule.getDefinition());
+    RuleParamDto templateRuleParam1 = RuleParamDto.createFor(templateRule.getDefinition()).setName("regex").setType("STRING").setDescription("Reg ex").setDefaultValue(".*");
+    RuleParamDto templateRuleParam2 = RuleParamDto.createFor(templateRule.getDefinition()).setName("format").setType("STRING").setDescription("Format");
+    ruleDao.insertRuleParam(dbSession, templateRule.getDefinition(), templateRuleParam1);
+    ruleDao.insertRuleParam(dbSession, templateRule.getDefinition(), templateRuleParam2);
 
     // Create custom rule
-    RuleDto customRule = RuleTesting.newCustomRule(templateRule)
+    RuleDefinitionDto customRule = RuleTesting.newCustomRule(templateRule)
       .setName("Old name")
       .setDescription("Old description")
       .setSeverity(Severity.MINOR)
-      .setStatus(RuleStatus.BETA);
+      .setStatus(RuleStatus.BETA)
+      .getDefinition();
     ruleDao.insert(dbSession, customRule);
     ruleDao.insertRuleParam(dbSession, customRule, templateRuleParam1.setDefaultValue("a.*"));
     ruleDao.insertRuleParam(dbSession, customRule, templateRuleParam2.setDefaultValue(null));
   public void update_custom_rule_with_empty_parameter() {
     // Create template rule
     RuleDto templateRule = RuleTesting.newTemplateRule(RuleKey.of("java", "S001"));
-    ruleDao.insert(dbSession, templateRule);
-    RuleParamDto templateRuleParam = RuleParamDto.createFor(templateRule).setName("regex").setType("STRING").setDescription("Reg ex");
-    ruleDao.insertRuleParam(dbSession, templateRule, templateRuleParam);
+    ruleDao.insert(dbSession, templateRule.getDefinition());
+    RuleParamDto templateRuleParam = RuleParamDto.createFor(templateRule.getDefinition()).setName("regex").setType("STRING").setDescription("Reg ex");
+    ruleDao.insertRuleParam(dbSession, templateRule.getDefinition(), templateRuleParam);
 
     // Create custom rule
-    RuleDto customRule = RuleTesting.newCustomRule(templateRule)
+    RuleDefinitionDto customRule = RuleTesting.newCustomRule(templateRule)
       .setName("Old name")
       .setDescription("Old description")
       .setSeverity(Severity.MINOR)
-      .setStatus(RuleStatus.BETA);
+      .setStatus(RuleStatus.BETA)
+      .getDefinition();
     ruleDao.insert(dbSession, customRule);
     ruleDao.insertRuleParam(dbSession, customRule, templateRuleParam);
 
   public void update_active_rule_parameters_when_updating_custom_rule() {
     // Create template rule with 3 parameters
     RuleDto templateRule = RuleTesting.newTemplateRule(RuleKey.of("java", "S001")).setLanguage("xoo");
-    ruleDao.insert(dbSession, templateRule);
-    RuleParamDto templateRuleParam1 = RuleParamDto.createFor(templateRule).setName("regex").setType("STRING").setDescription("Reg ex").setDefaultValue(".*");
-    ruleDao.insertRuleParam(dbSession, templateRule, templateRuleParam1);
-    RuleParamDto templateRuleParam2 = RuleParamDto.createFor(templateRule).setName("format").setType("STRING").setDescription("format").setDefaultValue("csv");
-    ruleDao.insertRuleParam(dbSession, templateRule, templateRuleParam2);
-    RuleParamDto templateRuleParam3 = RuleParamDto.createFor(templateRule).setName("message").setType("STRING").setDescription("message");
-    ruleDao.insertRuleParam(dbSession, templateRule, templateRuleParam3);
+    RuleDefinitionDto templateRuleDefinition = templateRule.getDefinition();
+    ruleDao.insert(dbSession, templateRuleDefinition);
+    RuleParamDto templateRuleParam1 = RuleParamDto.createFor(templateRuleDefinition).setName("regex").setType("STRING").setDescription("Reg ex").setDefaultValue(".*");
+    ruleDao.insertRuleParam(dbSession, templateRuleDefinition, templateRuleParam1);
+    RuleParamDto templateRuleParam2 = RuleParamDto.createFor(templateRuleDefinition).setName("format").setType("STRING").setDescription("format").setDefaultValue("csv");
+    ruleDao.insertRuleParam(dbSession, templateRuleDefinition, templateRuleParam2);
+    RuleParamDto templateRuleParam3 = RuleParamDto.createFor(templateRuleDefinition).setName("message").setType("STRING").setDescription("message");
+    ruleDao.insertRuleParam(dbSession, templateRuleDefinition, templateRuleParam3);
 
     // Create custom rule
-    RuleDto customRule = RuleTesting.newCustomRule(templateRule).setSeverity(Severity.MAJOR).setLanguage("xoo");
+    RuleDefinitionDto customRule = RuleTesting.newCustomRule(templateRule)
+      .setSeverity(Severity.MAJOR)
+      .setLanguage("xoo")
+      .getDefinition();
     ruleDao.insert(dbSession, customRule);
     ruleDao.insertRuleParam(dbSession, customRule, templateRuleParam1.setDefaultValue("a.*"));
     ruleDao.insertRuleParam(dbSession, customRule, templateRuleParam2.setDefaultValue("txt"));
   public void fail_to_update_custom_rule_when_empty_name() {
     // Create template rule
     RuleDto templateRule = RuleTesting.newTemplateRule(RuleKey.of("java", "S001"));
-    ruleDao.insert(dbSession, templateRule);
+    ruleDao.insert(dbSession, templateRule.getDefinition());
 
     // Create custom rule
     RuleDto customRule = RuleTesting.newCustomRule(templateRule);
-    ruleDao.insert(dbSession, customRule);
+    ruleDao.insert(dbSession, customRule.getDefinition());
 
     dbSession.commit();
 
   public void fail_to_update_custom_rule_when_empty_description() {
     // Create template rule
     RuleDto templateRule = RuleTesting.newTemplateRule(RuleKey.of("java", "S001"));
-    ruleDao.insert(dbSession, templateRule);
+    ruleDao.insert(dbSession, templateRule.getDefinition());
 
     // Create custom rule
     RuleDto customRule = RuleTesting.newCustomRule(templateRule);
-    ruleDao.insert(dbSession, customRule);
+    ruleDao.insert(dbSession, customRule.getDefinition());
 
     dbSession.commit();
 
   public void fail_to_update_plugin_rule_if_name_is_set() {
     // Create rule rule
     RuleDto ruleDto = RuleTesting.newDto(RuleKey.of("squid", "S01"));
-    ruleDao.insert(dbSession, ruleDto);
+    ruleDao.insert(dbSession, ruleDto.getDefinition());
 
     dbSession.commit();
 
   public void fail_to_update_plugin_rule_if_description_is_set() {
     // Create rule rule
     RuleDto ruleDto = RuleTesting.newDto(RuleKey.of("squid", "S01"));
-    ruleDao.insert(dbSession, ruleDto);
+    ruleDao.insert(dbSession, ruleDto.getDefinition());
 
     dbSession.commit();
 
   public void fail_to_update_plugin_rule_if_severity_is_set() {
     // Create rule rule
     RuleDto ruleDto = RuleTesting.newDto(RuleKey.of("squid", "S01"));
-    ruleDao.insert(dbSession, ruleDto);
+    ruleDao.insert(dbSession, ruleDto.getDefinition());
 
     dbSession.commit();
 

server/sonar-server/src/test/java/org/sonar/server/rule/index/RuleIndexerTest.java

 import org.sonar.db.DbClient;
 import org.sonar.db.DbSession;
 import org.sonar.db.DbTester;
+import org.sonar.db.rule.RuleDefinitionDto;
 import org.sonar.db.rule.RuleDto;
 import org.sonar.server.es.EsTester;
 
 
   private DbClient dbClient = dbTester.getDbClient();
   private DbSession dbSession = dbTester.getSession();
-  private RuleDto rule = new RuleDto()
+  private RuleDefinitionDto rule = new RuleDefinitionDto()
     .setRuleKey("S001")
     .setRepositoryKey("xoo")
     .setConfigKey("S1")
     .setSeverity(Severity.BLOCKER)
     .setStatus(RuleStatus.READY)
     .setIsTemplate(true)
-    .setTags(newHashSet("performance"))
     .setSystemTags(newHashSet("cwe"))
     .setType(RuleType.BUG)
     .setCreatedAt(1500000000000L)

server/sonar-server/src/test/java/org/sonar/server/rule/index/RuleResultSetIteratorTest.java

 import org.sonar.db.DbClient;
 import org.sonar.db.DbSession;
 import org.sonar.db.DbTester;
+import org.sonar.db.rule.RuleDefinitionDto;
 import org.sonar.db.rule.RuleDto;
 
 import static com.google.common.collect.Sets.newHashSet;
     .setSeverity(Severity.BLOCKER)
     .setStatus(RuleStatus.READY)
     .setIsTemplate(true)
-    .setTags(newHashSet("performance"))
     .setSystemTags(newHashSet("cwe"))
     .setType(RuleType.BUG)
     .setCreatedAt(1500000000000L)
-    .setUpdatedAt(1600000000000L);
+    .setUpdatedAt(1600000000000L)
+    .setOrganizationUuid("foo-org")
+    .setTags(newHashSet("performance"));
 
-  RuleDto customRule = new RuleDto()
+  RuleDefinitionDto customRule = new RuleDefinitionDto()
     .setRuleKey("S002")
     .setRepositoryKey("xoo")
     .setConfigKey("S2")
 
   @Test
   public void iterator_over_one_rule() {
-    dbClient.ruleDao().insert(dbSession, templateRule);
-    dbSession.commit();
+    dbTester.rules().insertRule(templateRule);
 
     RuleResultSetIterator it = RuleResultSetIterator.create(dbTester.getDbClient(), dbTester.getSession(), 0L);
     Map<String, RuleDoc> rulesByKey = rulesByKey(it);
 
   @Test
   public void iterator_over_rules() {
-    dbClient.ruleDao().insert(dbSession, templateRule);
+    dbTester.rules().insertRule(templateRule);
     dbClient.ruleDao().insert(dbSession, customRule);
     dbSession.commit();
 
 
   @Test
   public void custom_rule() {
-    dbClient.ruleDao().insert(dbSession, templateRule);
+    dbTester.rules().insertRule(templateRule);
     dbClient.ruleDao().insert(dbSession, customRule.setTemplateId(templateRule.getId()));
     dbSession.commit();
 
 
   @Test
   public void removed_rule_is_returned() {
-    dbClient.ruleDao().insert(dbSession, templateRule.setStatus(RuleStatus.REMOVED));
+    dbTester.rules().insertRule(templateRule.setStatus(RuleStatus.REMOVED));
     dbSession.commit();
 
     RuleResultSetIterator it = RuleResultSetIterator.create(dbTester.getDbClient(), dbTester.getSession(), 0L);

server/sonar-server/src/test/java/org/sonar/server/rule/ws/CreateActionMediumTest.java

   public void create_custom_rule() throws Exception {
     // Template rule
     RuleDto templateRule = RuleTesting.newTemplateRule(RuleKey.of("java", "S001"), defaultOrganization);
-    ruleDao.insert(session, templateRule);
-    RuleParamDto param = RuleParamDto.createFor(templateRule).setName("regex").setType("STRING").setDescription("Reg ex").setDefaultValue(".*");
-    ruleDao.insertRuleParam(session, templateRule, param);
+    ruleDao.insert(session, templateRule.getDefinition());
+    ruleDao.update(session, templateRule.getMetadata().setRuleId(templateRule.getId()));
+    RuleParamDto param = RuleParamDto.createFor(templateRule.getDefinition()).setName("regex").setType("STRING").setDescription("Reg ex").setDefaultValue(".*");
+    ruleDao.insertRuleParam(session, templateRule.getDefinition(), param);
     session.commit();
 
     WsTester.TestRequest request = wsTester.newPostRequest("api/rules", "create")
   @Test
   public void create_custom_rule_with_prevent_reactivation_param_to_true() throws Exception {
     RuleDto templateRule = RuleTesting.newTemplateRule(RuleKey.of("java", "S001"));
-    ruleDao.insert(session, templateRule);
+    ruleDao.insert(session, templateRule.getDefinition());
 
     // insert a removed rule
     RuleDto customRule = RuleTesting.newCustomRule(templateRule)
       .setDescription("Description")
       .setDescriptionFormat(RuleDto.Format.MARKDOWN)
       .setSeverity(Severity.MAJOR);
-    tester.get(RuleDao.class).insert(session, customRule);
+    tester.get(RuleDao.class).insert(session, customRule.getDefinition());
     session.commit();
 
     WsTester.TestRequest request = wsTester.newPostRequest("api/rules", "create")

server/sonar-server/src/test/java/org/sonar/server/rule/ws/ListActionTest.java

 
   @Test
   public void return_rules_in_protobuf() throws Exception {
-    dbTester.getDbClient().ruleDao().insert(dbTester.getSession(), RuleTesting.newDto(RuleKey.of("java", "S001")).setConfigKey(null).setName(null));
-    dbTester.getDbClient().ruleDao().insert(dbTester.getSession(), RuleTesting.newDto(RuleKey.of("java", "S002")).setConfigKey("I002").setName("Rule Two"));
+    dbTester.rules().insertRule(RuleTesting.newDto(RuleKey.of("java", "S001")).setConfigKey(null).setName(null));
+    dbTester.rules().insertRule(RuleTesting.newDto(RuleKey.of("java", "S002")).setConfigKey("I002").setName("Rule Two"));
     dbTester.getSession().commit();
 
     TestResponse response = tester.newRequest()

server/sonar-server/src/test/java/org/sonar/server/rule/ws/RulesWsMediumTest.java

     tester.get(QualityProfileDao.class).insert(session, profile);
 
     RuleDto rule = RuleTesting.newXooX1(defaultOrganization);
-    ruleDao.insert(session, rule);
+    ruleDao.insert(session, rule.getDefinition());
+    ruleDao.update(session, rule.getMetadata().setRuleId(rule.getId()));
 
     ActiveRuleDto activeRuleDto = ActiveRuleDto.createFor(profile, rule).setSeverity("BLOCKER");
     tester.get(ActiveRuleDao.class).insert(session, activeRuleDto);
     QualityProfileDto profile = QProfileTesting.newXooP1("org-123");
     tester.get(QualityProfileDao.class).insert(session, profile);
 
-    RuleDto rule = RuleTesting.newXooX1().
-      setTags(ImmutableSet.of("hello", "world"))
+    RuleDto rule = RuleTesting.newXooX1()
+      .setTags(ImmutableSet.of("hello", "world"))
       .setSystemTags(Collections.<String>emptySet());
-    ruleDao.insert(session, rule);
+    ruleDao.insert(session, rule.getDefinition());
+    ruleDao.update(session, rule.getMetadata().setRuleId(rule.getId()));
 
     RuleDto rule2 = RuleTesting.newXooX2()
       .setTags(ImmutableSet.of("hello", "java"))
       .setSystemTags(ImmutableSet.of("sys1"));
-    ruleDao.insert(session, rule2);
+    ruleDao.insert(session, rule2.getDefinition());
+    ruleDao.update(session, rule2.getMetadata().setRuleId(rule2.getId()));
 
     session.commit();
     ruleIndexer.index();

server/sonar-server/src/test/java/org/sonar/server/rule/ws/SearchActionMediumTest.java

 package org.sonar.server.rule.ws;
 
 import com.google.common.collect.ImmutableSet;
-import java.util.Collections;
 import java.util.Date;
 import org.junit.After;
 import org.junit.Before;
 import org.sonar.db.qualityprofile.QualityProfileDao;
 import org.sonar.db.qualityprofile.QualityProfileDto;
 import org.sonar.db.rule.RuleDao;
+import org.sonar.db.rule.RuleDefinitionDto;
 import org.sonar.db.rule.RuleDto;
 import org.sonar.db.rule.RuleParamDto;
 import org.sonar.db.rule.RuleTesting;
   private static final String API_SEARCH_METHOD = "search";
 
   private DbClient db;
-  private RulesWs ws;
   private RuleDao ruleDao;
   private DbSession dbSession;
   private RuleIndexer ruleIndexer;
     tester.clearDbAndIndexes();
     db = tester.get(DbClient.class);
     ruleDao = tester.get(RuleDao.class);
-    ws = tester.get(RulesWs.class);
     dbSession = tester.get(DbClient.class).openSession(false);
     ruleIndexer = tester.get(RuleIndexer.class);
     activeRuleIndexer = tester.get(ActiveRuleIndexer.class);
 
   @Test
   public void filter_by_key_rules() throws Exception {
-    ruleDao.insert(dbSession, RuleTesting.newXooX1());
-    ruleDao.insert(dbSession, RuleTesting.newXooX2());
+    ruleDao.insert(dbSession, RuleTesting.newXooX1().getDefinition());
+    ruleDao.insert(dbSession, RuleTesting.newXooX2().getDefinition());
     dbSession.commit();
     ruleIndexer.index();
 
 
   @Test
   public void search_2_rules() throws Exception {
-    ruleDao.insert(dbSession, RuleTesting.newXooX1(defaultOrganization)
-      .setType(RuleType.BUG));
-    ruleDao.insert(dbSession, RuleTesting.newXooX2(defaultOrganization)
-      .setType(RuleType.VULNERABILITY));
+    RuleDto rule1 = RuleTesting.newXooX1(defaultOrganization)
+        .setType(RuleType.BUG);
+    ruleDao.insert(dbSession, rule1.getDefinition());
+    ruleDao.update(dbSession, rule1.getMetadata().setRuleId(rule1.getId()));
+    RuleDto rule2 = RuleTesting.newXooX2(defaultOrganization)
+        .setType(RuleType.VULNERABILITY);
+    ruleDao.insert(dbSession, rule2.getDefinition());
+    ruleDao.update(dbSession, rule2.getMetadata().setRuleId(rule2.getId()));
     dbSession.commit();
     ruleIndexer.index();
 
   @Test
   public void search_2_rules_with_fields_selection() throws Exception {
     ruleDao.insert(dbSession, RuleTesting.newXooX1()
-      .setType(RuleType.CODE_SMELL))
-    ;
+      .setType(RuleType.CODE_SMELL)
+      .getDefinition());
     ruleDao.insert(dbSession, RuleTesting.newXooX2()
       .setType(RuleType.BUG)
       .setDescription("A *Xoo* rule")
-      .setDescriptionFormat(RuleDto.Format.MARKDOWN))
-    ;
+      .setDescriptionFormat(RuleDto.Format.MARKDOWN)
+      .getDefinition());
     dbSession.commit();
     ruleIndexer.index();
 
   public void return_mandatory_fields_even_when_setting_f_param() throws Exception {
     ruleDao.insert(dbSession, RuleTesting.newXooX1()
       .setName("Rule x1")
-      .setType(RuleType.CODE_SMELL))
-    ;
+      .setType(RuleType.CODE_SMELL)
+      .getDefinition());
     dbSession.commit();
     ruleIndexer.index();
 
 
   @Test
   public void return_lang_field() throws Exception {
-    ruleDao.insert(dbSession, RuleTesting.newXooX1());
+    ruleDao.insert(dbSession, RuleTesting.newXooX1().getDefinition());
     dbSession.commit();
     ruleIndexer.index();
 
 
   @Test
   public void return_lang_name_field() throws Exception {
-    ruleDao.insert(dbSession, RuleTesting.newXooX1());
+    ruleDao.insert(dbSession, RuleTesting.newXooX1().getDefinition());
     dbSession.commit();
     ruleIndexer.index();
 
 
   @Test
   public void return_lang_key_field_when_language_name_is_not_available() throws Exception {
-    ruleDao.insert(dbSession, RuleTesting.newDto(RuleKey.of("other", "rule")).setLanguage("unknown"));
+    ruleDao.insert(dbSession, RuleTesting.newDto(RuleKey.of("other", "rule")).setLanguage("unknown").getDefinition());
     dbSession.commit();
     ruleIndexer.index();
 
 
   @Test
   public void search_debt_rules_with_default_and_overridden_debt_values() throws Exception {
-    ruleDao.insert(dbSession, RuleTesting.newXooX1()
+    RuleDto ruleDto = RuleTesting.newXooX1()
       .setDefaultRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.name())
       .setDefaultRemediationGapMultiplier("1h")
       .setDefaultRemediationBaseEffort("15min")
       .setRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.name())
       .setRemediationGapMultiplier("2h")
-      .setRemediationBaseEffort("25min"));
+      .setRemediationBaseEffort("25min");
+    ruleDao.insert(dbSession, ruleDto.getDefinition());
+    ruleDao.update(dbSession, ruleDto.getMetadata().setRuleId(ruleDto.getId()));
     dbSession.commit();
     ruleIndexer.index();
 
 
   @Test
   public void search_debt_rules_with_default_linear_offset_and_overridden_constant_debt() throws Exception {
-    ruleDao.insert(dbSession, RuleTesting.newXooX1()
+    RuleDto ruleDto = RuleTesting.newXooX1()
       .setDefaultRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.name())
       .setDefaultRemediationGapMultiplier("1h")
       .setDefaultRemediationBaseEffort("15min")
       .setRemediationFunction(DebtRemediationFunction.Type.CONSTANT_ISSUE.name())
       .setRemediationGapMultiplier(null)
-      .setRemediationBaseEffort("5min"));
+      .setRemediationBaseEffort("5min");
+    ruleDao.insert(dbSession, ruleDto.getDefinition());
+    ruleDao.update(dbSession, ruleDto.getMetadata().setRuleId(ruleDto.getId()));
     dbSession.commit();
     ruleIndexer.index();
 
 
   @Test
   public void search_debt_rules_with_default_linear_offset_and_overridden_linear_debt() throws Exception {
-    ruleDao.insert(dbSession, RuleTesting.newXooX1()
+    RuleDto ruleDto = RuleTesting.newXooX1()
       .setDefaultRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.name())
       .setDefaultRemediationGapMultiplier("1h")
       .setDefaultRemediationBaseEffort("15min")
       .setRemediationFunction(DebtRemediationFunction.Type.LINEAR.name())
       .setRemediationGapMultiplier("1h")
-      .setRemediationBaseEffort(null));
+      .setRemediationBaseEffort(null);
+    ruleDao.insert(dbSession, ruleDto.getDefinition());
+    ruleDao.update(dbSession, ruleDto.getMetadata().setRuleId(ruleDto.getId()));
     dbSession.commit();
     ruleIndexer.index();
 
   @Test
   public void search_template_rules() throws Exception {
     RuleDto templateRule = RuleTesting.newXooX1().setIsTemplate(true);
-    ruleDao.insert(dbSession, templateRule);
+    ruleDao.insert(dbSession, templateRule.getDefinition());
     RuleDto rule = RuleTesting.newXooX2();
     rule.setTemplateId(templateRule.getId());
-    ruleDao.insert(dbSession, rule);
+    ruleDao.insert(dbSession, rule.getDefinition());
     dbSession.commit();
     ruleIndexer.index();
 
   @Test
   public void search_custom_rules_from_template_key() throws Exception {
     RuleDto templateRule = RuleTesting.newXooX1().setIsTemplate(true);
-    ruleDao.insert(dbSession, templateRule);
-    ruleDao.insert(dbSession, RuleTesting.newXooX2().setTemplateId(templateRule.getId()));
+    ruleDao.insert(dbSession, templateRule.getDefinition());
+    ruleDao.insert(dbSession, RuleTesting.newXooX2().setTemplateId(templateRule.getId()).getDefinition());
     dbSession.commit();
     ruleIndexer.index();
 
     tester.get(QualityProfileDao.class).insert(dbSession, profile);
 
     RuleDto rule = RuleTesting.newXooX1();
-    ruleDao.insert(dbSession, rule);
+    ruleDao.insert(dbSession, rule.getDefinition());
 
     ActiveRuleDto activeRule = newActiveRule(profile, rule);
     tester.get(ActiveRuleDao.class).insert(dbSession, activeRule);
     dbSession.commit();
 
     RuleDto rule = RuleTesting.newXooX1();
-    ruleDao.insert(dbSession, rule);
+    RuleDefinitionDto definition = rule.getDefinition();
+    ruleDao.insert(dbSession, definition);
 
-    RuleParamDto param = RuleParamDto.createFor(rule)
+    RuleParamDto param = RuleParamDto.createFor(definition)
       .setDefaultValue("some value")
       .setType("string")
       .setDescription("My small description")
       .setName("my_var");
-    ruleDao.insertRuleParam(dbSession, rule, param);
+    ruleDao.insertRuleParam(dbSession, definition, param);
 
-    RuleParamDto param2 = RuleParamDto.createFor(rule)
+    RuleParamDto param2 = RuleParamDto.createFor(definition)
       .setDefaultValue("other value")
       .setType("integer")
       .setDescription("My small description")
       .setName("the_var");
-    ruleDao.insertRuleParam(dbSession, rule, param2);
+    ruleDao.insertRuleParam(dbSession, definition, param2);
 
     // SONAR-7083
-    RuleParamDto param3 = RuleParamDto.createFor(rule)
+    RuleParamDto param3 = RuleParamDto.createFor(definition)
       .setDefaultValue(null)
       .setType("string")
       .setDescription("Empty Param")
       .setName("empty_var");
-    ruleDao.insertRuleParam(dbSession, rule, param3);
+    ruleDao.insertRuleParam(dbSession, definition, param3);
 
     ActiveRuleDto activeRule = newActiveRule(profile, rule);
     tester.get(ActiveRuleDao.class).insert(dbSession, activeRule);
     dbSession.commit();
 
     RuleDto rule = RuleTesting.newXooX1();
-    ruleDao.insert(dbSession, rule);
+    ruleDao.insert(dbSession, rule.getDefinition());
 
     ActiveRuleDto activeRule = newActiveRule(profile, rule);
     tester.get(ActiveRuleDao.class).insert(dbSession, activeRule);
     QualityProfileDto profile = QProfileTesting.newXooP1("org-123");
     tester.get(QualityProfileDao.class).insert(dbSession, profile);
     RuleDto rule = RuleTesting.newXooX1();
-    ruleDao.insert(dbSession, rule);
+    RuleDefinitionDto definition = rule.getDefinition();
+    ruleDao.insert(dbSession, definition);
     dbSession.commit();
 
-    RuleParamDto param = RuleParamDto.createFor(rule)
+    RuleParamDto param = RuleParamDto.createFor(definition)
       .setDefaultValue("some value")
       .setType("string")
       .setDescription("My small description")
       .setName("my_var");
-    ruleDao.insertRuleParam(dbSession, rule, param);
+    ruleDao.insertRuleParam(dbSession, definition, param);
 
-    RuleParamDto param2 = RuleParamDto.createFor(rule)
+    RuleParamDto param2 = RuleParamDto.createFor(definition)
       .setDefaultValue("other value")
       .setType("integer")
       .setDescription("My small description")
       .setName("the_var");
-    ruleDao.insertRuleParam(dbSession, rule, param2);
+    ruleDao.insertRuleParam(dbSession, definition, param2);
 
     ActiveRuleDto activeRule = newActiveRule(profile, rule);
     tester.get(ActiveRuleDao.class).insert(dbSession, activeRule);
     QualityProfileDto profile = QProfileTesting.newXooP1("org-123");
     tester.get(QualityProfileDao.class).insert(dbSession, profile);
     RuleDto rule = RuleTesting.newXooX1().setNoteData("this is *bold*");
-    ruleDao.insert(dbSession, rule);
+    ruleDao.insert(dbSession, rule.getDefinition());
+    ruleDao.update(dbSession, rule.getMetadata().setRuleId(rule.getId()));
 
     dbSession.commit();
     ruleIndexer.index();
   @Test
   public void filter_by_tags() throws Exception {
     ruleDao.insert(dbSession, RuleTesting.newXooX1()
-      .setTags(Collections.<String>emptySet())
-      .setSystemTags(ImmutableSet.of("tag1")));
+      .setSystemTags(ImmutableSet.of("tag1"))
+      .getDefinition());
     ruleDao.insert(dbSession, RuleTesting.newXooX2()
-      .setTags(Collections.<String>emptySet())
-      .setSystemTags(ImmutableSet.of("tag2")));
+      .setSystemTags(ImmutableSet.of("tag2"))
+      .getDefinition());
 
     dbSession.commit();
     ruleIndexer.index();
 
   @Test
   public void statuses_facet_should_be_sticky() throws Exception {
-    ruleDao.insert(dbSession, RuleTesting.newXooX1());
-    ruleDao.insert(dbSession, RuleTesting.newXooX2().setStatus(RuleStatus.BETA));
-    ruleDao.insert(dbSession, RuleTesting.newXooX3().setStatus(RuleStatus.DEPRECATED));
+    ruleDao.insert(dbSession, RuleTesting.newXooX1().getDefinition());
+    ruleDao.insert(dbSession, RuleTesting.newXooX2().setStatus(RuleStatus.BETA).getDefinition());
+    ruleDao.insert(dbSession, RuleTesting.newXooX3().setStatus(RuleStatus.DEPRECATED).getDefinition());
 
     dbSession.commit();
     ruleIndexer.index();
 
   @Test
   public void sort_by_name() throws Exception {
-    ruleDao.insert(dbSession, RuleTesting.newXooX1().setName("Dodgy - Consider returning a zero length array rather than null "));
-    ruleDao.insert(dbSession, RuleTesting.newXooX2().setName("Bad practice - Creates an empty zip file entry"));
-    ruleDao.insert(dbSession, RuleTesting.newXooX3().setName("XPath rule"));
+    ruleDao.insert(dbSession, RuleTesting.newXooX1()
+      .setName("Dodgy - Consider returning a zero length array rather than null ")
+      .getDefinition());
+    ruleDao.insert(dbSession, RuleTesting.newXooX2()
+      .setName("Bad practice - Creates an empty zip file entry")
+      .getDefinition());
+    ruleDao.insert(dbSession, RuleTesting.newXooX3()
+      .setName("XPath rule")
+      .getDefinition());
 
     dbSession.commit();
     ruleIndexer.index();
     Date since = new Date();
     ruleDao.insert(dbSession, RuleTesting.newXooX1()
       .setUpdatedAt(since.getTime())
-      .setCreatedAt(since.getTime()));
+      .setCreatedAt(since.getTime())
+      .getDefinition());
     ruleDao.insert(dbSession, RuleTesting.newXooX2()
       .setUpdatedAt(since.getTime())
-      .setCreatedAt(since.getTime()));
+      .setCreatedAt(since.getTime())
+      .getDefinition());
 
     dbSession.commit();
     dbSession.clearCache();
 
   @Test
   public void search_rules_with_deprecated_fields() throws Exception {
-    ruleDao.insert(dbSession, RuleTesting.newXooX1()
-      .setDefaultRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.name())
-      .setDefaultRemediationGapMultiplier("1h")
-      .setDefaultRemediationBaseEffort("15min")
-      .setRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.name())
-      .setRemediationGapMultiplier("2h")
-      .setRemediationBaseEffort("25min"));
+    RuleDto ruleDto = RuleTesting.newXooX1()
+        .setDefaultRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.name())
+        .setDefaultRemediationGapMultiplier("1h")
+        .setDefaultRemediationBaseEffort("15min")
+        .setRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.name())
+        .setRemediationGapMultiplier("2h")
+        .setRemediationBaseEffort("25min");
+    ruleDao.insert(dbSession, ruleDto.getDefinition());
+    ruleDao.update(dbSession, ruleDto.getMetadata().setRuleId(ruleDto.getId()));
     dbSession.commit();
     ruleIndexer.index();
 

server/sonar-server/src/test/java/org/sonar/server/rule/ws/ShowActionMediumTest.java

 import org.sonar.db.qualityprofile.QualityProfileDao;
 import org.sonar.db.qualityprofile.QualityProfileDto;
 import org.sonar.db.rule.RuleDao;
+import org.sonar.db.rule.RuleDefinitionDto;
 import org.sonar.db.rule.RuleDto;
 import org.sonar.db.rule.RuleDto.Format;
 import org.sonar.db.rule.RuleParamDto;
       .setTags(newHashSet("tag1", "tag2"))
       .setSystemTags(newHashSet("systag1", "systag2"))
       .setType(RuleType.BUG);
-    ruleDao.insert(session, ruleDto);
-    RuleParamDto param = RuleParamDto.createFor(ruleDto).setName("regex").setType("STRING").setDescription("Reg *exp*").setDefaultValue(".*");
-    ruleDao.insertRuleParam(session, ruleDto, param);
+    RuleDefinitionDto definition = ruleDto.getDefinition();
+    ruleDao.insert(session, definition);
+    ruleDao.update(session, ruleDto.getMetadata().setRuleId(ruleDto.getId()));
+    RuleParamDto param = RuleParamDto.createFor(definition).setName("regex").setType("STRING").setDescription("Reg *exp*").setDefaultValue(".*");
+    ruleDao.insertRuleParam(session, definition, param);
     session.commit();
     session.clearCache();
 
       .setRemediationFunction(null)
       .setRemediationGapMultiplier(null)
       .setRemediationBaseEffort(null);
-    ruleDao.insert(session, ruleDto);
+    ruleDao.insert(session, ruleDto.getDefinition());
+    ruleDao.update(session, ruleDto.getMetadata());
     session.commit();
     session.clearCache();
 
       .setRemediationFunction("LINEAR_OFFSET")
       .setRemediationGapMultiplier("5d")
       .setRemediationBaseEffort("10h");
-    ruleDao.insert(session, ruleDto);
+    ruleDao.insert(session, ruleDto.getDefinition());
+    ruleDao.update(session, ruleDto.getMetadata().setRuleId(ruleDto.getId()));
     session.commit();
     session.clearCache();
 
       .setRemediationFunction("LINEAR_OFFSET")
       .setRemediationGapMultiplier("5d")
       .setRemediationBaseEffort("10h");
-    ruleDao.insert(session, ruleDto);
+    ruleDao.insert(session, ruleDto.getDefinition());
+    ruleDao.update(session, ruleDto.getMetadata().setRuleId(ruleDto.getId()));
     session.commit();
     session.clearCache();
 
       .setLanguage("xoo")
       .setDefaultRemediationFunction(null)
       .setDefaultRemediationGapMultiplier(null)
-      .setDefaultRemediationBaseEffort(null)
-      .setRemediationFunction(null)
-      .setRemediationGapMultiplier(null)
-      .setRemediationBaseEffort(null);
-    ruleDao.insert(session, ruleDto);
+      .setDefaultRemediationBaseEffort(null);
+    ruleDao.insert(session, ruleDto.getDefinition());
     session.commit();
     session.clearCache();
 
   public void encode_html_description_of_custom_rule() throws Exception {
     // Template rule
     RuleDto templateRule = RuleTesting.newTemplateRule(RuleKey.of("java", "S001"));
-    ruleDao.insert(session, templateRule);
+    ruleDao.insert(session, templateRule.getDefinition());
     session.commit();
 
     // Custom rule
       .setRemediationFunction("LINEAR_OFFSET")
       .setRemediationGapMultiplier("5d")
       .setRemediationBaseEffort("10h");
-    ruleDao.insert(session, ruleDto);
+    ruleDao.insert(session, ruleDto.getDefinition());
+    ruleDao.update(session, ruleDto.getMetadata().setRuleId(ruleDto.getId()));
     session.commit();
 
     WsTester.TestRequest request = wsTester.newGetRequest("api/rules", "show")
       .setType(RuleType.BUG)
       .setCreatedAt(new Date().getTime())
       .setUpdatedAt(new Date().getTime());
-    ruleDao.insert(session, ruleDto);
-    RuleParamDto regexParam = RuleParamDto.createFor(ruleDto).setName("regex").setType("STRING").setDescription("Reg *exp*").setDefaultValue(".*");
-    ruleDao.insertRuleParam(session, ruleDto, regexParam);
+    RuleDefinitionDto definition = ruleDto.getDefinition();
+    ruleDao.insert(session, definition);
+    RuleParamDto regexParam = RuleParamDto.createFor(definition).setName("regex").setType("STRING").setDescription("Reg *exp*").setDefaultValue(".*");
+    ruleDao.insertRuleParam(session, definition, regexParam);
 
     QualityProfileDto profile = QualityProfileDto.createFor("profile")
       .setOrganizationUuid(defaultOrganizationProvider.get().getUuid())

server/sonar-server/src/test/java/org/sonar/server/rule/ws/UpdateActionMediumTest.java

 import org.sonar.db.DbSession;
 import org.sonar.db.organization.OrganizationDto;
 import org.sonar.db.rule.RuleDao;
+import org.sonar.db.rule.RuleDefinitionDto;
 import org.sonar.db.rule.RuleDto;
 import org.sonar.db.rule.RuleParamDto;
 import org.sonar.db.rule.RuleTesting;
 import org.sonar.server.organization.DefaultOrganizationProvider;
 import org.sonar.server.rule.NewCustomRule;
 import org.sonar.server.rule.RuleCreator;
-import org.sonar.server.rule.RuleService;
 import org.sonar.server.tester.ServerTester;
 import org.sonar.server.tester.UserSessionRule;
 import org.sonar.server.ws.WsTester;
   public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
 
   private WsTester wsTester;
-  private RuleService ruleService;
   private RuleDao ruleDao;
   private DbSession session;
   private OrganizationDto defaultOrganization;
   public void setUp() {
     tester.clearDbAndIndexes();
     wsTester = tester.get(WsTester.class);
-    ruleService = tester.get(RuleService.class);
     ruleDao = tester.get(RuleDao.class);
     DbClient dbClient = tester.get(DbClient.class);
     session = dbClient.openSession(false);
     RuleDto rule = RuleTesting.newXooX1()
       .setDefaultRemediationFunction(LINEAR.toString())
       .setDefaultRemediationGapMultiplier("10d")
-      .setDefaultRemediationBaseEffort(null)
-      .setRemediationFunction(null)
-      .setRemediationGapMultiplier(null)
-      .setRemediationBaseEffort(null);
-    ruleDao.insert(session, rule);
+      .setDefaultRemediationBaseEffort(null);
+    ruleDao.insert(session, rule.getDefinition());
     session.commit();
 
     WsTester.TestRequest request = wsTester.newPostRequest("api/rules", "update")
       .setRemediationFunction(LINEAR_OFFSET.toString())
       .setRemediationGapMultiplier("15min")
       .setRemediationBaseEffort("3h");
-    ruleDao.insert(session, rule);
+    ruleDao.insert(session, rule.getDefinition());
+    ruleDao.update(session, rule.getMetadata().setRuleId(rule.getId()));
     session.commit();
 
     WsTester.TestRequest request = wsTester.newPostRequest("api/rules", "update")
   public void update_custom_rule() throws Exception {
     // Template rule
     RuleDto templateRule = RuleTesting.newTemplateRule(RuleKey.of("java", "S001"), defaultOrganization);
-    ruleDao.insert(session, templateRule);
-    RuleParamDto param = RuleParamDto.createFor(templateRule).setName("regex").setType("STRING").setDescription("Reg ex").setDefaultValue(".*");
-    ruleDao.insertRuleParam(session, templateRule, param);
+    RuleDefinitionDto definition = templateRule.getDefinition();
+    ruleDao.insert(session, definition);
+    ruleDao.update(session, templateRule.getMetadata().setRuleId(templateRule.getId()));
+    RuleParamDto param = RuleParamDto.createFor(definition).setName("regex").setType("STRING").setDescription("Reg ex").setDefaultValue(".*");
+    ruleDao.insertRuleParam(session, definition, param);
     session.commit();
 
     // Custom rule
   public void fail_to_update_custom_when_description_is_empty() {
     // Template rule
     RuleDto templateRule = RuleTesting.newTemplateRule(RuleKey.of("java", "S001"));
-    ruleDao.insert(session, templateRule);
+    ruleDao.insert(session, templateRule.getDefinition());
 
     // Custom rule
     RuleDto customRule = RuleTesting.newCustomRule(templateRule);
-    ruleDao.insert(session, customRule);
+    ruleDao.insert(session, customRule.getDefinition());
     session.commit();
     session.clearCache();
 

server/sonar-server/src/test/java/org/sonar/server/view/index/ViewIndexerTest.java

     String viewUuid = "ABCD";
 
     RuleDto rule = RuleTesting.newXooX1();
-    dbClient.ruleDao().insert(dbSession, rule);
+    dbClient.ruleDao().insert(dbSession, rule.getDefinition());
     ComponentDto project1 = addProjectWithIssue(rule, dbTester.organizations().insert());
     issueIndexer.indexOnStartup(issueIndexer.getIndexTypes());
     permissionIndexer.indexProjectsByUuids(dbSession, asList(project1.uuid()));