/// <summary>
        /// Visits the given <paramref name="addConstraintNode"/>.
        /// </summary>
        /// <param name="addConstraintNode"></param>
        public override void Visit(IAddConstraintNode addConstraintNode)
        {
            if(string.IsNullOrEmpty(addConstraintNode.Name))
                addConstraintNode.Name = Environment.GetAnonymousIdentifier();

            base.Visit(addConstraintNode);
        }
 /// <summary>
 /// Visits the given <paramref name="addConstraintNode"/>.
 /// </summary>
 /// <param name="addConstraintNode"></param>
 public override void Visit(IAddConstraintNode addConstraintNode)
 {
     Visit(addConstraintNode.ChildNodes);
 }
        /*/// <summary>
        /// Visits the given <paramref name="alterTableNode"/>.
        /// </summary>
        /// <param name="alterTableNode"></param>
        public override void Visit(IAlterTableNode alterTableNode)
        {
            
        }*/

        public override void Visit(IAddConstraintNode addConstraintNode)
        {
            IConstraintDefinition constraint = addConstraintNode;
                //Environment.Schema.GetTable(addConstraintNode.Table).GetConstraint(addConstraintNode.Name);

            if(constraint is IDefaultConstraintDefinition)
            {
                IDefaultConstraintDefinition defaultConstraint = (IDefaultConstraintDefinition)constraint;
                TextWriter.WriteLine("alter table {0} add constraint {1} default ({2}) for {3};",
                    Platform.Dialect.EscapeIdentifier(constraint.Table),
                    Platform.Dialect.EscapeIdentifier(defaultConstraint.Name),
                    defaultConstraint.Default,
                    Platform.Dialect.EscapeIdentifier(constraint.Columns[0]));
            } // if
        }
        public override void Visit(IAddConstraintNode addConstraintNode)
        {
            textWriter.Write("add constraint {0}", GetIdentifier(addConstraintNode.Name));

            WriteProperties(addConstraintNode);
            VisitBlock(addConstraintNode);
        }
        public override void Visit(IAddConstraintNode addConstraintNode)
        {
            if(!Environment.IsAnonymousIdentifier(addConstraintNode.Name))
                return;

            ITableDefinition table = Environment.Schema.GetTable(addConstraintNode.Table);
            IConstraintDefinition constraint = table.GetConstraint(addConstraintNode.Name);

            table.RemoveConstraint(addConstraintNode.Name);
            addConstraintNode.Name = constraint.Name = namingStrategy.GetConstraintName(constraint);
            table.AddConstraint(constraint);
        }
        /// <summary>
        /// Visits the given <paramref name="addConstraintNode"/>.
        /// </summary>
        /// <param name="addConstraintNode"></param>
        public override void Visit(IAddConstraintNode addConstraintNode)
        {
            //
            // If we have "table" property, use that as a value for "table" property
            if(addConstraintNode.Properties[MdlSyntax.Table] != null)
                addConstraintNode.Table = AstNodePropertyUtil.AsString(addConstraintNode.Properties, MdlSyntax.Table);
            else
            {
                //
                // If we have IAddColumnNode or IAlterColumnNode as a parent, use its table name
                // plus use that column as a target for the constraint
                if(addConstraintNode.Parent is IAddColumnNode || addConstraintNode.Parent is IAlterColumnNode)
                {
                    IColumnNode columnNode = ((IColumnNode)addConstraintNode.Parent);
                    
                    addConstraintNode.Table = columnNode.Table;
                    addConstraintNode.Columns.Add(columnNode.Name);
                } // if

                //
                // If parent is IAddTableNode or IAlterTableNode, use its name
                if(addConstraintNode.Parent is IAddTableNode || addConstraintNode.Parent is IAlterTableNode)
                    addConstraintNode.Table = ((ITableNode)addConstraintNode.Parent).Name;

                addConstraintNode.Properties.AddProperty(new AstNodeProperty(MdlSyntax.Table, 
                    new StringAstNodePropertyValue(addConstraintNode.Table)));
            } // else

            //
            // If we have "default" property, this is is IDefaultConstraintDefinition
            IConstraintDefinition constraintDefinition = null;
            if(addConstraintNode.Properties[MdlSyntax.Default] != null)
            {
                IAstNodePropertyValue value = addConstraintNode.Properties[MdlSyntax.Default].Value;
                constraintDefinition =
                    new DefaultConstraintDefinition(addConstraintNode.Name,
                        addConstraintNode.Table,
                        value is IIntegerAstNodePropertyValue ?
                            AstNodePropertyUtil.AsInteger(value).ToString() :
                            AstNodePropertyUtil.AsString(value));
                Environment.Schema.GetTable(constraintDefinition.Table).AddConstraint(constraintDefinition);
            } // if

            if(addConstraintNode.Columns.Count > 0)
                constraintDefinition.Columns.Add(addConstraintNode.Columns[0]);

            //
            // Look for "columns" or "column" properties
            if(addConstraintNode.Properties[MdlSyntax.Column] != null)
            {
                string columnName = AstNodePropertyUtil.AsString(
                    addConstraintNode.Properties[MdlSyntax.Column].Value);
                
                addConstraintNode.Columns.Add(columnName);
                constraintDefinition.Columns.Add(columnName);
            } // if

            if(addConstraintNode.Properties[MdlSyntax.Columns] != null)
            {
                IListAstNodePropertyValue columns =
                    (IListAstNodePropertyValue)addConstraintNode.Properties[MdlSyntax.Columns].Value;
                foreach (IAstNodePropertyValue column in columns.Items)
                {
                    string columnName = AstNodePropertyUtil.AsString(column);
                    
                    addConstraintNode.Columns.Add(columnName);
                    constraintDefinition.Columns.Add(columnName);
                }
            } // if
        }