/// <summary>
		///     Creates a generic query part that can be used for any query
		/// </summary>
		/// <param name="prefix"></param>
		/// <param name="parameters"></param>
		/// <param name="builder">The type of building object</param>
		public GenericQueryPart(string prefix, IEnumerable<IQueryParameter> parameters, IQueryBuilder builder)
		{
			_builder = builder;
			Debug.Assert(prefix != null, "prefix != null");
			Prefix = prefix;
			QueryParameters = parameters;
		}

        public static void GetStationCollectionAsync(IQueryBuilder url, RealTimeDataDelegate callback)
        {
            try
            {
                if (url == null) throw new Exception("Cannot work with null-objects");
                if (String.IsNullOrEmpty(url.Url)) throw new Exception("Url cannot be empty");

                var client = new WebClient();

                client.DownloadStringCompleted += (s, e) =>
                {
                    if (e.Error != null) throw e.Error;
                    if (e.Result == null) return;

                    var collection = JsonHelper.Deserialize<
                        IList<Station>>(e.Result);

                    callback(new ObservableCollection<Station>(collection));
                };

                client.DownloadStringAsync(new Uri(url.Url));
            }
            catch (Exception)
            {
                throw;
            }
        }

 public FurnitureCreator(
     IRoomReader roomReader,
     IQueryBuilder queryBuilder)
 {
     this.roomReader = roomReader;
     this.queryBuilder = queryBuilder;
 }

 public static void ExecuteReaderAndRead( this IDbTransaction dbTransaction, IQueryBuilder query, Action<IDataReader> action )
 {
     ExecuteReader( dbTransaction,
                    query.GetSql(),
                    query.GetParameters(),
                    dataReader => dataReader.Read( action ) );
 }

        /// <summary>
        /// Creates the query for this class.
        /// </summary>
        /// <param name="qb">The <see cref="IQueryBuilder"/> instance.</param>
        /// <returns>The query for this class.</returns>
        static string CreateQuery(IQueryBuilder qb)
        {
            // SELECT * FROM `{0}`

            var q = qb.Select(GuildTable.TableName).AllColumns();
            return q.ToString();
        }

        private static IList<Status> Load(IQueryBuilder queryBuilder, ulong maxId, int count = 2000)
        {
            var statuses = new List<Status>();
            //todo limit exception System.AggregateException, message: Rate limit exceeded - Please visit the LINQ to Twitter FAQ (at the HelpLink) for help on resolving this error.
            var tweetQuery = queryBuilder.BuildTaskByMinId(maxId + 1).ToList();

            statuses.AddRange(tweetQuery);

            if (statuses.Count < 150)
            {
                return statuses;
            }

            while (statuses.Count < count)
            {
                tweetQuery = queryBuilder.BuildTaskByMinIdAndMaxId(maxId + 1, statuses[statuses.Count - 1].StatusID - 1).ToList();

                statuses.AddRange(tweetQuery);
                if (tweetQuery.Count < 150)
                {
                    break;
                }
            }
            return statuses;
        }

        /// <summary>
        /// Creates the query for this class.
        /// </summary>
        /// <param name="qb">The <see cref="IQueryBuilder"/> instance.</param>
        /// <returns>The query for this class.</returns>
        static string CreateQuery(IQueryBuilder qb)
        {
            // SELECT `id` FROM `{0}`

            var q = qb.Select(QuestTable.TableName).Add("id");
            return q.ToString();
        }

        public virtual string BuildQual(IQueryBuilder builder)
        {
            if (!builder.StatusClauseAdded)
            {
                // builder
            }

            var set = builder.StoredClauses;

            var clauses = this.ExecuteStoredClauses(set).Distinct(new ClauseComparer()).ToList();

            var qual = new StringBuilder();
            foreach (var clause in clauses)
            {
                if (string.IsNullOrEmpty(qual.ToString()))
                {
                    qual.Append(clause.Value ?? string.Empty);
                }
                else
                {
                    qual.Append(string.Format("{0} {1} ", clause.Operator == ClauseOperator.AND ? " AND" : " OR", clause.Value ?? string.Empty));
                }
            }

            return qual.ToString();
        }

        /// <summary>
        /// Creates the query for this class.
        /// </summary>
        /// <param name="qb">The <see cref="IQueryBuilder"/> instance.</param>
        /// <returns>The query for this class.</returns>
        static string CreateQuery(IQueryBuilder qb)
        {
            // CALL find_foreign_keys(@schema,@table,@column)

            var q = qb.CallProcedure("find_foreign_keys").AddParam(SchemaParameterName, TableParameterName, ColumnParameterName);
            return q.ToString();
        }

        public MusicModule(IQueryBuilder queryBuilder, ICommandBuilder commandBuilder)
            : base("/music")
        {
            _queryBuilder = queryBuilder;
            _commandBuilder = commandBuilder;

            Get["/"] = _ =>
            {
                this.RequiresAuthentication();
                this.RequiresReadClaim("music");

                var paging = this.BindAndValidate<Paging>();
                var result = _queryBuilder.For<IPagedEnumerable<TrackDto>>().With(paging);

                return Response.AsAccepted(result, new[] { "json", "m3u" }, model => Response.AsJson(model));
            };

            Post["/"] = _ =>
            {
                this.RequiresAuthentication();
                this.RequiresWriteClaim("music");

                var model = this.BindAndValidate<AddTrack>();
                _commandBuilder.Execute(model);

                return new Response
                {
                    StatusCode = HttpStatusCode.Created
                };
            };

            Post["/tagged"] = _ =>
            {
                this.RequiresAuthentication();
                this.RequiresWriteClaim("music");

                var model = this.BindAndValidate<MarkTrackWithTags>();
                _commandBuilder.Execute(model);

                return new Response
                {
                    StatusCode = HttpStatusCode.OK
                };
            };

            Delete["/tagged"] = _ =>
            {
                this.RequiresAuthentication();
                this.RequiresWriteClaim("music");

                var model = this.BindAndValidate<RemoreTagsFromTrack>();
                _commandBuilder.Execute(model);

                return new Response
                {
                    StatusCode = HttpStatusCode.OK
                };
            };
        }

 private static void RootExecuteReader( this IDbConnection dbConnection, IQueryBuilder queryBuilder, Action<IDataReader> action )
 {
     using ( IDbCommand dbCommand = dbConnection.CreateCommand( queryBuilder ) )
     using ( IDataReader dataReader = dbCommand.ExecuteReader() )
     {
         action( dataReader );
     }
 }

 public SelectRequest(SolrUriBuilder builder, IQueryBuilder queryBuilder)
     : base(builder)
 {
     UrlBuilder.Handler = "select";
     if (queryBuilder == null)
         throw new ArgumentNullException("queryBuilder");
     UrlBuilder.SetQuery(queryBuilder);
 }

        /// <summary>
        /// Creates the query for this class.
        /// </summary>
        /// <param name="qb">The <see cref="IQueryBuilder"/> instance.</param>
        /// <returns>The query for this class.</returns>
        static string CreateQuery(IQueryBuilder qb)
        {
            // UPDATE `{0}` SET `server_time`=NOW()

            var f = qb.Functions;
            var q = qb.Update(ServerTimeTable.TableName).Add("server_time", f.Now());
            return q.ToString();
        }

 public CalcService()
 {
     InitializeComponent();
     IoC.Init();
     _query = IoC.Resolve<IQueryBuilder>();
     _periodsRepository = IoC.Resolve<IRepository<Period>>();
     _statisticDataRepository = IoC.Resolve<IRepository<StatisticalData>>();
     _dynamicDataRepository = IoC.Resolve<IRepository<DynamicData>>();
     _unitOfWorkFactory = IoC.Resolve<IUnitOfWorkFactory>();
 }

        /// <summary>
        /// Creates the query for this class.
        /// </summary>
        /// <param name="qb">The <see cref="IQueryBuilder"/> instance.</param>
        /// <returns>The query for this class.</returns>
        static string CreateQuery(IQueryBuilder qb)
        {
            // SELECT `id` FROM `{0}` WHERE `repeatable` = 1

            var f = qb.Functions;
            var s = qb.Settings;
            var q = qb.Select(QuestTable.TableName).Add("id")
                .Where(f.Equals(s.EscapeColumn("repeatable"), "1"));
            return q.ToString();
        }

		public void SetUp()
		{
			var logger = _repository.Stub<ILogger>();
			_mockServices = _repository.StrictMock<IServices>();
			_mockMetaModel = _repository.StrictMock<IMetaModel>();
			_mockQueryBuilder = _repository.StrictMock<IQueryBuilder>();

			_processor = new TestVersionOneProcessor(null, logger);
			_processor.ConnectTest(_mockServices, _mockMetaModel, _mockQueryBuilder);
		}

 public static void ExecuteReader( this IDbConnection dbConnection, IQueryBuilder queryBuilder, Action<IDataReader> action )
 {
     try
     {
         RootExecuteReader( dbConnection, queryBuilder, action );
     }
     catch ( DbException ex )
     {
         Ez.DbExceptionHandler().Handle( ex, queryBuilder.GetSql(), queryBuilder.GetParameters() );
     }
 }

        private static IEnumerable<IQuery> GetQueriesForGameObjects(IQueryBuilder queryBuilder)
        {
            var allQueries = new List<IQuery>
            {
                queryBuilder.BuildQuery(ObjectType.Champion, GetChampionDefaultQueryParameter()),
                queryBuilder.BuildQuery(ObjectType.Item, GetItemDefaultQueryParameter()),
                queryBuilder.BuildQuery(ObjectType.Mastery, GetMasteryDefaultQueryParameter()),
                queryBuilder.BuildQuery(ObjectType.Rune, GetRuneDefaultQueryParameter())
            };

            return allQueries;
        }

        public SisoDynamicQueryable(Type structureType, IQueryBuilder queryBuilder, IQueryEngine queryEngine, IDynamicLambdaBuilder lambdaBuilder)
        {
            Ensure.That(structureType, "structureType").IsNotNull();
            Ensure.That(queryBuilder, "queryBuilder").IsNotNull();
            Ensure.That(queryEngine, "queryEngine").IsNotNull();
            Ensure.That(lambdaBuilder, "lambdaBuilder").IsNotNull();

            StructureType = structureType;
            QueryBuilder = queryBuilder;
            QueryEngine = queryEngine;
            LambdaBuilder = lambdaBuilder;
        }

        public AccountModule(ICommandBuilder commandBuilder, IQueryBuilder queryBuilder)
            : base("/account")
        {
            _commandBuilder = commandBuilder;
            _queryBuilder = queryBuilder;

            Get["/"] = _ =>
            {
                this.RequiresAuthentication();
                this.RequiresReadClaim("account");

                var paging = this.BindAndValidate<Paging>();
                var result = _queryBuilder.For<IPagedEnumerable<UserDto>>().With(paging);

                return Response.AsJson(result);
            };

            Post["/"] = _ =>
            {
                this.RequiresAuthentication();
                this.RequiresWriteClaim("account");

                var findByEmail = this.BindAndValidate<FindByEmail>();
                var emailAlreadyInUse = _queryBuilder.For<UserDto>().With(findByEmail) != null;
                if (emailAlreadyInUse)
                {
                    return new Response
                    {
                        StatusCode = HttpStatusCode.BadRequest
                    };
                }

                var user = this.BindAndValidate<CreateUser>();
                _commandBuilder.Execute(user);

                return new Response
                {
                    StatusCode = HttpStatusCode.Created
                };
            };

            Post["/{email}"] = _ =>
            {
                this.RequiresAuthentication();
                this.RequiresReadClaim("account");

                var credentials = this.BindAndValidate<Credentials>();
                var result = _queryBuilder.For<UserDto>().With(credentials);

                return Response.AsJson(result);
            };
        }