SequenceHiLoGenerator.cs

usingSystem;
usingSystem.Collections;
usingSystem.Collections.Generic;
usingSystem.Runtime.CompilerServices;

usingNHibernate.Engine;
usingNHibernate.Type;
usingNHibernate.Util;

namespaceNHibernate.Id
{
/// <summary>
/// An <see cref="IIdentifierGenerator" /> that combines a hi/lo algorithm with an underlying
/// oracle-style sequence that generates hi values.
/// </summary>
/// <remarks>
/// <p>
/// This id generation strategy is specified in the mapping file as 
/// <code>
/// &lt;generator class="seqhilo"&gt;
/// &lt;param name="sequence"&gt;uid_sequence&lt;/param&gt;
/// &lt;param name="max_lo"&gt;max_lo_value&lt;/param&gt;
/// &lt;param name="schema"&gt;db_schema&lt;/param&gt;
/// &lt;/generator&gt;
/// </code>
/// </p>
/// <p>
/// The <c>sequence</c> parameter is required, the <c>max_lo</c> and <c>schema</c> are optional.
/// </p>
/// <p>
/// The user may specify a <c>max_lo</c> value to determine how often new hi values are
/// fetched. If sequences are not avaliable, <c>TableHiLoGenerator</c> might be an
/// alternative.
/// </p>
/// </remarks>
publicpartialclassSequenceHiLoGenerator:SequenceGenerator
{
privatestaticreadonlyINHibernateLoggerlog=NHibernateLogger.For(typeof(SequenceHiLoGenerator));

/// <summary>
/// The name of the maximum low value parameter.
/// </summary>
publicconststringMaxLo="max_lo";

privateintmaxLo;
privateintlo;
privatelonghi;
privateSystem.TypereturnClass;
privatereadonlyAsyncLock_asyncLock=newAsyncLock();

 #region IConfigurable Members

/// <summary>
/// Configures the SequenceHiLoGenerator by reading the value of <c>sequence</c>, <c>max_lo</c>, 
/// and <c>schema</c> from the <c>parms</c> parameter.
/// </summary>
/// <param name="type">The <see cref="IType"/> the identifier should be.</param>
/// <param name="parms">An <see cref="IDictionary"/> of Param values that are keyed by parameter name.</param>
/// <param name="dialect">The <see cref="Dialect.Dialect"/> to help with Configuration.</param>
publicoverridevoidConfigure(ITypetype,IDictionary<string,string>parms,Dialect.Dialectdialect)
{
base.Configure(type,parms,dialect);
maxLo=PropertiesHelper.GetInt32(MaxLo,parms,9);
lo=maxLo+1;// so we "clock over" on the first invocation
returnClass=type.ReturnedClass;
}

 #endregion

 #region IIdentifierGenerator Members

/// <summary>
/// Generate an <see cref="Int16"/>, <see cref="Int32"/>, or <see cref="Int64"/> 
/// for the identifier by using a database sequence.
/// </summary>
/// <param name="session">The <see cref="ISessionImplementor"/> this id is being generated in.</param>
/// <param name="obj">The entity for which the id is being generated.</param>
/// <returns>The new identifier as a <see cref="Int16"/>, <see cref="Int32"/>, or <see cref="Int64"/>.</returns>
publicoverrideobjectGenerate(ISessionImplementorsession,objectobj)
{
using(_asyncLock.Lock())
{
if(maxLo<1)
{
//keep the behavior consistent even for boundary usages
longval=Convert.ToInt64(base.Generate(session,obj));
if(val==0)
val=Convert.ToInt64(base.Generate(session,obj));
returnIdentifierGeneratorFactory.CreateNumber(val,returnClass);
}

if(lo>maxLo)
{
longhival=Convert.ToInt64(base.Generate(session,obj));
lo=(hival==0)?1:0;
hi=hival*(maxLo+1);
if(log.IsDebugEnabled())
log.Debug("new hi value: {0}",hival);
}
returnIdentifierGeneratorFactory.CreateNumber(hi+lo++,returnClass);
}
}

 #endregion
}
}