public DropTableWriter(ISqlDialect dialect) {
            if (dialect == null) {
                throw new ArgumentNullException("dialect");
            }

            this.dialect = dialect;
        }

        public static string ToSql(this DateTime value, ISqlDialect dialect = null)
        {
            if (value.Date == value)
                return value.ToString((dialect ?? SqlSettings.DefaultDialect).DateFormat, Invariants.DateTimeFormat);

            return value.ToString((dialect ?? SqlSettings.DefaultDialect).DateTimeFormat, Invariants.DateTimeFormat);
        }

 public DelimitedDbStatement(
     ISqlDialect dialect,
     TransactionScope scope,
     IDbConnection connection,
     IDbTransaction transaction)
     : base(dialect, scope, connection, transaction)
 {}

 public InheritedSqlPersistenceEngine(
     IConnectionFactory connectionFactory,
     ISqlDialect dialect,
     ISerialize serializer,
     TransactionScopeOption scopeOption, int pageSize) 
     : base(connectionFactory, dialect, serializer, scopeOption, pageSize)
 {}

 public string ToString(ISqlDialect dialect)
 {
     var sql = new StringBuilder();
     sql.AppendFormat("delete from {0}", table);
     if (where != Exp.Empty) sql.AppendFormat(" where {0}", where.ToString(dialect));
     return sql.ToString();
 }

        public static string ToSql(this string value, ISqlDialect dialect = null)
        {
            if (value == null)
                return Null;

            return (dialect ?? SqlSettings.DefaultDialect).QuoteUnicodeString(value);
        }

        public IEnumerable<IMap> ReverseEngineer(
            DatabaseSchema schema,
            ISqlDialect sqlDialect,
            IEnumerable<string> tablesToIgnore,
            IAnswerProvider answerProvider,
            bool fixOneToOnes) {
            if (tablesToIgnore == null) {
                tablesToIgnore = new string[0];
            }

            var maps = new List<IMap>();
            this.configuration = new Configuration(sqlDialect);
            foreach (var table in schema.Tables.Where(t => !tablesToIgnore.Contains(t.Name))) {
                maps.Add(this.MapTable(table));
            }

            // go back through and add indexes and foreign keys
            foreach (var map in maps) {
                GetIndexesAndForeignKeys(schema.Tables.First(t => t.Name == map.Table), map);
            }

            // go back through and try to spot one-to-one columns
            if (fixOneToOnes) {
                foreach (var map in maps) {
                    FindOneToOnes(map, answerProvider);
                }
            }

            return maps;
        }

 public override string ToString(ISqlDialect dialect)
 {
     return string.Format("{0} {1} {2}",
                          column1.ToString(dialect),
                          Not ? "<>" : "=",
                          column2.ToString(dialect));
 }

        public void Append(StringBuilder stringBuilder, ISqlDialect dialect) {
            if (this.Node != null) {
                stringBuilder.Append(this.Node.Alias).Append(".");
            }

            dialect.AppendQuotedName(stringBuilder, this.columnName);
        }

        public ICreateSessionFactory ForConnection(string connectionName, ISqlDialect sqlDialect, IDbDriver dbDriver)
        {
            if (connectionName == null)
            {
                throw new ArgumentNullException("connectionName");
            }

            if (sqlDialect == null)
            {
                throw new ArgumentNullException("sqlDialect");
            }

            if (dbDriver == null)
            {
                throw new ArgumentNullException("dbDriver");
            }

            var configSection = ConfigurationManager.ConnectionStrings[connectionName];

            if (configSection == null)
            {
                throw new ConfigurationException(ExceptionMessages.FluentConfiguration_ConnectionNotFound.FormatWith(connectionName));
            }

            this.chosenConnectionName = configSection.Name;
            this.chosenSqlDialect = sqlDialect;
            this.chosenDbDriver = dbDriver;
            this.chosenDbDriver.ConnectionString = configSection.ConnectionString;
            this.chosenDbDriver.DbProviderFactory = DbProviderFactories.GetFactory(configSection.ProviderName);

            return this;
        }

        public static string Dump(string sql, IDictionary<string, object> parameters, ISqlDialect dialect = null)
        {
            if (parameters == null)
                return sql;

            var param = parameters.ToList();
            for (var i = 0; i < param.Count; i++)
            {
                var name = param[i].Key;
                if (!name.StartsWith("@"))
                    param[i] = new KeyValuePair<string,object>("@" + name, param[i].Value);
            }

            param.Sort((x, y) => y.Key.Length.CompareTo(x.Key.Length));

            var sb = new StringBuilder(sql);
            foreach (var pair in param)
                sb.Replace(pair.Key, DumpParameterValue(pair.Value, dialect));

            var text = DatabaseCaretReferences.Replace(sb.ToString());

            dialect = dialect ?? SqlSettings.DefaultDialect;
            var openBracket = dialect.OpenQuote;
            if (openBracket != '[')
                text = BracketLocator.ReplaceBrackets(text, dialect);

            var paramPrefix = dialect.ParameterPrefix;
            if (paramPrefix != '@')
                text = ParamPrefixReplacer.Replace(text, paramPrefix);

            return text;
        }

        internal SessionFactory(string connectionName, IDbDriver dbDriver, ISqlDialect sqlDialect)
        {
            this.connectionName = connectionName;
            this.dbDriver = dbDriver;
            this.sqlDialect = sqlDialect;

            this.sessionListeners = new SessionListeners(Listener.DeleteListeners, Listener.InsertListener, Listener.UpdateListeners);
        }

 /// <summary>
 /// Creates a new DynamicSQLinqJoinExpression instance
 /// </summary>
 /// <param name="tableName">The database Table / View to Join</param>
 /// <param name="joinOperator">The JOIN operator</param>
 /// <param name="clause">The Join clause</param>
 /// <param name="parameters">Any parameter values necessary for the Join clause</param>
 public DynamicSQLinqJoinExpression(ISqlDialect dialect, string tableName, DynamicSQLinqJoinOperator joinOperator, string clause, object[] parameters)
 {
     this.Dialect = dialect;
     this.Table = tableName;
     this.JoinOperator = joinOperator;
     this.Clause = clause;
     this.Parameters = parameters;
 }

            public FirebirdDbStatement(
				ISqlDialect dialect,
				IDbConnection connection,
				IDbTransaction transaction,
				params IDisposable[] resources)
                : base(dialect, connection, transaction, resources)
            {
            }

 public CustomSqlPersistenceFactory(IConnectionFactory factory, ISerialize serializer, ISqlDialect dialect, TransactionScopeOption scopeOption, int pageSize) : base(factory, serializer, dialect, scopeOption, pageSize)
 {
     this.factory = factory;
     this.serializer = serializer;
     this.dialect = dialect;
     this.scopeOption = scopeOption;
     this.pageSize = pageSize;
 }

 /// <summary>
 /// Creates a new DynamicSQLinqSubQueryJoinExpression instance
 /// </summary>
 /// <param name="query">The sub-query that will be joined</param>
 /// <param name="alias">The Alias to give the sub-query within the main query</param>
 /// <param name="joinOperator">The JOIN operator</param>
 /// <param name="clause">The Join clause</param>
 /// <param name="parameters">Any parameters necessary for the Join clause</param>
 public DynamicSQLinqSubQueryJoinExpression(ISqlDialect dialect, ISQLinq query, string alias, DynamicSQLinqJoinOperator joinOperator, string clause, params object[] parameters)
 {
     this.Dialect = dialect;
     this.Query = query;
     this.Alias = alias;
     this.JoinOperator = joinOperator;
     this.Clause = clause;
     this.Parameters = parameters;
 }

        protected DrapperManager(ISqlGenerator generator, IDbConnection dbConnection, ISqlDialect dialect)
        {
            Dialect = dialect;
            Generator = generator;
            DbConnection = dbConnection;
            Database = new Database(dbConnection, generator);

            Init();
        }

 public override string ToString(ISqlDialect dialect)
 {
     string format = exp1 is JunctionExp && ((JunctionExp) exp1).and != and ? "({0})" : "{0}";
     format += " {1} ";
     format += exp2 is JunctionExp && ((JunctionExp) exp2).and != and ? "({2})" : "{2}";
     return Not
                ? string.Format(format, (!exp1).ToString(dialect), and ? "or" : "and",
                                (!exp2).ToString(dialect))
                : string.Format(format, exp1.ToString(dialect), and ? "and" : "or", exp2.ToString(dialect));
 }

 public static HashSetEx<string> InvokeGetKeywords(ISqlDialect dialect)
 {
     if (GetKeywords == null) return null;
     var args = new GetKeyboardsEventArgs
         {
             Dialect = dialect,
         };
     GetKeywords(args);
     return args.Keywords;
 }

 public AbsoluteOrderingSqlPersistenceEngine(IConnectionFactory connectionFactory, 
     ISqlDialect dialect, 
     IPipelineStoreSqlDialect pipelineStoreSqlDialect,
     ISerialize serializer, bool transactional)
     : base(connectionFactory, dialect, serializer)
 {
     _dialect = pipelineStoreSqlDialect;
     _transactional = transactional;
     _serializer = serializer;
 }