title: Unable to delete row : TransactionRequiredException: Executing an update/delete query
body: <p>There are several posts on this question but still not getting the solution.
  This the parent class Userr. 
  In a @OneToMany relationship I want to remove a particular child Account.</p>
  
  <p>Now When I do this by "DELETE" query I am getting following exception.</p>
  
  <p>org.springframework.dao.InvalidDataAccessApiUsageException: Executing an update/delete query; nested exception is javax.persistence.TransactionRequiredException: Executing an update/delete query</p>
  
  <pre><code>@RooJavaBean
  @RooToString
  @RooJpaEntity
  @RooJpaActiveRecord(finders = { "findUserrsByUserName"})
  public class Userr {
  
  
  @NotNull
  @Column(unique = true)
  private String userName;
  
  
  @NotNull
  private int userType;
  
  @OneToMany(mappedBy = "user", fetch = FetchType.LAZY, cascade = CascadeType.ALL, orphanRemoval = true)
  private List&lt;Account&gt; accounts = new ArrayList&lt;Account&gt;();
  }
  </code></pre>
  
  <p>Child class </p>
  
  <pre><code>@RooJavaBean
  @RooToString
  @RooJpaActiveRecord
  @RooJpaEntity
  public class Account {
  
  @OneToMany(mappedBy="account", fetch=FetchType.LAZY, cascade = CascadeType.ALL)
  List&lt;Message&gt; messages = new ArrayList&lt;Message&gt;();
  
  
  /*@OneToMany(mappedBy="account", fetch=FetchType.LAZY, cascade = CascadeType.ALL)
  List&lt;PremiumPlayPositionCombination&gt; premiumPlayPosition = new ArrayList&lt;PremiumPlayPositionCombination&gt;();*/
  
  
  @OneToMany(mappedBy="account", fetch=FetchType.LAZY, cascade = CascadeType.ALL)
  List&lt;PositionCombinationArc&gt; allPositionsArc = new ArrayList&lt;PositionCombinationArc&gt;();
  
  @ManyToOne
  @JoinColumn(name="user_id")
  private Userr user;
  }
  </code></pre>
  
  <p>Here is my delete query </p>
  
  <pre><code>@Transactional
  public static void deleteClientByClientId(Long clientId) {
      System.out.println("Delete query findUsersClientsByUser" + clientId);
      int deleteCount= entityManager().createQuery("DELETE FROM Account where id =:clientId").setParameter("clientId", clientId).executeUpdate();
      System.out.println("Delete query findUsersClientsByUser" + deleteCount);
  
  
  
  }
  </code></pre>
  
  <p>I have added in ApplicationContext-security.xml like this </p>
  
  <pre><code> &lt;?xml version="1.0" encoding="UTF-8" standalone="no"?&gt;
  &lt;beans xmlns="http://www.springframework.org/schema/beans"      xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context" xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd         http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd         http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.0.xsd         http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd"&gt;
  &lt;!--
      This will automatically locate any and all property files you have
      within your classpath, provided they fall under the META-INF/spring
      directory. The located property files are parsed and their values can
      then be used within application context files in the form of
      ${propertyKey}.
  --&gt;
  &lt;context:property-placeholder location="classpath*:META-INF/spring/*.properties"/&gt;
  &lt;!--
      Turn on AspectJ @Configurable support. As a result, any time you
      instantiate an object, Spring will attempt to perform dependency
      injection on that object. This occurs for instantiation via the "new"
      keyword, as well as via reflection. This is possible because AspectJ
      is used to "weave" Roo-based applications at compile time. In effect
      this feature allows dependency injection of any object at all in your
      system, which is a very useful feature (without @Configurable you'd
      only be able to dependency inject objects acquired from Spring or
      subsequently presented to a specific Spring dependency injection
      method). Roo applications use this useful feature in a number of
      areas, such as @PersistenceContext injection into entities.
  --&gt;
  &lt;context:spring-configured/&gt;
  &lt;bean class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close" id="dataSource"&gt;
      &lt;property name="driverClassName" value="${database.driverClassName}"/&gt;
      &lt;property name="url" value="${database.url}"/&gt;
      &lt;property name="username" value="${database.username}"/&gt;
      &lt;property name="password" value="${database.password}"/&gt;
  &lt;/bean&gt;
  &lt;bean class="org.springframework.orm.jpa.JpaTransactionManager" id="transactionManager"&gt;
      &lt;property name="entityManagerFactory" ref="entityManagerFactory"/&gt;
  &lt;/bean&gt;
  &lt;tx:annotation-driven mode="aspectj" transaction-manager="transactionManager"/&gt;
  &lt;bean class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean" id="entityManagerFactory"&gt;
      &lt;property name="dataSource" ref="dataSource"/&gt;
  &lt;/bean&gt;
  &lt;bean id="mailSender" class="org.springframework.mail.javamail.JavaMailSenderImpl"&gt;
      &lt;property name="host" value="smtp.gmail.com"/&gt;
      &lt;property name="port" value="587"/&gt;
      &lt;property name="username" value="noreply@uforic.in"/&gt;
      &lt;property name="password" value="noreply@123"/&gt;
      &lt;property name="javaMailProperties"&gt;
          &lt;props&gt;
              &lt;prop key="mail.transport.protocol"&gt;smtp&lt;/prop&gt;
              &lt;prop key="mail.smtp.auth"&gt;true&lt;/prop&gt;
              &lt;prop key="mail.smtp.starttls.enable"&gt;true&lt;/prop&gt;
              &lt;prop key="mail.debug"&gt;true&lt;/prop&gt;
          &lt;/props&gt;
      &lt;/property&gt;
  &lt;/bean&gt;
  &lt;!--
      This declaration will cause Spring to locate every @Component,
      @Repository and @Service in your application. In practical terms this
      allows you to write a POJO and then simply annotate the new POJO as an
      @Service and Spring will automatically detect, instantiate and
      dependency inject your service at startup time. Importantly, you can
      then also have your new service injected into any other class that
      requires it simply by declaring a field for your service inside the
      relying class and Spring will inject it. Note that two exclude filters
      are declared. The first ensures that Spring doesn't spend time
      introspecting Roo-specific ITD aspects. The second ensures Roo doesn't
      instantiate your @Controller classes, as these should be instantiated
      by a web tier application context. Refer to web.xml for more details
      about the web tier application context setup services.
  
      Furthermore, this turns on @Autowired, @PostConstruct etc support. These 
      annotations allow you to use common Spring and Java Enterprise Edition 
      annotations in your classes without needing to do any special configuration. 
      The most commonly used annotation is @Autowired, which instructs Spring to
      dependency inject an object into your class.
  --&gt;
  &lt;context:component-scan base-package="com.uforic.optionstrader"&gt;
      &lt;context:exclude-filter expression=".*_Roo_.*" type="regex"/&gt;
      &lt;!--context:exclude-filter expression="org.springframework.stereotype.Controller" type="annotation"/--&gt;
  &lt;/context:component-scan&gt;
  </code></pre>
  
  <p></p>