public TwitterModule(IDbProvider dbProvider)
        {
            Get["/{slug}"] = p =>
                {
                    var mvp = dbProvider.GetDb()
                        .mvps.FindAllBySlug(p["slug"])
                        .WithLinks()
                        .FirstOrDefault()
                        ;

                    if (mvp == null)
                    {
                        return HttpStatusCode.NotFound;
                    }

                    TwitterJson model = TwitterJson.ParseSingle(mvp);

                    return Response.AsJson(model);
                };

            Get["/"] = _ =>
                {
                    var mvps = dbProvider.GetDb().mvps.WithLinks();

                    TwitterJson model = TwitterJson.ParseList(mvps);

                    return Response.AsJson(model);
                };
        }

 public PagedQueryBuilder(TableInfo info,IDbProvider provider)
 {
    
     _info = info;
     _provider = provider;
 
 }

		public IDbContext ConnectionString(string connectionString, IDbProvider fluentDataProvider, string providerName = null)
		{
			if(string.IsNullOrEmpty(providerName))
				providerName = fluentDataProvider.ProviderName;
			var adoNetProvider = System.Data.Common.DbProviderFactories.GetFactory(providerName);
			return ConnectionString(connectionString, fluentDataProvider, adoNetProvider);
		}

        /// <summary>
        /// Initializes a new instance of a DatabaseSchema.
        /// </summary>
        /// <param name="dbprovider"></param>
        public DatabaseSchema(IDbProvider dbprovider)
        {
            if (dbprovider == null)
                throw new ArgumentNullException("dbprovider");

            _dbprovider = dbprovider;
        }

        public void SetUpMocks()
        {
            provider = MockRepository.GenerateMock<IDbProvider>();
            IDbConnection connection = MockRepository.GenerateMock<IDbConnection>();

            provider.Stub(x => x.CreateConnection()).Return(connection).Repeat.Once();

            // Creating a query (setting DbProvider property)
            // will call new DbParameters(IDbProvider), which is a real pain to mock.
            // to store the declared parameters.

            command = MockRepository.GenerateMock<IDbCommand>();
            //This IDbCommand is used as a container for the underlying parameter collection.	
            provider.Stub(x => x.CreateCommand()).Return(command).Repeat.Once();

            //Create a real instance of IDbParameters to stored the declared parameters
            IDbProvider realDbProvider = DbProviderFactory.GetDbProvider("System.Data.SqlClient");
            IDbParameters dbParameters = new DbParameters(realDbProvider);

            //Pass real instance into mock instance.
            command.Stub(x => x.Parameters).Return(dbParameters.DataParameterCollection).Repeat.Once();
            provider.Stub(x => x.CreateCommand()).Return(command).Repeat.Once();

            // done with init of DbParameters mock/stubbing
        }

		public string GenerateSql(IDbProvider provider, string parameterPrefix, BuilderData data)
		{
			var setSql = "";
			foreach (var column in data.Columns)
			{
				if (setSql.Length > 0)
					setSql += ", ";

				setSql += string.Format("{0} = {1}{2}",
									provider.EscapeColumnName(column.ColumnName),
									parameterPrefix,
									column.ParameterName);
			}

			var whereSql = "";
			foreach (var column in data.Where)
			{
				if (whereSql.Length > 0)
					whereSql += " and ";

				whereSql += string.Format("{0} = {1}{2}",
									provider.EscapeColumnName(column.ColumnName),
									parameterPrefix,
									column.ParameterName);
			}

			var sql = string.Format("update {0} set {1} where {2}",
										data.ObjectName,
										setSql,
										whereSql);
			return sql;
		}

 /// <summary>
 /// Serializes the specified <see cref="IDbProvider"/> into an <see cred="IConfiguration" /> node.
 /// </summary>
 public static IConfiguration Serialize(IDbProvider dbProvider)
 {
     IConfiguration providerConfig = new MutableConfiguration("provider", dbProvider.Id, dbProvider.Id);
     providerConfig.Attributes[DataConstants.ATTRIBUTE_NAME] = dbProvider.Id;
     providerConfig.Attributes[DataConstants.ATTRIBUTE_ASSEMBLYNAME] = dbProvider.AssemblyName;
     providerConfig.Attributes[DataConstants.ATTRIBUTE_COMMANDBUILDERCLASS] = dbProvider.CommandBuilderClass;
     providerConfig.Attributes[DataConstants.ATTRIBUTE_COMMANDCLASS] = dbProvider.DbCommandClass;
     providerConfig.Attributes[DataConstants.ATTRIBUTE_CONNECTIONCLASS] = dbProvider.DbConnectionClass;
     providerConfig.Attributes[DataConstants.ATTRIBUTE_DESCRIPTION] = dbProvider.Description;
     providerConfig.Attributes[DataConstants.ATTRIBUTE_DEFAULT] = dbProvider.IsDefault.ToString().ToLower();
     providerConfig.Attributes[DataConstants.ATTRIBUTE_ENABLED] = dbProvider.IsEnabled.ToString().ToLower();
     providerConfig.Attributes[DataConstants.ATTRIBUTE_PARAMETERDBTYPECLASS] = dbProvider.ParameterDbTypeClass;
     providerConfig.Attributes[DataConstants.ATTRIBUTE_PARAMETERDBTYPEPROPERTY] = dbProvider.ParameterDbTypeProperty;
     providerConfig.Attributes[DataConstants.ATTRIBUTE_PARAMETERPREFIX] = dbProvider.ParameterPrefix;
     providerConfig.Attributes[DataConstants.ATTRIBUTE_PARAMETERPREFIX] = dbProvider.ParameterPrefix;
     providerConfig.Attributes[DataConstants.ATTRIBUTE_SETDBPARAMETERPRECISION] = dbProvider.SetDbParameterPrecision.ToString().ToLower();
     providerConfig.Attributes[DataConstants.ATTRIBUTE_SETDBPARAMETERSCALE] = dbProvider.SetDbParameterScale.ToString().ToLower();
     providerConfig.Attributes[DataConstants.ATTRIBUTE_SETDBPARAMETERSIZE] = dbProvider.SetDbParameterSize.ToString().ToLower();
     providerConfig.Attributes[DataConstants.ATTRIBUTE_USEDERIVEPARAMETERS] = dbProvider.UseDeriveParameters.ToString().ToLower();
     providerConfig.Attributes[DataConstants.ATTRIBUTE_USEPARAMETERPREFIXINPARAMETER] = dbProvider.UseParameterPrefixInParameter.ToString().ToLower();
     providerConfig.Attributes[DataConstants.ATTRIBUTE_USEPARAMETERPREFIXINSQL] = dbProvider.UseParameterPrefixInSql.ToString().ToLower();
     providerConfig.Attributes[DataConstants.ATTRIBUTE_USEPOSITIONALPARAMETERS] = dbProvider.UsePositionalParameters.ToString().ToLower();
     providerConfig.Attributes[DataConstants.ATTRIBUTE_ALLOWMARS] = dbProvider.AllowMARS.ToString().ToLower();
     return providerConfig;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="DBSemaphore"/> class.
 /// </summary>
 /// <param name="tablePrefix">The table prefix.</param>
 /// <param name="sql">The SQL.</param>
 /// <param name="defaultSQL">The default SQL.</param>
 /// <param name="dbProvider">The db provider.</param>
 public DBSemaphore(string tablePrefix, string sql, string defaultSQL, IDbProvider dbProvider) {
     log = LogManager.GetLogger(GetType());
     this.sql = defaultSQL;
     this.tablePrefix = tablePrefix;
     SQL = sql;
     adoUtil = new AdoUtil(dbProvider);
 }

		/// <summary>
		/// Initializes a new instance of the <see cref="IDbCommandCreatorFactory"/> class.
        /// </summary>
	    public IDbCommandCreatorFactory(IDbProvider dbProvider, CommandType commandType, string sql, IDbParameters declaredParameters)
	    {
            this.dbProvider = dbProvider;
            this.sql = sql;	
		    this.commandType = commandType;
		    this.declaredParameters = declaredParameters;
	    }

 public static DbParameter AddParam(this DbCommand cmd, IDbProvider provider, string name, object value)
 {
     var p = cmd.CreateParameter();
     provider.SetupParameter(p,name,value);
     cmd.Parameters.Add(p);
     return p;
 }

 public SqlFuConnection(DbConnection cnx,IDbProvider provider)
 {
     cnx.MustNotBeNull();
     provider.MustNotBeNull();
     _conex = cnx;
     _provider = provider;
   
 }

 public void Inject(IDbProvider dbProvider, IReadWriteLockManager lockManager)
 {
     Debug.Assert(dbProvider != null && lockManager != null);
     if (this.dbProvider != null || this.lockManager != null)
         throw new InvalidOperationException();
     this.dbProvider = dbProvider;
     this.lockManager = lockManager;
 }

 public void SetUp()
 {
     ctx =
         new XmlApplicationContext("assembly://Spring.Data.Integration.Tests/Spring.Data/autoDeclarativeServices.xml");
     dbProvider = ctx["DbProvider"] as IDbProvider;
     transactionManager = ctx["adoTransactionManager"] as IPlatformTransactionManager;
     
 }

 public void CreateDbProvider()
 {
     IApplicationContext ctx =
         new XmlApplicationContext("assembly://Spring.Data.Integration.Tests/Spring.Data/adoTemplateTests.xml");
     Assert.IsNotNull(ctx);
     dbProvider = ctx["DbProvider"] as IDbProvider;
     Assert.IsNotNull(dbProvider);
 }

 public InsertSqlBuilder(TableInfo info,object data,IDbProvider provider,InsertSqlOptions options)
 {
     _info = info;
     _data = data;
     _provider = provider;
     _options = options;      
     options.EnsureTableName(info);      
 }

        /*
		* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		* 
		* Constructors.
		* 
		* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		*/

        /// <summary>
        /// Create new StdAdoDelegate instance.
        /// </summary>
        /// <param name="logger">the logger to use during execution</param>
        /// <param name="tablePrefix">the prefix of all table names</param>
        /// <param name="instanceId">The instance id.</param>
        /// <param name="dbProvider">The db provider.</param>
        public StdAdoDelegate(ILog logger, string tablePrefix, string instanceId, IDbProvider dbProvider)
        {
            this.logger = logger;
            this.tablePrefix = tablePrefix;
            this.instanceId = instanceId;
            this.dbProvider = dbProvider;
            adoUtil = new AdoUtil(dbProvider);
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="DBSemaphore"/> class.
 /// </summary>
 /// <param name="tablePrefix">The table prefix.</param>
 /// <param name="schedName">the scheduler name</param>
 /// <param name="defaultInsertSQL">The SQL.</param>
 /// <param name="defaultSQL">The default SQL.</param>
 /// <param name="dbProvider">The db provider.</param>
 public DBSemaphore(string tablePrefix, string schedName, string defaultSQL, string defaultInsertSQL, IDbProvider dbProvider)
 {
     this.schedName = schedName;
     this.tablePrefix = tablePrefix;
     SQL = defaultSQL;
     InsertSQL = defaultInsertSQL;
     adoUtil = new AdoUtil(dbProvider);
 }

 public EmpProc(IDbProvider provider)
     : base(provider, "TEST.Get1CurOut")
 {
     //DeriveParameters();
     DeclaredParameters.AddOut("P_CURSOR1", OracleType.Cursor);
     AddRowMapper("employees", new EmployeeRowMapper());
     Compile();
 }

		/// <summary>
		///  Creates a DataReaderAdapter from a <see cref="IDataReader" />
		/// </summary>
		/// <param name="reader">The <see cref="IDataReader" /> which holds the records from the Database.</param>
		/// <param name="dbProvider">The databse provider <see cref="IDbProvider"/></param>
		public static IDataReader Transform(IDataReader reader, IDbProvider dbProvider)
		{
		    if (!dbProvider.AllowMARS && !(reader is InMemoryDataReader))
			{
				// The underlying reader will be closed.
				return new InMemoryDataReader(reader);
			}
		    return reader;
		}

 /// <summary>
 /// Initializes a new instance of the <see cref="DBSemaphore"/> class.
 /// </summary>
 /// <param name="tablePrefix">The table prefix.</param>
 /// <param name="defaultInsertSQL">The SQL.</param>
 /// <param name="defaultSQL">The default SQL.</param>
 /// <param name="dbProvider">The db provider.</param>
 public DBSemaphore(string tablePrefix, string schedName, string defaultSQL, string defaultInsertSQL, IDbProvider dbProvider)
 {
     log = LogManager.GetLogger(GetType());
     this.schedName = schedName;
     this.tablePrefix = tablePrefix;
     SQL = defaultSQL;
     InsertSQL = defaultInsertSQL;
     adoUtil = new AdoUtil(dbProvider);
 }