Hibernate One-to-Many cascade efficiency

Question

I have been learning Hibernate for the past few weeks, I have gotten most of what I learned to work but have a question on the efficiency of a One-to-Many mapping. It works, but I am pretty sure that it could be tweaked quite a bit. When saving, I notice that there are three queries that get executed, an insert for the "Parent" object, an insert for the "Child" object and then an update query for the child that updates the foreign key for the parent object. My assumption is that there is a more efficient way to map this relationship so that there is only the two inserts. Am I missing something relatively obvious in my mapping?

Here is my code:

Parent:

@Entity      
@Table(name="Punch")  
public class Punch implements Serializable  
{  
private Long id;  
private DateTime punchDate;  
private Integer userId;  
private List<PunchTimes> punches= new ArrayList<PunchTimes>();  
private static final long serialVersionUID=2010010611;  
...Various getters & setters... 
@OneToMany    
@JoinColumn(name="punchId_fk")  
@OrderBy("pid")  
@Cascade(org.hibernate.annotations.CascadeType.ALL)  
public List<PunchTimes> getPunches()  
{  
    return punches;  
}  
}

Child:

@Entity
@Table(name = "PunchTimes")
public class PunchTimes implements Serializable{
private Long id;
private Long pid;
private DateTime inTime;
private DateTime outTime;
private Double adjustedTime;
private static final long serialVersionUID = 20100106;
private Punch punch;
...Various getters & setters...
@ManyToOne
@JoinColumn(name = "punchId_fk", insertable = false, updatable = false)
public Punch getPunch(){
return punch;
}
}

SQL Output:

Hibernate:
insert
into
Punch
(punchDate, employeeId)
values
(?, ?)

Hibernate:
insert
into
PunchTimes
(adjusted, inTime, outTime, punchId_fk)
values
(?, ?, ?, ?)

Hibernate: update
PunchTimes
set
punchId_fk=?
where
inoutId=?

Answer 1

import java.io.Serializable;
import javax.persistence.*;
import org.hibernate.annotations.Type;
import org.joda.time.DateTime;

@Entity
@Table(name = "PunchTimes")
public class PunchTimes implements Serializable
{
    private static final long serialVersionUID = 20100106;
    private Long id;
    private Long pid;
    private DateTime inTime;
    private DateTime outTime=null;
    private Double adjustedTime=null;
    private Boolean adjustedByOperator=false;
    private Boolean overtimeAuthorized;
    private Punch punch;

    public PunchTimes()
    {
    }

    @Column(name = "adjusted")
    public Double getAdjustedTime()
    {
        return adjustedTime;
    }

    public void setAdjustedTime(Double adjustedTime)
    {
        this.adjustedTime = adjustedTime;
    }

    @Id
    @GeneratedValue
    @Column(name = "inoutId")
    public Long getId()
    {
        return id;
    }

    public void setId(Long id)
    {
        this.id = id;
    }

    @Column(name = "inTime")
    @Type(type = "org.joda.time.contrib.hibernate.PersistentDateTime")
    public DateTime getInTime()
    {
        return inTime;
    }

    public void setInTime(DateTime inTime)
    {
        this.inTime = inTime;
    }

    @Column(name = "outTime")
    @Type(type = "org.joda.time.contrib.hibernate.PersistentDateTime")
    public DateTime getOutTime()
    {
        return outTime;
    }

    public void setOutTime(DateTime outTime)
    {
        this.outTime = outTime;
    }

    @Column(name = "punchId_fk" ,insertable = false, updatable = false)
    public Long getPid()
    {
        return pid;
    }

    public void setPid(Long pid)
    {
        this.pid = pid;
    }

    @ManyToOne
    @JoinColumn(name = "punchId_fk" )
    public Punch getPunch()
    {
        return punch;
    }

    public void setPunch(Punch punch)
    {
        this.punch = punch;
    }

To get rid of the update I had to make the foreign-key (pid) insertable=false, updatable=false