/// <summary>
		/// Get the SQL string to drop this Constraint in the database.
		/// </summary>
		/// <param name="dialect">The <see cref="Dialect.Dialect"/> to use for SQL rules.</param>
		/// <param name="defaultCatalog"></param>
		/// <param name="defaultSchema"></param>
		/// <returns>
		/// A string that contains the SQL to drop this Constraint.
		/// </returns>
		public override string SqlDropString(Dialect.Dialect dialect, string defaultCatalog, string defaultSchema)
		{
			string ifExists = dialect.GetIfExistsDropConstraint(Table, Name);
			string drop = string.Format("alter table {0}{1}", Table.GetQualifiedName(dialect, defaultCatalog, defaultSchema), dialect.GetDropPrimaryKeyConstraintString(Name));
			string end = dialect.GetIfExistsDropConstraintEnd(Table, Name);
			return ifExists + Environment.NewLine + drop + Environment.NewLine + end;
		}

		public static string BuildSqlDropIndexString(Dialect.Dialect dialect, Table table, string name, string defaultCatalog, string defaultSchema)
		{
			string ifExists = dialect.GetIfExistsDropConstraint(table, name);
			string drop = string.Format("drop index {0}", StringHelper.Qualify(table.GetQualifiedName(dialect, defaultCatalog, defaultSchema), name));
			string end = dialect.GetIfExistsDropConstraintEnd(table, name);
			return ifExists + Environment.NewLine + drop + Environment.NewLine + end;
		}

		/// <summary> Build a SQLExceptionConverter instance. </summary>
		/// <param name="dialect">The defined dialect. </param>
		/// <param name="properties">The configuration properties. </param>
		/// <returns> An appropriate <see cref="ISQLExceptionConverter"/> instance. </returns>
		/// <remarks>
		/// First, looks for a <see cref="Cfg.Environment.SqlExceptionConverter"/> property to see
		/// if the configuration specified the class of a specific converter to use.  If this
		/// property is set, attempt to construct an instance of that class.  If not set, or
		/// if construction fails, the converter specific to the dialect will be used.
		/// </remarks>
		public static ISQLExceptionConverter BuildSQLExceptionConverter(Dialect.Dialect dialect, IDictionary<string, string> properties)
		{
			ISQLExceptionConverter converter = null;

			string converterClassName;
			properties.TryGetValue(Cfg.Environment.SqlExceptionConverter, out converterClassName);
			if (!string.IsNullOrEmpty(converterClassName))
			{
				converter = ConstructConverter(converterClassName, dialect.ViolatedConstraintNameExtracter);
			}

			if (converter == null)
			{
				log.Info("Using dialect defined converter");
				converter = dialect.BuildSQLExceptionConverter();
			}

			IConfigurable confConv = converter as IConfigurable;
			if (confConv != null)
			{
				try
				{
					confConv.Configure(properties);
				}
				catch (HibernateException e)
				{
					log.Warn("Unable to configure SQLExceptionConverter", e);
					throw;
				}
			}

			return converter;
		}

		public DatabaseMetadata(DbConnection connection, Dialect.Dialect dialect, bool extras)
		{
			schemaReader = new InformationSchemaReader(connection);
			this.extras = extras;
			InitSequences(connection, dialect);
			sqlExceptionConverter = dialect.BuildSQLExceptionConverter();
		}

 public MappingRootBinder(Mappings mappings, XmlNamespaceManager namespaceManager,
     Dialect.Dialect dialect)
     : base(mappings)
 {
     this.namespaceManager = namespaceManager;
     this.dialect = dialect;
 }

 public OracleManagedDriverTransformationProvider(Dialect dialect, string connectionString, string defaultSchema)
     : base(dialect, connectionString, defaultSchema)
 {
     _connection = new OracleConnection();
     _connection.ConnectionString = _connectionString;
     _connection.Open();
 }

		public SelectBuilder(Dialect dialect, string[] tables, string[] columns) {
			_dialect = dialect;
			_tables = tables;
			_columns = columns;

			Parameters = new In[0];
		}

		public static string ParseToString(object o, Dialect.DbDialect dd)
		{
            if (o == null)
            {
                return "NULL";
            }
			var ot = o.GetType();
			if ( typeof(bool) == ot )
			{
				return Convert.ToInt32(o).ToString();
			}
		    if	( typeof(string) == ot )
		    {
		        string s = o.ToString();
		        s = s.Replace("'", "''");
		        return string.Format("N'{0}'", s);
		    }
		    if ( typeof(DateTime) == ot || typeof(Date) == ot || typeof(Time) == ot )
		    {
		        return dd.QuoteDateTimeValue(o.ToString());
		    }
		    if (ot.IsEnum)
		    {
		        return Convert.ToInt32(o).ToString();
		    }
		    if (typeof(byte[]) == ot)
		    {
		        throw new ApplicationException("Sql without Parameter can not support blob, please using Parameter mode.");
		    }
            return o.ToString();
        }

 public MySqlTransformationProvider(Dialect dialect, string connectionString)
     : base(dialect, connectionString)
 {
     connection = new MySqlConnection(base.connectionString);
     connection.ConnectionString = base.connectionString;
     connection.Open();
 }

		public override string SqlCreateString(
			Dialect.Dialect dialect,
			IMapping p,
			string defaultSchema)
		{
			return InjectCatalogAndSchema(sqlCreateString, defaultSchema);
		}

 public PostgreSQLTransformationProvider(Dialect dialect, string connectionString)
     : base(dialect, connectionString)
 {
     connection = new NpgsqlConnection();
     connection.ConnectionString = connectionString;
     connection.Open();
 }

		/// <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.Dialect"/> to help with Configuration.</param>
		public virtual void Configure( IType type, IDictionary parms, Dialect.Dialect dialect )
		{
			this.tableName = PropertiesHelper.GetString( Table, parms, "hibernate_unique_key" );
			this.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 " + tableName;
			if( dialect.SupportsForUpdate )
			{
				query += " for update";
			}

			// build the sql string for the Update since it uses parameters
			Parameter setParam = new Parameter( columnName, new Int32SqlType() );
			Parameter whereParam = new Parameter( columnName, new Int32SqlType() );

			SqlStringBuilder builder = new SqlStringBuilder();
			builder.Add( "update " + tableName + " set " )
				.Add( columnName )
				.Add( " = " )
				.Add( setParam )
				.Add( " where " )
				.Add( columnName )
				.Add( " = " )
				.Add( whereParam );

			updateSql = builder.ToSqlString();

		}

		protected override bool AppliesTo(Dialect.Dialect dialect)
		{
			return !(dialect is Dialect.Oracle8iDialect);
			// Oracle sometimes causes: ORA-12520: TNS:listener could not find available handler for requested type of server
			// Following links bizarrely suggest it's an Oracle limitation under load:
			// http://www.orafaq.com/forum/t/60019/2/ & http://www.ispirer.com/wiki/sqlways/troubleshooting-guide/oracle/import/tns_listener
		}

		/// <summary>
		/// Gets the schema qualified name of the Table using the specified qualifier
		/// </summary>
		/// <param name="dialect">The <see cref="Dialect.Dialect"/> that knows how to Quote the Table name.</param>
		/// <param name="defaultQualifier">The Qualifier to use when accessing the table.</param>
		/// <returns>A String representing the Qualified name.</returns>
		/// <remarks>If this were used with MSSQL it would return a dbo.table_name.</remarks>
		public string GetQualifiedName( Dialect.Dialect dialect, string defaultQualifier )
		{
			string quotedName = GetQuotedName( dialect );
			return schema == null ?
				( ( defaultQualifier == null ) ? quotedName : defaultQualifier + StringHelper.Dot + quotedName ) :
				GetQualifiedName( dialect );
		}

		protected TransformationProvider(Dialect dialect, string connectionString, string schemaName)
		{
			_dialect = dialect;
			_connectionString = connectionString;
		    _schemaName = schemaName;
		    _logger = new Logger(false);
		}

 public OracleTransformationProvider(Dialect dialect, string connectionString)
     : base(dialect, connectionString)
 {
     connection = new OracleConnection();
     connection.ConnectionString = base.connectionString;
     connection.Open();
 }

		/// <summary>
		///
		/// </summary>
		/// <param name="type"></param>
		/// <param name="parms"></param>
		/// <param name="d"></param>
		public void Configure(IType type, IDictionary<string, string> parms, Dialect.Dialect d)
		{
			string tableList;
			string column;
			string schema;
			string catalog;

			if (!parms.TryGetValue("tables", out tableList))
				parms.TryGetValue(PersistentIdGeneratorParmsNames.Tables, out tableList);
			string[] tables = StringHelper.Split(", ", tableList);
			if (!parms.TryGetValue("column", out column))
				parms.TryGetValue(PersistentIdGeneratorParmsNames.PK, out column);
			returnClass = type.ReturnedClass;
			parms.TryGetValue(PersistentIdGeneratorParmsNames.Schema, out schema);
			parms.TryGetValue(PersistentIdGeneratorParmsNames.Catalog, out catalog);

			StringBuilder buf = new StringBuilder();
			for (int i = 0; i < tables.Length; i++)
			{
				if (tables.Length > 1)
				{
					buf.Append("select ").Append(column).Append(" from ");
				}
				buf.Append(Table.Qualify(catalog, schema, tables[i]));
				if (i < tables.Length - 1)
					buf.Append(" union ");
			}
			if (tables.Length > 1)
			{
				buf.Insert(0, "( ").Append(" ) ids_");
				column = "ids_." + column;
			}

			sql = "select max(" + column + ") from " + buf;
		}

		/// <summary>
		/// Generates the SQL string to create the named Foreign Key Constraint in the database.
		/// </summary>
		/// <param name="d">The <see cref="Dialect.Dialect"/> to use for SQL rules.</param>
		/// <param name="constraintName">The name to use as the identifier of the constraint in the database.</param>
		/// <param name="defaultSchema"></param>
		/// <param name="defaultCatalog"></param>
		/// <returns>
		/// A string that contains the SQL to create the named Foreign Key Constraint.
		/// </returns>
		public override string SqlConstraintString(Dialect.Dialect d, string constraintName, string defaultCatalog, string defaultSchema)
		{
			string[] cols = new string[ColumnSpan];
			string[] refcols = new string[ColumnSpan];
			int i = 0;
			IEnumerable<Column> refiter;
			if (IsReferenceToPrimaryKey)
				refiter = referencedTable.PrimaryKey.ColumnIterator;
			else
				refiter = referencedColumns;
			foreach (Column column in ColumnIterator)
			{
				cols[i] = column.GetQuotedName(d);
				i++;
			}

			i = 0;
			foreach (Column column in refiter)
			{
				refcols[i] = column.GetQuotedName(d);
				i++;
			}
			string result = d.GetAddForeignKeyConstraintString(constraintName, cols, referencedTable.GetQualifiedName(d, defaultCatalog, defaultSchema), refcols, IsReferenceToPrimaryKey);
			return cascadeDeleteEnabled && d.SupportsCascadeDelete ? result + " on delete cascade" : result;
		}

		/// <summary>
		/// Configures the SequenceGenerator by reading the value of <c>sequence</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>
		public virtual void Configure(IType type, IDictionary<string, string> parms, Dialect.Dialect dialect)
		{
			var nativeSequenceName = PropertiesHelper.GetString(Sequence, parms, "hibernate_sequence");
			bool needQuote = StringHelper.IsBackticksEnclosed(nativeSequenceName);
			bool isQuelified = nativeSequenceName.IndexOf('.') > 0;
			if (isQuelified)
			{
				string qualifier = StringHelper.Qualifier(nativeSequenceName);
				nativeSequenceName = StringHelper.Unqualify(nativeSequenceName);
				nativeSequenceName = StringHelper.PurgeBackticksEnclosing(nativeSequenceName);
				sequenceName = qualifier + '.' + (needQuote ? dialect.QuoteForTableName(nativeSequenceName) : nativeSequenceName);
			}
			else
			{
				nativeSequenceName = StringHelper.PurgeBackticksEnclosing(nativeSequenceName);
				sequenceName = needQuote ? dialect.QuoteForTableName(nativeSequenceName) : nativeSequenceName;
			}
			string schemaName;
			string catalogName;
			parms.TryGetValue(Parameters, out parameters);
			parms.TryGetValue(PersistentIdGeneratorParmsNames.Schema, out schemaName);
			parms.TryGetValue(PersistentIdGeneratorParmsNames.Catalog, out catalogName);

			if (!isQuelified)
			{
				sequenceName = dialect.Qualify(catalogName, schemaName, sequenceName);
			}

			identifierType = type;
			sql = new SqlString(dialect.GetSequenceNextValString(sequenceName));
		}

		/// <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>
		public override void Configure(IType type, IDictionary<string, string> parms, Dialect.Dialect dialect)
		{
			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;
		}