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 SqlDropString(Dialect dialect,
     string defaultCatalog, string defaultSchema)
 {
     FinalizeAuditTable((IExtendedDialect)dialect);
       return auditTable.SqlDropString(dialect,
     defaultCatalog, defaultSchema);
 }

        public SessionSource(FluentConfiguration config)
        {
            configuration = config.Configuration;

            sessionFactory = config.BuildSessionFactory();
            dialect = Dialect.GetDialect(configuration.Properties);
        }

		/// <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);
 }

        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);
        }

		/// <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 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);
        }

		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;
		}

		/// <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>
 /// 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);
 }

 /// <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 )"
         };
 }