OracleConnection does not support parallel transactions

I'm not manually manging transaction.
What i'm doing is cloning some xpo object from one session to another.
Basically when a user click on save, i have to move some rows from SQL Server to Oracle.

here is the code i'm using:

Session SqlSession = XpoDataSourcePreordini.Session;// session from the grid
Session oracleSession = XpoHelperOracle.GetNewSession();

XPClassInfo preordineClass = SqlSession.GetClassInfo(typeof(Preordine));
ICollection preordini = SqlSession.GetObjects(preordineClass, CriteriaOperator.Parse(Filter), null, int.MaxValue, false, true);

CloneIXPSimpleObjectHelper cloneHelper = new CloneIXPSimpleObjectHelper(SqlSession, oracleSession);
foreach (Preordine currOrdine in preordini)
{
Preordine pers = cloneHelper.Clone(currOrdine);
pers.ID_PREORDINE = currOrdine.ID_PREORDINE;
oracleSession.Save(pers);
}

foreach (Preordine currOrdine in preordini)
currOrdine.Delete();

// If i will not execute the following 2 lines of code that i get ORA-12516
oracleSession.Disconnect();
oracleSession.Dispose();

Here it is the class "Preordine" which represent a row moving from sql to oracle

[Persistent("PREORDINE_CLIENTE")]
public class Preordine : XPLiteObject
{
int fID_PREORDINE;
[Key(false)]
public int ID_PREORDINE
{
get { return fID_PREORDINE; }
set { SetPropertyValue<int>("ID_PREORDINE", ref fID_PREORDINE, value); }
}

int fNUMPOS;
public int NUMPOS
{
get { return fNUMPOS; }
set { SetPropertyValue<int>("NUMPOS", ref fNUMPOS, value); }
}

String fCOD_CLIENTE;
[Size(6)]
public String COD_CLIENTE
{
get { return fCOD_CLIENTE; }
set { SetPropertyValue<String>("COD_CLIENTE", ref fCOD_CLIENTE, value); }
}

//…other properties here

// ctors
public Preordine(Session session) : base(session) { }
public Preordine() : base(Session.DefaultSession) { }
public override void AfterConstruction() { base.AfterConstruction(); }
}

here it is the class that clones the instances(from your kb)

public class CloneIXPSimpleObjectHelper
{
/// <summary>
/// A dictionary containing objects from the source session as key and objects from the
/// target session as values
/// </summary>
/// <returns></returns>
Dictionary<object, object> clonedObjects;
Session sourceSession;
Session targetSession;

/// <summary>
/// Initializes a new instance of the CloneIXPSimpleObjectHelper class.
/// </summary>
public CloneIXPSimpleObjectHelper(Session source, Session target)
{
this.clonedObjects = new Dictionary<object, object>();
this.sourceSession = source;
this.targetSession = target;
}

public T Clone<T>(T source) where T : IXPSimpleObject
{
return Clone<T>(source, targetSession, false);
}
public T Clone<T>(T source, bool synchronize) where T : IXPSimpleObject
{
return (T)Clone(source as IXPSimpleObject, targetSession, synchronize);
}

public object Clone(IXPSimpleObject source)
{
return Clone(source, targetSession, false);
}
public object Clone(IXPSimpleObject source, bool synchronize)
{
return Clone(source, targetSession, synchronize);
}

public T Clone<T>(T source, Session targetSession, bool synchronize) where T : IXPSimpleObject
{
return (T)Clone(source as IXPSimpleObject, targetSession, synchronize);
}

/// <summary>
/// Clones and / or synchronizes the given IXPSimpleObject.
/// </summary>
/// <param name="source"></param>
/// <param name="targetSession"></param>
/// <param name="synchronize">If set to true, reference properties are only cloned in case
/// the reference object does not exist in the targetsession. Otherwise the exising object will be
/// reused and synchronized with the source. Set this property to false when knowing at forehand
/// that the targetSession will not contain any of the objects of the source.</param>
/// <returns></returns>
public object Clone(IXPSimpleObject source, Session targetSession, bool synchronize)
{
if (source == null)
return null;
if (clonedObjects.ContainsKey(source))
return clonedObjects[source];
XPClassInfo targetClassInfo = targetSession.GetClassInfo(source.GetType());
object clone = null;
if (synchronize)
clone = targetSession.GetObjectByKey(targetClassInfo, source.Session.GetKeyValue(source));
if (clone == null)
clone = targetClassInfo.CreateNewObject(targetSession);
clonedObjects.Add(source, clone);

foreach (XPMemberInfo m in targetClassInfo.PersistentProperties)
{
if (m is DevExpress.Xpo.Metadata.Helpers.ServiceField || m.IsKey)
continue;
object val;
if (m.ReferenceType != null)
{
object createdByClone = m.GetValue(clone);
if ((createdByClone != null) && synchronize == false)
val = createdByClone;
else
{
val = Clone((IXPSimpleObject)m.GetValue(source), targetSession, synchronize);
}

}
else
{
val = m.GetValue(source);
}
m.SetValue(clone, val);
}
foreach (XPMemberInfo m in targetClassInfo.CollectionProperties)
{
if (m.HasAttribute(typeof(AggregatedAttribute)))
{
XPBaseCollection col = (XPBaseCollection)m.GetValue(clone);
XPBaseCollection colSource = (XPBaseCollection)m.GetValue(source);
foreach (IXPSimpleObject obj in new ArrayList(colSource))
col.BaseAdd(Clone(obj, targetSession, synchronize));
}
}
return clone;
}
}