private void SetQueryContext(SimpleQuery query)
 {
     _query = query;
     _tableName = ObjectName.Parse(query.TableName.Split('.').Last());
     _table = _schema.FindTable(_tableName);
     _commandBuilder = new CommandBuilder(GetSelectClause(_tableName), _schema.SchemaProvider);
 }

 public SimpleSelectNode(IQueryPlanNode child, ObjectName leftVar, Operator op, Expression rightExpression)
     : base(child)
 {
     this.leftVar = leftVar;
     this.op = op;
     this.rightExpression = rightExpression;
 }

 internal OldNewTableState(ObjectName tableSource, int oldRowIndex, Row newDataRow, bool newMutable)
 {
     TableSource = tableSource;
     OldRowIndex = oldRowIndex;
     NewDataRow = newDataRow;
     IsNewMutable = newMutable;
 }

        public RenameTriggerAction(ObjectName name)
        {
            if (name == null)
                throw new ArgumentNullException("name");

            Name = name;
        }

        public static void AddForeignKey(this ITransaction transaction, ObjectName table, string[] columns,
			ObjectName refTable, string[] refColumns,
			ForeignKeyAction deleteRule, ForeignKeyAction updateRule, String constraintName)
        {
            AddForeignKey(transaction, table, columns, refTable, refColumns, deleteRule, updateRule,
                ConstraintDeferrability.InitiallyImmediate, constraintName);
        }

        public CreateSequenceStatement(ObjectName sequenceName)
        {
            if (sequenceName == null)
                throw new ArgumentNullException("sequenceName");

            SequenceName = sequenceName;
        }

        private void SetQueryContext(SimpleQuery query)
        {
            _query = query;
            _tableName = _schema.BuildObjectName(query.TableName);
            _table = _schema.FindTable(_tableName);
            var selectClause = _query.Clauses.OfType<SelectClause>().SingleOrDefault();
            if (selectClause != null)
            {
                if (selectClause.Columns.OfType<AllColumnsSpecialReference>().Any())
                {
                    _columns = ExpandAllColumnsReferences(selectClause.Columns).ToArray();
                }
                else
                {
                    _columns = selectClause.Columns.ToArray();
                }
            }
            else
            {
                _columns = _table.Columns.Select(c => ObjectReference.FromStrings(_table.Schema, _table.ActualName, c.ActualName)).ToArray();
            }

            HandleWithClauses();

            _whereCriteria = _query.Clauses.OfType<WhereClause>().Aggregate(SimpleExpression.Empty,
                                                                            (seed, where) => seed && where.Criteria);
            _havingCriteria = _query.Clauses.OfType<HavingClause>().Aggregate(SimpleExpression.Empty,
                                                                              (seed, having) => seed && having.Criteria);

            _commandBuilder.SetText(GetSelectClause(_tableName));
        }

 public void AddNotificationListener(object token, ObjectName name, ObjectName listener, NotificationFilterCallback filterCallback, object handback)
 {
     using (TemporarySecurityContext tsc = new TemporarySecurityContext(Authorize(token)))
      {
     _server.AddNotificationListener(name, listener, filterCallback, handback);
      }
 }

 public ObjectInstance CreateMBean(object token, string className, ObjectName name, object[] arguments)
 {
     using (TemporarySecurityContext tsc = new TemporarySecurityContext(Authorize(token)))
      {
     return _server.CreateMBean(className, name, arguments);
      }
 }

        private static string MakeMessage(string userName, ObjectName objectName, Privileges privileges)
        {
            if (privileges == Privileges.None)
                return String.Format("User '{0}' has not enough privileges to operate on the object '{1}'.", userName, objectName);

            return String.Format("User '{0}' has not the privilege '{1}' on the object '{2}'.", userName, privileges, objectName);
        }

        public static ITableInfoBuilder Named(this ITableInfoBuilder builder, ObjectName tableName)
        {
            if (tableName == null)
                throw new ArgumentNullException("tableName");

            return builder.InSchema(tableName.ParentName).Named(tableName.Name);
        }

 public MissingPrivilegesException(string userName, ObjectName objectName, Privileges privileges, string message)
     : base(SecurityErrorCodes.MissingPrivileges, message)
 {
     UserName = userName;
     ObjectName = objectName;
     Privileges = privileges;
 }

 public SimpleSelectNode(IQueryPlanNode child, ObjectName columnName, SqlExpressionType op, SqlExpression expression)
     : base(child)
 {
     ColumnName = columnName;
     OperatorType = op;
     Expression = expression;
 }

 public string QuoteObjectName(ObjectName unquotedName)
 {
     if (!string.IsNullOrWhiteSpace(unquotedName.Schema))
         return _schemaProvider.QuoteObjectName(unquotedName.Schema) + '.' + _schemaProvider.QuoteObjectName(unquotedName.Name);
     else
         return _schemaProvider.QuoteObjectName(unquotedName.Name);
 }

        public override bool HasPrivileges(DbObjectType objectType, ObjectName objectName, Privileges privileges)
        {
            if (IsSecureAccess)
                return true;

            return base.HasPrivileges(objectType, objectName, privileges);
        }

 public ForeignKey(ObjectName detailTable, IEnumerable<string> columns, ObjectName masterTable, IEnumerable<string> masterColumns)
 {
     _columns = new Key(columns);
     _detailTable = detailTable;
     _masterTable = masterTable;
     _masterColumns = new Key(masterColumns);
 }

        private static string BuildMessage(ObjectName objectName)
        {
            if (objectName == null)
                return "Cannot access the object: possibly not enough privileges.";

            return String.Format("Cannot access the '{0}': possibly not enough privileges.", objectName);
        }

 public JoinNode(IQueryPlanNode left, IQueryPlanNode right, ObjectName leftColumnName, SqlExpressionType @operator, SqlExpression rightExpression)
     : base(left, right)
 {
     LeftColumnName = leftColumnName;
     Operator = @operator;
     RightExpression = rightExpression;
 }

 static SqlPreCommand DropViewIndex(ObjectName viewName, string index)
 {
     return new[]{
          DropIndex(viewName, index),
          DropView(viewName)
     }.Combine(Spacing.Simple);
 }

        public IExpressionBuilder Reference(ObjectName referenceName)
        {
            expression = SqlExpression.Reference(referenceName);
            VerifyUnary();

            return this;
        }