C# IQueryContext.GetTable方法代码示例

        public static ColumnChecker Default(IQueryContext context, ObjectName tableName)
        {
            var table = context.GetTable(tableName);
            if (table == null)
                throw new InvalidOperationException(String.Format("Table '{0}' not found in the context.", tableName));

            var tableInfo = table.TableInfo;
            var ignoreCase = context.IgnoreIdentifiersCase();

            return new DefaultChecker(tableInfo, ignoreCase);
        }

        protected override SqlPreparedStatement PrepareStatement(IExpressionPreparer preparer, IQueryContext context)
        {
            var tableName = context.ResolveTableName(TableName);

            var table = context.GetTable(tableName);
            if (table == null)
                throw new InvalidOperationException();

            if (Values.Any(x => x.OfType<SqlQueryExpression>().Any()))
                throw new InvalidOperationException("Cannot set a value from a query.");

            var columnInfos = new List<ColumnInfo>();
            foreach (var name in ColumnNames) {
                var columnName = ObjectName.Parse(name);
                var colIndex = table.FindColumn(columnName);
                if (colIndex < 0)
                    throw new InvalidOperationException(String.Format("Cannot find column '{0}' in table '{1}'", columnName, table.FullName));

                columnInfos.Add(table.TableInfo[colIndex]);
            }

            var assignments = new List<SqlAssignExpression[]>();

            foreach (var valueSet in Values) {
                var valueAssign = new SqlAssignExpression[valueSet.Length];

                for (int i = 0; i < valueSet.Length; i++) {
                    var columnInfo = columnInfos[i];

                    var value = valueSet[i];
                    if (value != null) {
                        // TODO: Deference columns with a preparer
                    }

                    if (value != null) {
                        var expReturnType = value.ReturnType(context, null);
                        if (!columnInfo.ColumnType.IsComparable(expReturnType))
                            throw new InvalidOperationException();
                    }

                    valueAssign[i] = SqlExpression.Assign(SqlExpression.Reference(columnInfo.FullColumnName), value);
                }

                assignments.Add(valueAssign);
            }

            return new Prepared(tableName, assignments);
        }

            public override ITable Evaluate(IQueryContext context)
            {
                if (!context.UserCanAlterTable(TableName))
                    throw new InvalidAccessException(TableName);

                var table = context.GetTable(TableName);
                if (table == null)
                    throw new ObjectNotFoundException(TableName);

                var tableInfo = table.TableInfo;
                var newTableInfo = new TableInfo(tableInfo.TableName);

                var checker = ColumnChecker.Default(context, TableName);

                bool tableAltered = false;
                bool markDropped = false;

                for (int n = 0; n < tableInfo.ColumnCount; ++n) {
                    var column = tableInfo[n];

                    string columnName = column.ColumnName;
                    var columnType = column.ColumnType;
                    var defaultExpression = column.DefaultExpression;

                    if (Action.ActionType == AlterTableActionType.SetDefault &&
                        CheckColumnNamesMatch(context, ((SetDefaultAction) Action).ColumnName, columnName)) {
                        var exp = ((SetDefaultAction) Action).DefaultExpression;
                        exp = checker.CheckExpression(exp);
                        defaultExpression = exp;
                        tableAltered = true;
                    } else if (Action.ActionType == AlterTableActionType.DropDefault &&
                               CheckColumnNamesMatch(context, ((DropDefaultAction) Action).ColumnName, columnName)) {
                        defaultExpression = null;
                        tableAltered = true;
                    } else if (Action.ActionType == AlterTableActionType.DropColumn &&
                               CheckColumnNamesMatch(context, ((DropColumnAction) Action).ColumnName, columnName)) {
                        // Check there are no referential links to this column
                        var refs = context.GetTableImportedForeignKeys(TableName);
                        foreach (var reference in refs) {
                            CheckColumnConstraint(columnName, reference.ForeignColumnNames, reference.ForeignTable, reference.ConstraintName);
                        }

                        // Or from it
                        refs = context.GetTableForeignKeys(TableName);
                        foreach (var reference in refs) {
                            CheckColumnConstraint(columnName, reference.ColumnNames, reference.TableName, reference.ConstraintName);
                        }

                        // Or that it's part of a primary key
                        var primaryKey = context.GetTablePrimaryKey(TableName);
                        if (primaryKey != null)
                            CheckColumnConstraint(columnName, primaryKey.ColumnNames, TableName, primaryKey.ConstraintName);

                        // Or that it's part of a unique set
                        var uniques = context.GetTableUniqueKeys(TableName);
                        foreach (var unique in uniques) {
                            CheckColumnConstraint(columnName, unique.ColumnNames, TableName, unique.ConstraintName);
                        }

                        markDropped = true;
                        tableAltered = true;
                    }

                    var newColumn = new ColumnInfo(columnName, columnType);
                    if (defaultExpression != null)
                        newColumn.DefaultExpression = defaultExpression;

                    newColumn.IndexType = column.IndexType;
                    newColumn.IsNotNull = column.IsNotNull;

                    // If not dropped then add to the new table definition.
                    if (!markDropped) {
                        newTableInfo.AddColumn(newColumn);
                    }
                }

                if (Action.ActionType == AlterTableActionType.AddColumn) {
                    var col = ((AddColumnAction)Action).Column;

                    checker.CheckExpression(col.DefaultExpression);
                    var columnName = col.ColumnName;
                    var columnType = col.ColumnType;

                    // If column name starts with [table_name]. then strip it off
                    columnName = checker.StripTableName(TableName.Name, columnName);
                    if (tableInfo.IndexOfColumn(col.ColumnName) != -1)
                        throw new InvalidOperationException("The column '" + col.ColumnName + "' is already in the table '" + tableInfo.TableName + "'.");

                    var newColumn = new ColumnInfo(columnName, columnType) {
                        IsNotNull = col.IsNotNull,
                        DefaultExpression = col.DefaultExpression
                    };

                    newTableInfo.AddColumn(newColumn);
                    tableAltered = true;
                }

                if (Action.ActionType == AlterTableActionType.DropConstraint) {
                    string constraintName = ((DropConstraintAction)Action).ConstraintName;
                    int dropCount = context.DropConstraint(TableName, constraintName);
//.........这里部分代码省略.........

 public ITable Evaluate(IQueryContext context)
 {
     var t = context.GetTable(TableName);
     return AliasName != null ? new ReferenceTable(t, AliasName) : t;
 }

 /// <inheritdoc/>
 public virtual ITable Evaluate(IQueryContext context)
 {
     ITable t = context.GetTable(tableName);
     return aliasName != null ? new ReferenceTable((Table)t, aliasName) : t;
 }