TableHiLoGenerator.cs

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

usingNHibernate.Engine;
usingNHibernate.Type;
usingNHibernate.Util;
usingSystem.Collections.Generic;

namespaceNHibernate.Id
{
/// <summary>
/// An <see cref="IIdentifierGenerator" /> that returns an <c>Int64</c>, constructed using
/// a hi/lo algorithm.
/// </summary>
/// <remarks>
/// <p>
/// This id generation strategy is specified in the mapping file as 
/// <code>
/// &lt;generator class="hilo"&gt;
/// &lt;param name="table"&gt;table&lt;/param&gt;
/// &lt;param name="column"&gt;id_column&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;param name="catalog"&gt;db_catalog&lt;/param&gt;
/// &lt;param name="where"&gt;arbitrary additional where clause&lt;/param&gt;
/// &lt;/generator&gt;
/// </code>
/// </p>
/// <p>
/// The <c>table</c> and <c>column</c> parameters are required, the <c>max_lo</c>,
/// <c>schema</c>, <c>catalog</c> and <c>where</c> are optional.
/// </p>
/// <p>
/// The hi value MUST be fecthed in a separate transaction to the <c>ISession</c>
/// transaction so the generator must be able to obtain a new connection and 
/// commit it. Hence this implementation may not be used when the user is supplying
/// connections. In that case a <see cref="SequenceHiLoGenerator"/> would be a 
/// better choice (where supported).
/// </p>
/// </remarks>
publicpartialclassTableHiLoGenerator:TableGenerator
{
privatestaticreadonlyINHibernateLoggerlog=NHibernateLogger.For(typeof(TableHiLoGenerator));

/// <summary>
/// The name of the max lo parameter.
/// </summary>
publicconststringMaxLo="max_lo";

privatelonghi;
privatelonglo;
privatelongmaxLo;
privateSystem.TypereturnClass;
privatereadonlyAsyncLock_asyncLock=newAsyncLock();

 #region IConfigurable Members

/// <summary>
/// Configures the TableHiLoGenerator by reading the value of <c>table</c>, 
/// <c>column</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.GetInt64(MaxLo,parms,Int16.MaxValue);
lo=maxLo+1;// so we "clock over" on the first invocation
returnClass=type.ReturnedClass;
}

 #endregion

 #region IIdentifierGenerator Members

/// <summary>
/// Generate a <see cref="Int64"/> for the identifier by selecting and updating a value in a table.
/// </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="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);
log.Debug("New high value: {0}",hival);
}

returnIdentifierGeneratorFactory.CreateNumber(hi+lo++,returnClass);
}
}

 #endregion
}
}