protected override SqlStatement PrepareStatement(IRequest context)
        {
            var tableName = context.Access().ResolveTableName(TableName);
            if (!context.Access().TableExists(tableName))
                throw new ObjectNotFoundException(tableName);

            var queryExpression = new SqlQueryExpression(new[]{SelectColumn.Glob("*") });
            queryExpression.FromClause.AddTable(tableName.FullName);
            queryExpression.WhereExpression = WherExpression;

            var queryFrom = QueryExpressionFrom.Create(context, queryExpression);
            var queryPlan = context.Query.Context.QueryPlanner().PlanQuery(new QueryInfo(context, queryExpression));

            var columns = new List<SqlAssignExpression>();
            foreach (var assignment in Assignments) {
                var columnName = ObjectName.Parse(assignment.ColumnName);

                var refName = queryFrom.ResolveReference(columnName);
                var expression = assignment.Expression.Prepare(queryFrom.ExpressionPreparer);

                var assign = SqlExpression.Assign(SqlExpression.Reference(refName), expression);
                columns.Add(assign);
            }

            return new Prepared(tableName, queryPlan, columns.ToArray(), Limit);
        }

 private FromTable(string tableName, SqlQueryExpression query, string alias)
 {
     Name = tableName;
     SubQuery = query;
     Alias = alias;
     IsSubQuery = query != null;
 }

        public ISelectStatementBuilder Query(SqlQueryExpression expression)
        {
            if (expression == null)
                throw new ArgumentNullException("expression");

            queryExpression = expression;
            return this;
        }

        public static void DeclareInsensitiveCursor(this IRequest context, string cursorName, SqlQueryExpression query, bool withScroll)
        {
            var flags = CursorFlags.Insensitive;
            if (withScroll)
                flags |= CursorFlags.Scroll;

            context.DeclareCursor(cursorName, flags, query);
        }

        public SelectStatement(SqlQueryExpression queryExpression, IEnumerable<SortColumn> orderBy)
        {
            if (queryExpression == null)
                throw new ArgumentNullException("queryExpression");

            QueryExpression = queryExpression;
            OrderBy = orderBy;
        }

        internal JoinPart(JoinType joinType, SqlQueryExpression subQuery, SqlExpression onExpression)
        {
            if (subQuery == null)
                throw new ArgumentNullException("subQuery");

            OnExpression = onExpression;
            JoinType = joinType;
            SubQuery = subQuery;
        }

        internal FromTableSubQuerySource(bool caseInsensitive, string uniqueKey, SqlQueryExpression queryExpression,
			QueryExpressionFrom fromSet, ObjectName alias)
        {
            UniqueName = uniqueKey;
            QueryExpression = queryExpression;
            QueryFrom = fromSet;
            AliasName = alias;
            IgnoreCase = caseInsensitive;
        }

        public IQueryPlanNode PlanQuery(IQueryContext context, SqlQueryExpression queryExpression, IEnumerable<SortColumn> sortColumns)
        {
            var queryFrom = QueryExpressionFrom.Create(context, queryExpression);
            var orderBy = new List<SortColumn>();
            if (sortColumns != null)
                orderBy.AddRange(sortColumns);

            return PlanQuery(context, queryExpression, queryFrom, orderBy);
        }

        public SelectIntoStatement(SqlQueryExpression queryExpression, SqlExpression reference)
        {
            if (queryExpression == null)
                throw new ArgumentNullException("queryExpression");
            if (reference == null)
                throw new ArgumentNullException("reference");

            QueryExpression = queryExpression;
            Reference = reference;
        }

        public InsertSelectStatement(ObjectName tableName, IEnumerable<string> columnNames, SqlQueryExpression queryExpression)
        {
            if (tableName == null)
                throw new ArgumentNullException("tableName");
            if (queryExpression == null)
                throw new ArgumentNullException("queryExpression");

            TableName = tableName;
            ColumnNames = columnNames;
            QueryExpression = queryExpression;
        }

        public CreateViewStatement(string viewName, IEnumerable<string> columnNames, SqlQueryExpression queryExpression)
        {
            if (viewName == null)
                throw new ArgumentNullException("viewName");
            if (queryExpression == null)
                throw new ArgumentNullException("queryExpression");

            ViewName = viewName;
            ColumnNames = columnNames;
            QueryExpression = queryExpression;
        }

        public ViewInfo(TableInfo tableInfo, SqlQueryExpression queryExpression, IQueryPlanNode queryPlan)
        {
            if (tableInfo == null)
                throw new ArgumentNullException("tableInfo");
            if (queryExpression == null)
                throw new ArgumentNullException("queryExpression");

            TableInfo = tableInfo;
            QueryExpression = queryExpression;
            QueryPlan = queryPlan;
        }

        public void DeclareInsensitiveCursor()
        {
            var query = new SqlQueryExpression(new []{new SelectColumn(SqlExpression.Constant("*")) });
            query.FromClause = new FromClause();
            query.FromClause.AddTable("test_table");

            Assert.DoesNotThrow(() => Query.DeclareInsensitiveCursor("c1", query));

            var exists = Query.ObjectExists(DbObjectType.Cursor, new ObjectName("c1"));
            Assert.IsTrue(exists);
        }

        public DeclareCursorStatement(string cursorName, IEnumerable<CursorParameter> parameters, CursorFlags flags, SqlQueryExpression queryExpression)
        {
            if (queryExpression == null)
                throw new ArgumentNullException("queryExpression");
            if (String.IsNullOrEmpty(cursorName))
                throw new ArgumentNullException("cursorName");

            CursorName = cursorName;
            Parameters = parameters;
            Flags = flags;
            QueryExpression = queryExpression;
        }

        private Field SelectScalar(string column)
        {
            var query = new SqlQueryExpression(new [] {new SelectColumn(SqlExpression.Reference(new ObjectName(column))) });
            query.FromClause.AddTable("seq1");

            var result = AdminQuery.Select(query);
            var row = result.FirstOrDefault();
            if (row == null)
                return Field.Null();

            return row.GetValue(0);
        }

        public QueryInfo(IRequest request, SqlQueryExpression expression, IEnumerable<SortColumn> sortColumns, QueryLimit limit)
        {
            if (expression == null)
                throw new ArgumentNullException("expression");
            if (request == null)
                throw new ArgumentNullException("request");

            Expression = expression;
            Request = request;
            SortColumns = sortColumns;
            Limit = limit;
        }

        public void ExecuteSelectAll()
        {
            var expression =
                new SqlQueryExpression(new[] {new SelectColumn(SqlExpression.Reference(new ObjectName("first_name")))});
            expression.FromClause.AddTable("test_table");

            Field result = null;
            Assert.DoesNotThrow(() => result = expression.EvaluateToConstant(AdminQuery, null));
            Assert.IsNotNull(result);
            Assert.IsInstanceOf<QueryType>(result.Type);
            Assert.IsNotNull(result.Value);
            Assert.IsInstanceOf<SqlQueryObject>(result.Value);

            ITable queryResult = null;

            Assert.DoesNotThrow(() => queryResult = ((SqlQueryObject) result.Value).QueryPlan.Evaluate(AdminQuery));
            Assert.IsNotNull(queryResult);
            Assert.AreEqual(3, queryResult.RowCount);
        }

        public static int DeleteFrom(this IQuery context, ObjectName tableName, SqlExpression expression, int limit)
        {
            if (expression is SqlQueryExpression)
                return context.DeleteFrom(tableName, (SqlQueryExpression)expression, limit);

            var table = context.GetMutableTable(tableName);
            if (table == null)
                throw new ObjectNotFoundException(tableName);

            var queryExpression = new SqlQueryExpression(new List<SelectColumn> { SelectColumn.Glob("*") });
            queryExpression.FromClause.AddTable(tableName.Name);
            queryExpression.WhereExpression = expression;

            var planExpression = queryExpression.Evaluate(context, null);
            var plan = (SqlQueryObject)((SqlConstantExpression)planExpression).Value.Value;
            var deleteSet = plan.QueryPlan.Evaluate(context);

            return context.DeleteFrom(tableName, deleteSet, limit);
        }

        IStatement IPreparableStatement.Prepare(IRequest request)
        {
            var tableName = request.Query.ResolveTableName(TableName);

            if (!request.Query.TableExists(tableName))
                throw new ObjectNotFoundException(tableName);

            var queryExp = new SqlQueryExpression(new SelectColumn[] {SelectColumn.Glob("*") });
            queryExp.FromClause.AddTable(tableName.FullName);
            queryExp.WhereExpression = WhereExpression;

            var queryInfo = new QueryInfo(request, queryExp);
            if (Limit > 0)
                queryInfo.Limit = new QueryLimit(Limit);

            var queryPlan = request.Query.Context.QueryPlanner().PlanQuery(queryInfo);

            return new Prepared(tableName, queryPlan);
        }

 public static void DeclareCursor(this IRequest context, string cursorName, CursorFlags flags, SqlQueryExpression query)
 {
     context.DeclareCursor(new CursorInfo(cursorName, flags, query));
 }