public IEnumerable<string> GenerateDataDefintionLanguage(Dialect dialect)
{
var formatter = new DdlFormatter();
foreach (var s in _versioningStrategy.EnsureDbObjectsStatements)
{
if (!String.IsNullOrWhiteSpace(s))
{
yield return formatter.Format(s).TrimEnd();
}
}
foreach (var m in _migrations)
{
foreach (var o in m.Operations)
{
foreach (var s in o.GetStatements(dialect))
{
if (!String.IsNullOrWhiteSpace(s))
{
yield return formatter.Format(s).TrimEnd();
}
}
}
var updateVersionStatements = _versioningStrategy.GetUpdateVersionStatements(m.Version, m.Context);
foreach (var s in updateVersionStatements)
{
if (!String.IsNullOrWhiteSpace(s))
{
yield return formatter.Format(s).TrimEnd();
}
}
}
}
/// <inheritdoc/>
public void Configure(IType type, IDictionary<string, string> parms, Dialect dialect)
{
if (!parms.TryGetValue(IdGenFunctionNameParam, out _idGenFunctionName))
_idGenFunctionName = DefaultIdGenFunctionName;
_targetTableName = parms[TargetTableNameParam];
_targetTableIdColumnName = parms[TargetTableIdColumnNameParam];
}
public override string SqlTriggerBody(
Dialect dialect, IMapping p,
string defaultCatalog, string defaultSchema)
{
var auditTableName = dialect.QuoteForTableName(_auditTableName);
var eDialect = (IExtendedDialect)dialect;
string triggerSource = _action == TriggerActions.DELETE ?
eDialect.GetTriggerOldDataAlias() :
eDialect.GetTriggerNewDataAlias();
var columns = new List<string>(_dataColumnNames);
columns.AddRange(from ac in _auditColumns
select ac.Name);
var values = new List<string>();
values.AddRange(
from columnName in _dataColumnNames
select eDialect.QualifyColumn(
triggerSource, columnName));
values.AddRange(
from auditColumn in _auditColumns
select auditColumn.ValueFunction.Invoke(_action));
return eDialect.GetInsertIntoString(auditTableName,
columns, triggerSource, values);
}
public SessionSource(FluentConfiguration config)
{
configuration = config.Configuration;
sessionFactory = config.BuildSessionFactory();
dialect = Dialect.GetDialect(configuration.Properties);
}
public override string SqlDropString(Dialect dialect,
string defaultCatalog, string defaultSchema)
{
FinalizeAuditTable((IExtendedDialect)dialect);
return auditTable.SqlDropString(dialect,
defaultCatalog, defaultSchema);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="config"></param>
protected Renderer(Configuration config)
{
_config = config;
_dialect = Dialect.GetDialect(config.Properties);
_defaultSchema = config.GetProperty(NHibernate.Cfg.Environment.DefaultSchema);
}
public override string SqlCreateString(Dialect dialect,
IMapping p, string defaultCatalog, string defaultSchema)
{
FinalizeAuditTable((IExtendedDialect) dialect);
return auditTable.SqlCreateString(
dialect, p, defaultCatalog, defaultSchema);
}
/// <summary>
/// Configures the TableGenerator by reading the value of <c>table</c>,
/// <c>column</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"/> to help with Configuration.</param>
public virtual void Configure(IType type, IDictionary<string, string> parms, Dialect.Dialect dialect)
{
tableName = PropertiesHelper.GetString(TableParamName, parms, DefaultTableName);
columnName = PropertiesHelper.GetString(ColumnParamName, parms, DefaultColumnName);
whereClause = PropertiesHelper.GetString(Where, parms, "");
string schemaName = PropertiesHelper.GetString(PersistentIdGeneratorParmsNames.Schema, parms, null);
string catalogName = PropertiesHelper.GetString(PersistentIdGeneratorParmsNames.Catalog, parms, null);
if (tableName.IndexOf('.') < 0)
{
tableName = dialect.Qualify(catalogName, schemaName, tableName);
}
var selectBuilder = new SqlStringBuilder(100);
selectBuilder.Add("select " + columnName)
.Add(" from " + dialect.AppendLockHint(LockMode.Upgrade, tableName));
if (string.IsNullOrEmpty(whereClause) == false)
{
selectBuilder.Add(" where ").Add(whereClause);
}
selectBuilder.Add(dialect.ForUpdateString);
query = selectBuilder.ToString();
columnType = type as PrimitiveType;
if (columnType == null)
{
log.Error("Column type for TableGenerator is not a value type");
throw new ArgumentException("type is not a ValueTypeType", "type");
}
// build the sql string for the Update since it uses parameters
if (type is Int16Type)
{
columnSqlType = SqlTypeFactory.Int16;
}
else if (type is Int64Type)
{
columnSqlType = SqlTypeFactory.Int64;
}
else
{
columnSqlType = SqlTypeFactory.Int32;
}
parameterTypes = new[] {columnSqlType, columnSqlType};
var builder = new SqlStringBuilder(100);
builder.Add("update " + tableName + " set ")
.Add(columnName).Add(" = ").Add(Parameter.Placeholder)
.Add(" where ")
.Add(columnName).Add(" = ").Add(Parameter.Placeholder);
if (string.IsNullOrEmpty(whereClause) == false)
{
builder.Add(" and ").Add(whereClause);
}
updateSql = builder.ToSqlString();
}
public static string GetSqlType(this Column column, Dialect dialect)
{
if (!String.IsNullOrWhiteSpace(column.SqlType))
{
return column.SqlType;
}
return dialect.GetTypeName(column.SqlTypeCode);
}
/// <summary>
/// Configures the specified type.
/// </summary>
/// <param name="type">The type to configure.</param>
/// <param name="parms">The parameters.</param>
/// <param name="dialect">The dialect.</param>
public override void Configure( IType type, IDictionary<string, string> parms, Dialect dialect )
{
parms[TableParamName] = "HiValue";
parms[ColumnParamName] = "HiValueKey";
parms[MaxLo] = "1000";
parms["schema"] = "CommonModule";
base.Configure ( type, parms, dialect );
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="column"></param>
/// <param name="config"></param>
/// <param name="dialect"></param>
internal ColumnInfo(Column column, Configuration config, Dialect dialect)
{
_name = column.Name;
_nullable = column.IsNullable;
_sqlType = column.GetSqlType(dialect, new Mapping(config));
//as of NH2.0, the length column seems to be set at 255 for non-string-like columns, which makes no sense
//therefore ignore NH length for non-string like columns, and use -1 which corresponds to the pre-2.0 behaviour
_length = (this.SqlType.IndexOf("char", System.StringComparison.InvariantCultureIgnoreCase) > -1) ? column.Length : -1;
}
protected override bool AppliesTo(Dialect.Dialect dialect)
{
if (dialect is MySQLDialect)
return false;
if (dialect is InformixDialect)
return false;
if (dialect is SQLiteDialect)
return false;
return true;
}
protected void Initialize(Configuration nhibernateConfig, PersistenceModel model)
{
if( model == null ) throw new ArgumentNullException("model", "Model cannot be null");
Configuration = nhibernateConfig;
model.Configure(Configuration);
SessionFactory = Configuration.BuildSessionFactory();
dialect = Dialect.GetDialect(Configuration.Properties);
}
/// <summary>
/// Configures the TableGenerator by reading the value of <c>table</c>,
/// <c>column</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"/> to help with Configuration.</param>
public virtual void Configure(IType type, IDictionary parms, Dialect.Dialect dialect)
{
tableName = PropertiesHelper.GetString(Table, parms, "hibernate_unique_key");
columnName = PropertiesHelper.GetString(Column, parms, "next_hi");
string schemaName = (string) parms[Schema];
if (schemaName != null && tableName.IndexOf(StringHelper.Dot) < 0)
{
tableName = schemaName + "." + tableName;
}
query =
"select " +
columnName +
" from " +
dialect.AppendLockHint(LockMode.Upgrade, tableName) +
dialect.ForUpdateString;
columnType = type as ValueTypeType;
if (columnType == null)
{
log.Error("Column type for TableGenerator is not a value type");
throw new ArgumentException("type is not a ValueTypeType", "type");
}
// build the sql string for the Update since it uses parameters
if (type is Int16Type)
{
columnSqlType = SqlTypeFactory.Int16;
}
else if (type is Int64Type)
{
columnSqlType = SqlTypeFactory.Int64;
}
else
{
columnSqlType = SqlTypeFactory.Int32;
}
parameterTypes = new SqlType[2] {columnSqlType, columnSqlType};
SqlStringBuilder builder = new SqlStringBuilder();
builder.Add("update " + tableName + " set ")
.Add(columnName)
.Add(" = ")
.Add(Parameter.Placeholder)
.Add(" where ")
.Add(columnName)
.Add(" = ")
.Add(Parameter.Placeholder);
updateSql = builder.ToSqlString();
}
public override string SqlCreateString(Dialect dialect, IMapping p, string defaultCatalog, string defaultSchema)
{
IExtendedDialect eDialect = (IExtendedDialect) dialect;
var buf = new StringBuilder();
buf.AppendLine(eDialect.GetCreateTriggerHeaderString(
_triggerName, _tableName, _action));
buf.AppendLine(SqlTriggerBody(dialect, p, defaultCatalog, defaultSchema));
buf.AppendLine(eDialect.GetCreateTriggerFooterString(
_triggerName, _tableName, _action));
return buf.ToString();
}
public void ExecuteMigrationScript(Dialect dialect, TextWriter log = null)
{
log = log ?? new StringWriter();
using (var s = _sessionFactory.OpenStatelessSession())
{
var conn = s.Connection;
foreach (var statement in GenerateDataDefintionLanguage(dialect))
{
log.WriteLine(statement);
using (var cmd = conn.CreateCommand())
{
cmd.CommandText = statement;
cmd.CommandType = CommandType.Text;
}
}
}
}
protected override bool AppliesTo(Dialect.Dialect dialect)
{
// It seems that SQLite has a nasty bug with coalesce
// Following query does not work
// SELECT order0_.*
// FROM Orders order0_
// WHERE coalesce(order0_.Freight, 0) > @p0;
// And this one works
// SELECT order0_.*
// FROM Orders order0_
// WHERE cast(coalesce(order0_.Freight, 0) as NUMERIC) > @p0;
if (dialect is SQLiteDialect)
return false;
return base.AppliesTo(dialect);
}
protected override bool AppliesTo(Dialect.Dialect dialect)
{
var typeNames = (TypeNames)typeof(Dialect.Dialect).GetField("_typeNames", ReflectHelper.AnyVisibilityInstance).GetValue(Dialect);
try
{
var value = AppliesTo();
if (value == null) return true;
typeNames.Get(value.Value);
}
catch (ArgumentException)
{
return false;
}
catch (Exception)
{
Assert.Fail("Probably a bug in the test case.");
}
return true;
}
/// <summary>
/// This is the real core function that build the fragment of sql needed
/// to build the criteria
/// </summary>
/// <param name="criteria"></param>
/// <param name="criteriaQuery"></param>
/// <param name="context"></param>
/// <returns></returns>
public override NHibernate.SqlCommand.SqlString ToSqlString(
NHibernate.ICriteria criteria,
NHibernate.Expressions.ICriteriaQuery criteriaQuery,
IDictionary <string, IFilter> enabledFilters)
{
//retrieve with projection the real name of the property.
String[] PropertyColumn = criteriaQuery.GetColumnsUsingProjection(
criteria, (String)mSqlFunctionParameter[mPropertyNamePosition]);
NHibernate.Dialect.Dialect dialect = criteriaQuery.Factory.Dialect;
mSqlFunctionParameter[mPropertyNamePosition] = PropertyColumn[0];
if (!dialect.Functions.ContainsKey(mFunction))
{
//throw new ApplicationException("Current dialect does not support " + mFunction + " function");
//Todo for now try to set the function but without the dialect.
return(CreateQueryString(
BuildUnknownExpression(mFunction, mSqlFunctionParameter)));
}
ISQLFunction func = (ISQLFunction)dialect.Functions[mFunction];
String functionResolved = func.Render(mSqlFunctionParameter, criteriaQuery.Factory);
//Now we have the cast operation required.
return(CreateQueryString(functionResolved));
}
protected override bool AppliesTo(Dialect.Dialect dialect)
{
return appliesToThisDialect;
}
protected override bool AppliesTo(Dialect.Dialect dialect)
{
return dialect as MsSql2008Dialect != null;
}
protected virtual bool AppliesTo(Dialect.Dialect dialect)
{
return true;
}
protected override bool AppliesTo(NHibernate.Dialect.Dialect dialect)
{
// Specific to MsSql2000Dialect. Does not apply to MsSql2005Dialect
return(dialect.GetType().Equals(typeof(MsSql2000Dialect)));
}
protected override bool AppliesTo(NHibernate.Dialect.Dialect dialect)
{
return(dialect as MsSql2005Dialect != null);
}
protected override bool AppliesTo(Dialect.Dialect dialect)
{
var cp = ConnectionProviderFactory.NewConnectionProvider(cfg.Properties);
return !cp.Driver.SupportsMultipleQueries;
}
public SqliteDataBaseMetaData(
DbConnection connection,
NHibernate.Dialect.Dialect dialect
) : base(connection, dialect)
{
}
/// <summary>
/// The SQL required to remove the underlying database objects for a TableGenerator.
/// </summary>
/// <param name="dialect">The <see cref="Dialect"/> to help with creating the sql.</param>
/// <returns>
/// A <see cref="string"/> that will drop the database objects for the TableGenerator.
/// </returns>
public virtual string[] SqlDropString(Dialect.Dialect dialect)
{
return new[] {dialect.GetDropTableString(tableName)};
}
protected override bool AppliesTo(Dialect.Dialect dialect)
{
return (dialect is MsSql2005Dialect);
}
protected override bool AppliesTo(NHibernate.Dialect.Dialect dialect)
{
return(dialect is NHibernate.Dialect.MsSql2008Dialect || dialect is NHibernate.Dialect.MsSql2005Dialect);
}
protected override bool AppliesTo(NHibernate.Dialect.Dialect dialect)
{
return(dialect is MsSql2000Dialect);
}
/// <summary>
/// The SQL required to create the database objects for a TableGenerator.
/// </summary>
/// <param name="dialect">The <see cref="Dialect"/> to help with creating the sql.</param>
/// <returns>
/// An array of <see cref="String"/> objects that contain the Dialect specific sql to
/// create the necessary database objects and to create the first value as <c>1</c>
/// for the TableGenerator.
/// </returns>
public string[] SqlCreateStrings(Dialect.Dialect dialect)
{
// changed the first value to be "1" by default since an uninitialized Int32 is 0 - leaving
// it at 0 would cause problems with an unsaved-value="0" which is what most people are
// defaulting <id>'s with Int32 types at.
return new string[]
{
"create table " + tableName + " ( " + columnName + " " + dialect.GetTypeName(columnSqlType) + " )",
"insert into " + tableName + " values ( 1 )"
};
}
protected override bool AppliesTo(Dialect.Dialect dialect)
{
return !(dialect is Oracle8iDialect);
}
protected override bool AppliesTo(Dialect.Dialect dialect)
{
return _OrignalDialectIsMsSql2005Dialect;
}
protected override bool AppliesTo(NHibernate.Dialect.Dialect dialect)
{
return(dialect as SQLiteDialect != null);
}
/// <summary>
/// The SQL required to remove the underlying database objects for a TableGenerator.
/// </summary>
/// <param name="dialect">The <see cref="Dialect"/> to help with creating the sql.</param>
/// <returns>
/// A <see cref="String"/> that will drop the database objects for the TableGenerator.
/// </returns>
public string SqlDropString(Dialect.Dialect dialect)
{
return dialect.GetDropTableString(tableName);
}
//private readonly Table _table;
//private readonly Column _column;
//public DropColumnOperation(Table table, Column column)
//{
// _table = table;
// _column = column;
//}
//public IEnumerable<string> GetStatements(IMigrationContext context)
//{
// var dialect = context.Dialect;
// var defaultSchema = context.DefaultSchema;
// var defaultCatalog = context.DefaultCatalog;
// if (!dialect.SupportsDropColumn)
// {
// throw new NotSupportedException(String.Format("{0} does not support dropping columns", dialect.GetType().Name));
// }
// var tableName = _table.GetQualifiedName(dialect, defaultCatalog, defaultSchema);
// var sb = new StringBuilder();
// sb.Append("alter table ")
// .Append(tableName)
// .Append(" ")
// .Append(dialect.DropColumnString)
// .Append(" ")
// .Append(_column.GetQuotedName(dialect));
// return new[]{sb.ToString()};
//}
public IEnumerable<string> GetStatements(Dialect dialect)
{
throw new System.NotImplementedException();
}
protected override bool AppliesTo(Dialect.Dialect dialect)
{
return dialect is MsSql2008Dialect;
}
protected override bool AppliesTo(NHibernate.Dialect.Dialect dialect)
{
var cp = ConnectionProviderFactory.NewConnectionProvider(cfg.Properties);
return(!cp.Driver.SupportsMultipleQueries);
}
/// <summary>
/// Generates an IDbDataParameter for the IDbCommand. It does not add the IDbDataParameter to the IDbCommand's
/// Parameter collection.
/// </summary>
/// <param name="command">The IDbCommand to use to create the IDbDataParameter.</param>
/// <param name="name">The name to set for IDbDataParameter.Name</param>
/// <param name="parameter">The Parameter to convert to an IDbDataParameter.</param>
/// <param name="dialect">The Dialect to use for Default lengths if needed.</param>
/// <returns>An IDbDataParameter ready to be added to an IDbCommand.</returns>
/// <remarks>
/// This adds logic to ensure that a DbType.Boolean parameter is not created since
/// ODP.NET doesn't support it.
/// </remarks>
protected override System.Data.IDbDataParameter GenerateParameter(IDbCommand command, string name, Parameter parameter, NHibernate.Dialect.Dialect dialect)
{
// if the parameter coming in contains a boolean then we need to convert it
// to another type since ODP.NET doesn't support DbType.Boolean
if (parameter.SqlType.DbType == DbType.Boolean)
{
parameter = new Parameter(parameter.Name, NHibernateUtil.Int16.SqlType);
}
return(base.GenerateParameter(command, name, parameter, dialect));
}
protected override bool AppliesTo(NHibernate.Dialect.Dialect dialect)
{
return((dialect is Dialect.SQLiteDialect) || (dialect is Dialect.MsSql2008Dialect));
}