public CommandBuilder(string text, DatabaseSchema schema, int bulkIndex)
 {
     _text = new StringBuilder(text);
     _schemaProvider = schema.SchemaProvider;
     _customInterfaceProvider = schema.ProviderHelper;
     _parameterSuffix = (bulkIndex >= 0) ? "_c" + bulkIndex : string.Empty;
 }

 public OracleProcedureExecutor(OracleConnectionProvider connectionProvider, ObjectName procedureName)
 {
     _connectionProvider = connectionProvider;
     _schema = DatabaseSchema.Get(_connectionProvider, new ProviderHelper());
     _procedureName = procedureName;
     _executeImpl = ExecuteReader;
 }

 protected override void OnSetup()
 {
     var settingsKeys = ((IDictionary<string, object>) Settings).Keys;
     if (settingsKeys.Contains("ConnectionString"))
     {
         if (settingsKeys.Contains("ProviderName"))
         {
             _connectionProvider = ProviderHelper.GetProviderByConnectionString(Settings.ConnectionString,
                                                                                Settings.ProviderName);
         }
         else
         {
             _connectionProvider = ProviderHelper.GetProviderByConnectionString(Settings.ConnectionString);
         }
     }
     else if (settingsKeys.Contains("Filename"))
     {
         _connectionProvider = ProviderHelper.GetProviderByFilename(Settings.Filename);
     }
     else if (settingsKeys.Contains("ConnectionName"))
     {
         _connectionProvider = ProviderHelper.GetProviderByConnectionName(Settings.ConnectionName);
     }
     _schema = DatabaseSchema.Get(_connectionProvider, _providerHelper);
     _relatedFinder = new Lazy<AdoAdapterRelatedFinder>(CreateRelatedFinder);
     _commandOptimizer = ProviderHelper.GetCustomProvider<CommandOptimizer>(_connectionProvider) ??
                         new CommandOptimizer();
 }

 internal AdoAdapter(IConnectionProvider connectionProvider) : this()
 {
     _connectionProvider = connectionProvider;
     _schema = DatabaseSchema.Get(_connectionProvider, _providerHelper);
     _relatedFinder = new Lazy<AdoAdapterRelatedFinder>(CreateRelatedFinder);
     _commandOptimizer = ProviderHelper.GetCustomProvider<CommandOptimizer>(_connectionProvider) ??
                         new CommandOptimizer();
 }

 public CommandBuilder(string text, DatabaseSchema schema, IEnumerable<KeyValuePair<ParameterTemplate, Object>> parameters)
     : this(text, schema, -1)
 {
     foreach (var kvp in parameters)
     {
         _parameters.Add(kvp.Key, kvp.Value);
     }
 }

 public ExpressionFormatter(ICommandBuilder commandBuilder, DatabaseSchema schema)
 {
     _commandBuilder = commandBuilder;
     _schema = schema;
     _expressionFormatters = new Dictionary<SimpleExpressionType, Func<SimpleExpression, string>>
           {
               {SimpleExpressionType.And, LogicalExpressionToWhereClause},
               {SimpleExpressionType.Or, LogicalExpressionToWhereClause},
               {SimpleExpressionType.Equal, EqualExpressionToWhereClause},
               {SimpleExpressionType.NotEqual, NotEqualExpressionToWhereClause},
               {SimpleExpressionType.GreaterThan, expr => BinaryExpressionToWhereClause(expr, ">")},
               {SimpleExpressionType.GreaterThanOrEqual, expr => BinaryExpressionToWhereClause(expr, ">=")},
               {SimpleExpressionType.LessThan, expr => BinaryExpressionToWhereClause(expr, "<")},
               {SimpleExpressionType.LessThanOrEqual, expr => BinaryExpressionToWhereClause(expr, "<=")},
           };
 }

        private IEnumerable<IDbDataParameter> CreateParameters(DatabaseSchema schema, IDbCommand command, IEnumerable<object> parameterValues)
        {
            var fixedParameters = _parameters.Where(pt => pt.Type == ParameterType.FixedValue).ToArray();
            if ((!parameterValues.Any(pv => pv != null)) && fixedParameters.Length == 0) yield break;
            parameterValues = parameterValues.Where(pv => pv != null);

            foreach (var fixedParameter in fixedParameters)
            {
                yield return CreateParameter(command, fixedParameter, fixedParameter.FixedValue);
            }
            
            var columnParameters = _parameters.Where(pt => pt.Type != ParameterType.FixedValue).ToArray();

            foreach (var parameter in parameterValues.Any(o => o is IEnumerable && !(o is string)) || parameterValues.Any(o => o is IRange)
                       ? parameterValues.SelectMany((v, i) => CreateParameters(schema, command, columnParameters[i], v))
                       : parameterValues.Select((v, i) => CreateParameter(command, columnParameters[i], v)))
            {
                yield return parameter;
            }
        }

 public Joiner(JoinType joinType, DatabaseSchema schema)
 {
     if (schema == null) throw new ArgumentNullException("schema");
     _joinType = joinType;
     _schema = schema;
 }

 internal AdoAdapter(IConnectionProvider connectionProvider)
 {
     _connectionProvider = connectionProvider;
     _schema = DatabaseSchema.Get(_connectionProvider);
     _relatedFinder = new Lazy<AdoAdapterRelatedFinder>(CreateRelatedFinder);
 }

 public ExpressionFormatter(ICommandBuilder commandBuilder, DatabaseSchema schema)
 {
     _commandBuilder = commandBuilder;
     _schema = schema;
     _simpleReferenceFormatter = new SimpleReferenceFormatter(_schema, _commandBuilder);
 }

 public FindHelper(DatabaseSchema schema)
 {
     _schema = schema;
     _commandBuilder = new CommandBuilder(schema.SchemaProvider);
     _expressionFormatter = new ExpressionFormatter(_commandBuilder, _schema);
 }

 public GetHelper(DatabaseSchema schema)
 {
     _schema = schema;
     _commandBuilder = new CommandBuilder(schema);
 }

 public ExpressionFormatter(ICommandBuilder commandBuilder, DatabaseSchema schema)
 {
     _commandBuilder = commandBuilder;
     _schema = schema;
 }

 public DatabaseSchema GetSchema()
 {
     return _schema ?? (_schema = DatabaseSchema.Get(_connectionProvider, _providerHelper));
 }

 protected override void OnReset()
 {
     DatabaseSchema.ClearCache();
     _schema = DatabaseSchema.Get(_connectionProvider, _providerHelper);
 }

 public DeleteHelper(DatabaseSchema schema)
 {
     _schema = schema;
     _commandBuilder = new CommandBuilder();
     _expressionFormatter = new ExpressionFormatter(_commandBuilder, _schema);
 }

 public AdoAdapter(IConnectionProvider connectionProvider)
 {
     _connectionProvider = connectionProvider;
     _schema = DatabaseSchema.Get(_connectionProvider);
 }

 private static void RewriteSqlEqualityToInClause(DatabaseSchema schema, IDbCommand command, ParameterTemplate parameterTemplate, StringBuilder builder)
 {
     if (command.CommandText.Contains("!= " + parameterTemplate.Name))
     {
         command.CommandText = command.CommandText.Replace("!= " + parameterTemplate.Name,
                                                           schema.Operators.NotIn + " (" +
                                                           builder.ToString().Substring(1) +
                                                           ")");
     }
     else
     {
         command.CommandText = command.CommandText.Replace("= " + parameterTemplate.Name,
                                                           schema.Operators.In + " (" +
                                                           builder.ToString().Substring(1) +
                                                           ")");
     }
 }

 public QueryBuilder(AdoAdapter adoAdapter, int bulkIndex)
 {
     _adoAdapter = adoAdapter;
     _bulkIndex = bulkIndex;
     _schema = _adoAdapter.GetSchema();
     _commandBuilder = new CommandBuilder(_schema, _bulkIndex);
     _simpleReferenceFormatter = new SimpleReferenceFormatter(_schema, _commandBuilder);
 }

 protected QueryBuilderBase(AdoAdapter adapter, int bulkIndex, IFunctionNameConverter functionNameConverter)
 {
     _adoAdapter = adapter;
     _bulkIndex = bulkIndex;
     _schema = _adoAdapter.GetSchema();
     _commandBuilder = new CommandBuilder(_schema, _bulkIndex);
     _simpleReferenceFormatter = new SimpleReferenceFormatter(_schema, _commandBuilder, functionNameConverter);
 }