Overriding Events

association {  
   // since we are defining all 8 events in this block, 
   // the join paths after the "=" are not necessary but are good
   // to have if they are possible to define.
   Article[0..n] articles = join magazines.magazine_id
                              to magazine_article_map.magazine_id,
                            join magazine_article_map.article_id
                              to articles.article_id;
   Magazine[0..n] magazines = join articles.article_id
                                to magazine_article_map.article_id,  
                              join magazine_article_map.magazine_id
                                to magazines.magazine_id;

    // the retrieve event that can be called from a magazine DataObject
    // to retrieve all of the articles in the magazine.  Note that we
    // use the object key for Magazine (id) for the bind variable
    // here instead of the object key for Article (articleID).
    retrieve articles {
       do {
          select articles.article_id, title 
          from articles, magazine_article_map m
          where articles.article_id = m.article_id
          and m.magazine_id = :id
       } map {
          articleID = articles.article_id;
          title = articles.title;        
       }
    }

    // the retrieve event that can be called from an Article DataObject
    // to retrieve all of the magazines for an article.  Note that we 
    // use the object key for Article (articleID) for the bind variable
    // here instead of the object key for Magazine (id).
    retrieve magazines {
       do {
          select magazines.magazine_id, issue_number, name
          from magazines, publications, magazine_article_map m
          where magazines.article_id = :articleID
          and publication_id = magazines.magazine_id
          and magazines.magazine_id = m.magazine.id
       } map {
          id = magazines.magazine_id;
          issueNumber = magazines.issue_number;
          name = publications.name;
       }
    }


    // for the other 6 events, we switch between magazines and articles
    add articles {
       do {
          insert into magazine_article_map (article_id, magazine_id)
          values (:articles.articleID, :id)
       }
    }

    add magazines {
       do {
          insert into magazine_article_map (article_id, magazine_id)
          values (:articleID, :magazines.id)
       }
    }

    remove articles {
       do {
          delete from magazine_article_map 
          where magazine_id = :id
          and article_id = :articles.articleID
       }
    }  

    remove magazines {
       do {
          delete from magazine_article_map 
          where magazine_id = :magazines.id
          and article_id = :articleID
       }
    }  

    clear articles {
       do {
          delete from magazine_article_map 
          where magazine_id = :id
       }
    }

    clear magazines {
       do {
          delete from magazine_article_map 
          where article_id = :articleID
       }
    }

    // there are no link attributes so there is nothing for the 
    // update event to do.  Therefore, we do not define it.
}

object type Author {
    BigInteger[1..1] id = authors.author_id INTEGER;
    String[1..1] firstName = author.first_name VARCHAR(700);
    String[1..1] lastName = author.last_name VARCHAR(700);
    Blob[0..1] portrait = authors.portrait BLOB;

    // the following line is the role reference.  Notice that it 
    // appears in the definition just like an Attribute.  The only
    // difference is that instead of pointing to a column in the   
    ScreenName[0..1] screenName = 
               join authors.screen_name_id to screen_names.name_id;

    object key (id);

    add screenName {
        // we include this extra do block so that
        // we null out the screen name of anyone that has the screen
        // name that is about to be taken by the author with id = :id
        do { 
            update authors set screen_name_id = null
            where screen_name_id = :screenName.id
        }

        // This do block is the block that would
        // have been created by standard MDSQL
        do {
            update authors set screen_name_id = :screenName.id
            where author_id = :id
        }
    }

    // we do not define any more Role Reference events or object type
    // events because the Persistence layer automatically generates 
    // the rest
}

object type Paragraph {
    BigDecimal id = paragraphs.paragraph_id;
    String text = paragraphs.text;
    
    object key (paragraphs.paragraph_id);

    insert {
       // notice that the insert block is empty.  This is because
       // it does not make sense for a Paragraph to belong
       // outside of an Article so there is no way to insert it
       // outside of the Association "add" event.  Note that this
       // means that creating a new Paragraph and calling save() will
       // not actually do anything which may be confusing at first
    }
}

association {
   Article[1..1] articles = join paragraphs.article_id 
                              to articles.article_id;
   // notice the composite keyword indicates that if the article does
   // not exist then the paragraph also does not exist
   composite Paragraph[0..n] paragraphs = join articles.article_id
                                            to paragraphs.article_id;

    add paragraphs {
       do {
          insert into paragraphs (paragraph_id, text, article_id)
          values (:paragraphs.id, :text, :articleID)
       }
    }
}