C# IQueryContext类代码示例

        public ChildQueryContext(IQueryContext parentContext)
        {
            if (parentContext == null)
                throw new ArgumentNullException("parentContext");

            this.parentContext = parentContext;
        }

 /// <inheritdoc/>
 public virtual ITable Evaluate(IQueryContext context)
 {
     // MILD HACK: Cast the context to a DatabaseQueryContext
     //DatabaseQueryContext dbContext = (DatabaseQueryContext)context;
     //return dbContext.Database.SingleRowTable;
     throw new NotImplementedException();
 }

        private void AddTestData(IQueryContext context)
        {
            var table = context.GetMutableTable(ObjectName.Parse("APP.test_table"));
            var row = table.NewRow();
            row.SetValue("id", DataObject.Integer(0));
            row.SetValue("first_name", DataObject.String("John"));
            row.SetValue("last_name", DataObject.String("Doe"));
            row.SetValue("birth_date", DataObject.Date(new SqlDateTime(1977, 01, 01)));
            row.SetValue("active", DataObject.Boolean(false));
            table.AddRow(row);

            row = table.NewRow();
            row.SetValue("id", DataObject.Integer(1));
            row.SetValue("first_name", DataObject.String("Jane"));
            row.SetValue("last_name", DataObject.String("Doe"));
            row.SetValue("birth_date", DataObject.Date(new SqlDateTime(1978, 11, 01)));
            row.SetValue("active", DataObject.Boolean(true));
            table.AddRow(row);

            row = table.NewRow();
            row.SetValue("id", DataObject.Integer(2));
            row.SetValue("first_name", DataObject.String("Roger"));
            row.SetValue("last_name", DataObject.String("Rabbit"));
            row.SetValue("birth_date", DataObject.Date(new SqlDateTime(1985, 05, 05)));
            row.SetValue("active", DataObject.Boolean(true));
            table.AddRow(row);
        }

        protected override SqlPreparedStatement PrepareStatement(IExpressionPreparer preparer, IQueryContext context)
        {
            var tableName = context.ResolveTableName(TableName);
            if (!context.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.DatabaseContext().QueryPlanner().PlanQuery(context, queryExpression, null);

            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);
        }

        public ReturnTypeVisitor(IQueryContext queryContext, IVariableResolver variableResolver)
        {
            this.queryContext = queryContext;
            this.variableResolver = variableResolver;

            dataType = PrimitiveTypes.Null();
        }

        public override ITable Evaluate(IQueryContext context)
        {
            // Solve the left branch result
            ITable leftResult = Left.Evaluate(context);
            // Solve the right branch result
            ITable rightResult = Right.Evaluate(context);

            // If the rightExpression is a simple variable then we have the option
            // of optimizing this join by putting the smallest table on the LHS.
            ObjectName rhsVar = rightExpression.AsVariable();
            ObjectName lhsVar = leftVar;
            Operator op = joinOp;
            if (rhsVar != null) {
                // We should arrange the expression so the right table is the smallest
                // of the sides.
                // If the left result is less than the right result
                if (leftResult.RowCount < rightResult.RowCount) {
                    // Reverse the join
                    rightExpression = Expression.Variable(lhsVar);
                    lhsVar = rhsVar;
                    op = op.Reverse();
                    // Reverse the tables.
                    ITable t = rightResult;
                    rightResult = leftResult;
                    leftResult = t;
                }
            }

            // The join operation.
            return leftResult.SimpleJoin(context, rightResult, lhsVar, op, rightExpression);
        }

        public override ITable Evaluate(IQueryContext context)
        {
            var leftResult = Left.Evaluate(context);
            var rightResult = Right.Evaluate(context);

            return leftResult.Union(rightResult);
        }

        public static void CreateViews(IQueryContext context)
        {
            // This view shows the grants that the user has (no join, only priv_bit).
            context.ExecuteQuery("CREATE VIEW INFORMATION_SCHEMA.ThisUserSimpleGrant AS " +
                                 "  SELECT \"priv_bit\", \"object\", \"name\", \"user\", " +
                                 "         \"grant_option\", \"granter\" " +
                                 "    FROM " + SystemSchema.UserGrantsTableName +
                                 "   WHERE ( user = user() OR user = '@PUBLIC' )");

            // This view shows the grants that the user is allowed to see
            context.ExecuteQuery("CREATE VIEW INFORMATION_SCHEMA.ThisUserGrant AS " +
                                 "  SELECT \"description\", \"object\", \"name\", \"user\", " +
                                 "         \"grant_option\", \"granter\" " +
                                 "    FROM " + SystemSchema.UserGrantsTableName + ", " + SystemSchema.PrivilegesTableName +
                                 "   WHERE ( user = user() OR user = '@PUBLIC' )" +
                                 "     AND " + SystemSchema.UserGrantsTableName + ".priv_bit = " +
                                 SystemSchema.PrivilegesTableName + ".priv_bit");

            // A view that represents the list of schema this user is allowed to view
            // the contents of.
            context.ExecuteQuery("CREATE VIEW INFORMATION_SCHEMA.ThisUserSchemaInfo AS " +
                                 "  SELECT * FROM  " + SystemSchema.SchemaInfoTableName +
                                 "   WHERE \"name\" IN ( " +
                                 "     SELECT \"name\" " +
                                 "       FROM INFORMATION_SCHEMA.ThisUserGrant " +
                                 "      WHERE \"object\" = " + ((int)DbObjectType.Schema) +
                                 "        AND \"description\" = '" + Privileges.List + "' )");

            // A view that exposes the table_columns table but only for the tables
            // this user has read access to.
            context.ExecuteQuery("CREATE VIEW INFORMATION_SCHEMA.ThisUserTableColumns AS " +
                                 "  SELECT * FROM " + SystemSchema.TableColumnsTableName +
                                 "   WHERE \"schema\" IN ( " +
                                 "     SELECT \"name\" FROM INFORMATION_SCHEMA.ThisUserSchemaInfo )");

            // A view that exposes the 'table_info' table but only for the tables
            // this user has read access to.
            context.ExecuteQuery("CREATE VIEW INFORMATION_SCHEMA.ThisUserTableInfo AS " +
                                 "  SELECT * FROM " + SystemSchema.TableInfoTableName +
                                 "   WHERE \"schema\" IN ( " +
                                 "     SELECT \"name\" FROM INFORMATION_SCHEMA.ThisUserSchemaInfo )");

            context.ExecuteQuery("  CREATE VIEW " + Tables + " AS " +
                                 "  SELECT NULL AS \"TABLE_CATALOG\", \n" +
                                 "         \"schema\" AS \"TABLE_SCHEMA\", \n" +
                                 "         \"name\" AS \"TABLE_NAME\", \n" +
                                 "         \"type\" AS \"TABLE_TYPE\", \n" +
                                 "         \"other\" AS \"REMARKS\", \n" +
                                 "         NULL AS \"TYPE_CATALOG\", \n" +
                                 "         NULL AS \"TYPE_SCHEMA\", \n" +
                                 "         NULL AS \"TYPE_NAME\", \n" +
                                 "         NULL AS \"SELF_REFERENCING_COL_NAME\", \n" +
                                 "         NULL AS \"REF_GENERATION\" \n" +
                                 "    FROM INFORMATION_SCHEMA.ThisUserTableInfo \n");

            context.ExecuteQuery("  CREATE VIEW " + Schemata + " AS " +
                                 "  SELECT \"name\" AS \"TABLE_SCHEMA\", \n" +
                                 "         NULL AS \"TABLE_CATALOG\" \n" +
                                 "    FROM INFORMATION_SCHEMA.ThisUserSchemaInfo\n");
        }

        /// <inheritdoc/>
        public override ITable Evaluate(IQueryContext context)
        {
            var t = Child.Evaluate(context);

            var exp = Expression;

            // Assert that all variables in the expression are identical.
            var columnNames = exp.DiscoverReferences();
            ObjectName columnName = null;
            foreach (var cv in columnNames) {
                if (columnName != null && !cv.Equals(columnName))
                    throw new InvalidOperationException("Range plan does not contain common column.");

                columnName = cv;
            }

            // Find the variable field in the table.
            var col = t.IndexOfColumn(columnName);
            if (col == -1)
                throw new InvalidOperationException("Could not find column reference in table: " + columnName);

            var field = t.TableInfo[col];

            // Calculate the range
            var range = new IndexRangeSet();
            var calculator = new RangeSetCalculator(context, field, range);
            range = calculator.Calculate(exp);

            // Select the range from the table
            var ranges = range.ToArray();
            return t.SelectRange(columnName, ranges);
        }

 public override ITable Evaluate(IQueryContext context)
 {
     ITable t = Child.Evaluate(context);
     // NOTE: currently this uses exhaustive select but should exploit
     //   function indexes when they are available.
     return t.ExhaustiveSelect(context, expression);
 }

        public ITable Evaluate(IQueryContext context)
        {
            IQueryPlanNode node = CreateChildNode(context);
            var t = node.Evaluate(context);

            return AliasName != null ? new ReferenceTable(t, AliasName) : t;
        }

 public override ITable Evaluate(IQueryContext context)
 {
     // Solve the left branch result
     var leftResult = Left.Evaluate(context);
     // Solve the Join (natural)
     return leftResult.NaturalJoin(Right.Evaluate(context));
 }

        public override ITable Evaluate(IQueryContext context)
        {
            // Evaluate the child
            ITable t = Child.Evaluate(context);

            var binary = (BinaryExpression) expression;

            // Perform the pattern search expression on the table.
            ObjectName lhsVar = binary.Left.AsVariable();
            if (lhsVar != null) {
                // LHS is a simple variable so do a simple select
                Operator op = binary.Operator;
                return t.SimpleSelect(context, lhsVar, op, binary.Right);
            }

            // LHS must be a constant so we can just evaluate the expression
            // and see if we get true, false, null, etc.
            DataObject v = expression.Evaluate(context);

            // If it evaluates to NULL or FALSE then return an empty set
            if (v.IsNull || v.Value.Equals(false))
                return t.EmptySelect();

            return t;
        }

        internal override bool MatchesInvoke(Invoke invoke, IQueryContext queryContext)
        {
            if (invoke == null)
                return false;

            bool ignoreCase = true;
            if (queryContext != null)
                ignoreCase = queryContext.IgnoreIdentifiersCase();

            if (!RoutineName.Equals(invoke.RoutineName, ignoreCase))
                return false;

            var inputParams = Parameters.Where(parameter => parameter.IsInput).ToList();
            if (invoke.Arguments.Length != inputParams.Count)
                return false;

            for (int i = 0; i < invoke.Arguments.Length; i++) {
                // TODO: support variable evaluation here? or evaluate parameters before reaching here?
                if (!invoke.Arguments[i].IsConstant())
                    return false;

                var argType = invoke.Arguments[i].ReturnType(queryContext, null);
                var paramType = Parameters[i].Type;

                // TODO: verify if this is assignable (castable) ...
                if (!paramType.IsComparable(argType))
                    return false;
            }

            return true;
        }

        private void updateVerseTable(IQueryContext context, SqliteTransaction transaction)
        {
            var sql = SqlBuilder.Update("Verses")
                .Set(DbVerse.BookField + " = @Book",
                    DbVerse.BeginChapterField + " = @BeginChapter",
                    DbVerse.EndChapterField + " = @EndChapter",
                    DbVerse.BeginVerseField + " = @BeginVerse",
                    DbVerse.EndVerseField + " = @EndVerse",
                    DbVerse.BodyField + " = @Body",
                    DbVerse.TitleField + " = @Title",
                    DbVerse.DateField + " = @Date",
                    DbVerse.TranslationField + " = @Translation")
                .Where(DbVerse.VerseIdField + " = @VerseId");

            var sqlParams = new
            {
                Book = _verse.Reference.Book.Id,
                BeginChapter = _verse.Reference.From.Chapter,
                EndChapter = _verse.Reference.To.Chapter,
                BeginVerse = _verse.Reference.From.Verse,
                EndVerse = _verse.Reference.To.Verse,
                Body = _verse.Body,
                Title = _verse.Title,
                Date = _verse.Date,
                Translation = _verse.Translation.ToDatabaseEntity().Id,
                VerseId = _verse.VerseId
            };

            context.Connection.Execute(sql, transaction, sqlParams);
        }