Bob's Blog - ColdFusion Tidbits - CF ORM Integration

Join me at RIA Unleashed in Boston to Learn about ColdFusion ORM

Mon, 16 Aug 2010 11:43:00 -0400

I am pleased and honoured to announce that I'll be teaching and speaking at RIA Unleashed in Boston in November. Organized by Brian Rinaldi (one of my heroes in the ColdFusion community), RIA Unleashed is a conference that I have wanted to attend in the past and I think this year's version is going to be stellar. The format is a bit different from other CF conferences that I have attended: it's a two day conference, with day one consisting of half-day hands-on workshops, and day two having standard one-hour sessions across multiple tracks. You can find more information about the half-day workshops and one-hour sessions at the RIA Unleashed site.

The conference runs from November 11-12, 2010, in Boston. You can register for just day one for $150, just day two for $50, or both days for the bargain price of $175, which includes lunch on both days and a party on Thursday night. Brian is also running a contest which will award three lucky winners with a two-day pass to the conference.

I'll be teaching a half-day workshop and presenting a session on, you guessed it, ColdFusion ORM. The day one workshop will be a hands-on introduction to ColdFusion ORM, designed to teach you the basics of working with this powerful new technology. My session on day two is called "What Your Mother Never Told You About ColdFusion ORM", and it covers advanced topics that you won't read about in the ColdFusion documentation. It will be a great follow up for folks who attend the half-day ORM workshop, and will also be valuable to anyone who's looked at ColdFusion ORM already.

I'm really looking forward to attending this conference, and I hope to see some of you there in November.

CFUnited is Almost Here - Learn about Validations and ORM

Mon, 19 Jul 2010 09:47:00 -0400

As I'm sure many of you are aware, the final CFUnited will be starting in a little over a week. Although I did attend a couple of CFUN's in the past (when they were a one-day event), this will be my first CFUnited, so I'm pretty excited about it. It will be great to meet even more people than I usually do at other conferences, such as cf.Objective() and NCDevCon, and I wanted to give a final plug to my sessions, as I think they will be of interest to a lot of developers. As well, I've made some last minute changes to both sessions to cover some new material.

What Your Mother Never Told You About CF9 ORM

The ColdFusion team at Adobe have done an outstanding job with ColdFusion ORM, which now provides ColdFusion developers with access to Hibernate, an enterprise-ready, open source, industry-standard Java ORM. The documentation on how to use CF ORM in the ColdFusion docs is also quite good, providing most of what you need to know to make use of the features. The problem, however, is that Hibernate is a pretty complex tool, and in order to use CF ORM successfully you really need to understand certain things about Hibernate. This session is designed to teach you some of those things - it will cover material that is not included in the ColdFusion documentation, but that is essential to understand when working with the ORM.

Topics covered will include Hibernate Session Management, Understanding Object States, Working with Detached Objects, Concurrency and Using a Base Persistent Object. We'll also be looking at the new Transaction Management model in the recently released ColdFusion 9.0.1. If you plan on working with CF ORM and are not already familiar with these concepts I think you'll really benefit from this session. It is, however, an advanced session, so if you are totally unfamiliar with CF ORM you may find it a bit confusing.

The session is scheduled for 5:30pm (ouch!) on Wednesday, July 28th.

Automagic Validations for ColdFusion Objects

This session will provide an overview of, as well as a detailed how-to about a Validation framework for ColdFusion. The title is a slight misnomer, as, although the framework was originally written to work inside an object-oriented application, and remains an ideal solution for that, it has recently been enhanced to work with simple ColdFusion structures as well. This means that anyone who is looking for a better way of addressing their validation requirements, both on the client side and on the server side, can now benefit from the framework, even if they are not using objects.

The main benefit of the framework is that it will automatically generate all of your client-side and server-side validations for you, from a simple set of metadata. This frees you from the drudgery of writing similar validation code over and over again, and also eliminates the possibility of adding bugs into your application via your validation code. The framework, called ValidateThis, is being actively developed by myself and a number of other contributors, so not only is it extremely functional and flexible right now, but new features are being added continually. If you are interested in finding out more about it, including exactly how to implement it in a new or existing application (and it's dead easy), I encourage you to attend my session. It will be held at 3:15pm on Friday, July 30th, and is being repeated at 2:45pm on Saturday, July 31st.

I hope to see you at one, or both, of my sessions. If we haven't met before please come by and say hi.

ColdFusion 9.0.1 Now Available - With ORM Goodies

Tue, 13 Jul 2010 11:48:00 -0400

ColdFusion 9.0.1 is now available for download at http://www.adobe.com/go/getcf901, and, in addition to fixing a number of issues with ColdFusion 9.0, it's packed full of goodies as well. The details of all the new features can be found in the New Feature Notes, and the bug fixes and outstanding items can be found in the Release Notes. I think my favourite single new feature is the ability to do a for - in loop with an array, as looping through an array using script has always been a pain. I'm also very happy with some of the improvements to ORM. Here's a high-level summary of the new features, followed by some details on the ORM changes:

Language enhancements - including for-in loops for arrays.
New script functions implemented as CFCs - including dbinfo, imap, pop, ldap, and feed.
Caching enhancements - including the ability to get a handle on the ehCache session.
Support for IIS 7
ColdFusion Ajax enhancements - including updates cfmap, cfgrid, file uploading and JavaScript functions.
ORM enhancements - more details below.
Amazon S3 support - the ability to use Amazon S3 storage with most tags and functions that use a file or directory as input or output.
Various other enhancements covering areas such as Spreadsheets, AIR Integration, Flash Remoting, Blaze DS, Solr, Logging, Server Monitoring, and more.

ORM Enhancements

Here's a summary of the ORM enhancements in ColdFusion 9.0.1, followed by some details about each one:

Support for Multiple Datasources
Transaction Management Improvements
skipCFCWithError Flag in ormSettings
mappedSuperClass Attribute for Components
Use EntityNew to Populate a New Entity
Support for HQL in cfquery

[More]

I'll Be Presenting at NCDevcon in May

Tue, 27 Apr 2010 10:12:00 -0400

I'm tickled pink to announce that I will be presenting a couple of sessions at the upcoming NCDevCon, dubbed North Carolina's Premier Web Conference, which is being held in beautiful Raleigh, North Carolina on May 22nd and 23rd. As I discussed in a previous post NCDevCon is being organized by the Triangle Area ColdFusion User's Group and is a sequel to the hugely successful and wildly talked about CFinNC.

I will be presenting two sessions:

Getting Started with ColdFusion ORM
Creating a Twitter / Google Maps Mashup with CF and Open Source Tools

The first session is one that I have presented before, but ColdFusion ORM is an important topic and therefore the committee considered it worth presenting again. The second session will be a fun one. In it I will demonstrate how I used a number of freely available open source tools to generate a Google Map showing the locations of all of my Twitter friends. This is a project that I built some time ago, and is currently available via my site. I'll be making some updates to it prior to the conference and my hope is that the session will illustrate two points:

There are pre-existing ColdFusion open source projects that can be used to fulfill many of your application's requirements.
It's very easy to create something cool using ColdFusion.

The conference itself is still chock full of ColdFusion, Flex and AIR goodness, but also includes a healthy dose of JavaScript, CSS and other web development topics. The schedule with a full list of sessions has been published, and it's top notch. I'm particularly pleased to see some folks whom I met last year presenting this year, including Daria Norris and Jim Leether. There will also be a number of hands-on ColdFusion sessions for beginners, so if you know someone who would benefit from a bit of a ColdFusion kick-start, send them down North Carolina way.

Registration is open, and, just like last year's CFinNC, it's absolutely free. I hope to see many of you there.

Sign Up for ColdFusion ORM Training and Get a Copy of the "Hibernate Bible"

Thu, 08 Apr 2010 08:05:00 -0400

Mark Mandel, and I have decided that we're going to give a copy of the book Java Persistence with Hibernate to each and every student at our Developing Applications with ColdFusion 9 Object Relational Mapping workshop, which is running from May 20-21, 2010 in Minneapolis, MN, which also happens to be the two days immediately preceding the cf.Objective() conference.

I've discussed this two-day, hands-on workshop at length in a previous blog post, so I won't repeat myself here, but one of the goals of the course is to teach you what you need to know about Hibernate to be effective with ColdFusion 9's ORM features. Although the Adobe engineering team have done an excellent job of integrating Hibernate into ColdFusion, it is still essential to understand quite a bit about Hibernate to make appropriate use of the features. Hibernate is a complex beast, and although we'll be teaching most of what you'll need to know in the course, it's always helpful to have a reference manual handy.

There is a lot about Hibernate that is not covered in the ColdFusion documentation, and Mark and I both feel that Java Persistence with Hibernate is the best book currently available on the market about Hibernate. We want to arm our students with the tools they'll need to continue their ORM education after the workshop, which is why we've decided to give a copy of the book to each student.

There are still spaces available in the class, so if you'd like to become a ColdFusion ORM ninja in just two days, and get a free copy of the "Hibernate Bible" as well, sign up today.

Managing Bi-directional Relationships in ColdFusion ORM - Array-based Collections Follow-up

Fri, 02 Apr 2010 09:01:00 -0400

Barney Boisvert made a comment on my last post on this topic, suggesting that a nice way to reduce the amount of code one has to write, and to boost performance, would be to have one side in a bi-directional relationship simply delegate to the other side. This way you are only writing the code to do the work in one object, and it also reduces the number of hasX() calls.

I changed my code to try this technique out, and I quite like it. Because the code is slightly different I figured I might as well write about it here, to keep my posts on this topic up to date. [More]

Managing Bi-directional Relationships in ColdFusion ORM - Array-based Collections

Mon, 29 Mar 2010 06:00:00 -0400

It's important to know that when you have a bi-directional relationship you should set the relationship on both sides when setting one side. There have been a number of discussions about this on the cf-orm-dev google group, including this one in which Barney Boisvert provides a very good explanation of why this is important. Brian Kotek has also written two articles on the subject in the past. If you're not already familiar with this topic I suggest you check out those links.

The general recommendation for addressing this requirement is to override the methods in your objects that set one side of the relationship (e.g., setX(), addX() and removeX()) so that they'll set both sides, rather than just the side of the object that was invoked. While doing some testing of the new CF9 ORM adapter for Model-Glue along with the new scaffolding mechanism that we're developing I needed to address this issue for a many-to-many bi-directional relationship. I found that there were a few wrinkles that made the task not quite as straightforward as I has originally imagined, so I figured I should share what I came up with. [More]

Become a ColdFusion ORM Ninja in Just Two Days!

Tue, 09 Mar 2010 11:47:00 -0400

I've mentioned previously that Mark Mandel, the mastermind behind Transfer ORM, JavaLoader, ColdDoc, and now the lead developer of Coldspring, and I have developed an intensive, two-day, hands-on workshop on ColdFusion's new ORM features. We will be delivering that workshop, Developing Applications with ColdFusion 9 Object Relational Mapping, in Minneapolis, MN on April 20-21, 2010 which are the two days immediately preceding the cf.Objective() conference.

Really? I Can Master ColdFusion ORM in Two Days?

You bet you can! This is an extreme hands-on workshop. We won't be lecturing at you, we'll be working with you. For each concept that we cover we'll be writing code together, both the instructor and the students, working towards building a single, working application. Then, once we've done that together, you'll be let loose on your own to practice the concepts again on your very own project, which is yet another application which will be built incrementally using the concepts that you just learned. This means you'll have lots of chances to practice your newfound skills, and, more importantly, to make your own mistakes. You'll either figure out how to fix your mistakes yourself, with the help of one of your fellow students, or with the help one of the two instructors. You'll learn by doing, and what's more, you'll leave the class with lots of examples of working code that you wrote yourself.

This is why we say that we can help you master ColdFusion ORM in just two days. Not only will you be ready to start using it in your next project, but you'll also be in an ideal position to teach it to your fellow developers.

About the Instructors

I've been working with Transfer ORM for a few years, and have been working with ColdFusion's ORM integration since early in the product beta. I've blogged about it extensively, delivered a number of one-hour presentations on the subject and have created and regularly contribute to a Google group (cf-orm-dev) dedicated to discussing some of the more advanced and esoteric topics around ColdFusion's ORM integration.

As for Mark, in addition to creating his own ColdFusion-based ORM (Transfer), he's also worked extensively with Hibernate (the ORM that is integrated into ColdFusion 9) and is considered by many to be the foremost expert in all things ORM in the ColdFusion community. This therefore represents a unique opportunity to learn about this new, exciting and productivity enhancing technology from two people who know it very well, and have real-world experience developing with it.

Do I Have to Be an OO Guru to Attend?

Definitely not! We assume no prior knowledge of ORMs or Object Oriented programming, and the techniques that we teach can be used, if you wish, in a totally procedural application. So you neither need to know OO to join in, nor do you need to learn OO in order to use what you learn in your own work (although we would encourage you to do so). Some experience working with CFCs would be helpful, but we can get you up to speed pretty quickly even if you lack that.

Where is the Workshop Being Held?

As mentioned above, the workshop is running as a pre-conference training session at cf.Objective(), and will take place from April 20 - 21, 2010 at the conference hotel, which is the Hyatt Regency in Minneapolis, MN.

How Much Does it Cost?

We have made the early-bird price into a permanent discount, so although the original price was listed at $1200 for the two days you can now enroll for just $1000.

How Do I Sign Up?

You can register for the training via cf.Objective()'s registration form.

Can Anyone Attend?

Although the workshop is being offered as a cf.Objective() pre-Conference class, you don't have to attend cf.Objective() in order to enroll. So if you've having trouble getting your boss to pony up for a trip to cf.Objective(), perhaps you can convince him or her to at least send you to these two days of invaluable training.

What Topics Will Be Covered?

Here's a summary of the topics that we'll be covering:

Introduction to ORM
Introduction to Hibernate
Configuring ORM
Working with Objects
- Creating an Object
- Retrieving an Object / Lists of Objects
- Updating an Object
- Deleting an Object
- Arrays of Objects vs. Queries
Mapping Objects
- Ids and Properties
- Many-to-One Relationships
- One-to-Many Relationships
- Many-to-Many Relationships
- Formulas
- Collection Mapping
- Inheritance
- Cascade Options
Hibernate Internals
- Hibernate Sessions
- Session Flushing
  - How It Works
  - How to Control It
- Working with Transactions
- Hibernate Object State
  - Transient, Persistent and Detached
  - How Objects Move between States
Lazy Loading
- Overview
- How it Affects SQL
- Dealing with Detached Objects
Concurrency
HQL
- What is HQL?
- Basic Queries
- Criteria / Parameters
- Joins
- Pagination
- Bulk Updates
Application Architecture
- Using a Service Layer with ORM
- Using an Abstract Service
Caching
Event Handling
DDL (Database) Generation

Truly a Unique Opportunity

Although we do have plans to make the course available at other venues in the future, Mark and I live on opposite sides of the planet, and it just so happens that we'll both be attending cf.Objective() this year. It's likely that future classes will feature either Mark or I as instructors, as it's a rare occurrence that we're both in the same place at the same time, so don't miss this unique opportunity.

Looking for More Information?

I think I've covered most of what you need to know about the course in this post, but if you're looking for even more information about it please visit our web site at www.ColdFusionORMTraining.com.

ColdFusion ORM Gotcha - Non-String Struct Collection Keys

Mon, 08 Feb 2010 09:22:00 -0400

Here's another tricky issue when working with collections of child objects that are stored as structs. Just like last time, we'll look at a Department object with a one-to-many property that holds a collection of Users which is stored as a struct. The difference this time is that we'll use a numeric property as the key to the struct, rather than a string property:

component persistent="true" output="false" entityname="Department" {
	property name="DeptId" fieldtype="id" generator="native";
	property name="Name";
	property name="SIN" ormtype="int";
	property name="Users" fieldtype="one-to-many" type="struct"
		cfc="User" fkcolumn="DeptId" singularname="User"
		structkeycolumn="SIN" structkeytype="int" cascade="save-update";
}

The nice thing about having the collection of Users in a struct is that we can access them individually. For example, if we have a Department object and we know we want the User in that Department with a SIN of 12345, we could simply write: Department = entityLoad("Department",1); User = Department.getUsers()[12345];

If you're like me you'd probably think that would work, but it doesn't. [More]

Awesome Training Available Before cf.Objective()

Mon, 25 Jan 2010 15:44:00 -0400

As you're no doubt aware, cf.Objective(), "The World's Only Enterprise Engineering Conference for ColdFusion Developers", is coming to Minneapolis, MN from April 22-24, 2010. It's an outstanding opportunity to learn a ton of stuff, and to network and socialize with like-minded developers. I am pleased and honoured to be speaking, twice, for the second year in a row. What you may not realize, however, is that in the days prior to the conference there is a boatload of training available.

Developing Applications with ColdFusion 9 Object Relational Mapping

Mark Mandel and I will be delivering a comprehensive hands-on workshop on Developing Applications with ColdFusion 9 Object Relational Mapping for two whole days, from April 20-21, and it's going to be fantastic, if I do say so myself. If the new features of ColdFusion's ORM integration don't interest you (buy why wouldn't they?), there are five other choices.

Something For Everyone

Here's the full list of all of the courses available:

Building Secure CFML Applications (April 21) - Jason Dean and Pete Freitag
Coldbox:100 Training (April 21) - Luis Majano
Developing Applications with ColdFusion 9 Object Relational Mapping (ORM) (April 20-21) - Bob Silverberg and Mark Mandel
Getting Started with Flex and AIR Development with the Flex SDK (April 21) - John Mason
Mach-II and OOP from the Ground Up (April 20-21) - Kurt Weirsma, Peter Farrell and Matt Woodward
Rapid Development with Model-Glue 3 (April 20-21) - Dan Wilson and Ezra Parker

There really is something for everyone, and the instructors are all top-notch.

Anyone Can Attend

Something else you might not realize; you don't have to attend cf.Objective() in order to sign up for and attend a pre-Conference training class. So, if you've been hankering to learn more about CF9 ORM, application security, ColdBox, Model-Glue, Mach-II, or Flex and AIR development, go for it!

The Early-Bird Ends Friday

I'll close with a reminder; the discounted early-bird rates, which apply to both the cf.Objective() conference fee and to most of the pre-conference training sessions, expires this Friday, January 29th. So why not save some cash and sign up right now? Registration is done via the cf.Objective() registration form.

I hope to see many of you there in April.

More Fun with ColdFusion ORM Struct-Based Collections

Mon, 25 Jan 2010 07:28:00 -0400

Ben Nadel asked a question in a comment to my last post about struct-based collections with ColdFusion ORM which I thought was quite interesting and deserved some investigation. To recap the previous post, it simply pointed out that in order to add an object to a struct-based collection, when calling the add method one must pass both the object to be added to the collection and the key to be used in the struct. This raised a great question from Ben, whom I quote:

Does the ORM system do any validation on the Key that you pass in? Does it affect the way the data is persisted to the database (or will the persistence use the value as defined by the CFProperty structKeyColumn)?

I'd never tested this myself, so I did just that, and what I found was somewhat surprising. [More]

CF9 ORM Gotcha - Adding Items to a Struct Collection

Tue, 19 Jan 2010 22:50:00 -0400

I was just bitten by this one, so I thought I'd quickly blog it to help anyone else who comes across it. If you've got a one-to-many or a many-to-many property in your ColdFusion ORM entity, and you've specified that the collection of objects should be stored as a struct, when adding an item to that struct you must pass both the key for the item and the item itself into the add method. For example, using the following Department object:

component persistent="true" output="false" entityname="Department" {
	property name="DeptId" fieldtype="id" generator="native";
	property name="Name";
	property name="Users" fieldtype="one-to-many" type="struct"
		cfc="User" fkcolumn="DeptId" singularname="User"
		structkeycolumn="UserName" structkeytype="string" cascade="save-update";
}

Forgetting that I had to specify the key for the struct as well as the object, my first take at adding a User object to the Department's collection of Users was something like this: Department = entityLoad("Department",1); User = new User(); User.setUserName("Bob"); Department.addUser(User); entitySave(Department);

Unfortunately, this code throws an error stating "The User parameter to the ADDUSER function is required but was not passed in." Being a bit dim-witted, I was totally confused by this. "Hey," I said to my computer, "I know that I'm passing a User object into the method." It took me awhile to remember that I had to pass both key to the struct and the User object into the addUser() method. Changing the code to: Department = entityLoad("Department",1); User = new User(); User.setUserName("Bob"); Department.addUser("Bob",User); entitySave(Department);

Did the trick. So remember:

When adding an item to a collection that is a struct, you must pass both the key to the struct and the object into the add method.
You must pass the key to the struct in as the first argument, and the object as the second argument.

Conversely, when removing an item from a struct collection using the remove method, you only need specify the key to the struct. I hope this tidbit saves someone else the time that ColdFusion stole from me. ;-)

Filtering Collections in ColdFusion ORM

Tue, 19 Jan 2010 16:08:00 -0400

A question was asked on the cf-orm-dev Google Group about returning just a subset of objects that make up a collection. Specifically, the developer had a Page object and a Content object with a many-to-many relationship. A simplified version of the objects is:

Page.cfc: component persistent="true" { property name="pageId" fieldtype="id" generator="native"; property name="title"; property name="contents" fieldtype="many-to-many" cfc="content" singularname="content" linktable="page_content"; }

Content.cfc: component persistent="true" { property name="contentId" fieldtype="id" generator="native"; property name="column" ormtype="integer"; property name="pages" fieldtype="many-to-many" cfc="page" singularname="page" linktable="page_content" inverse="true"; }

Each Page can have multiple pieces of Content, and each Content block appears in a particular column on that page. Each Page can have multiple Content objects in any given column. The developer was wondering if he could do something like: Page = entityLoadByPK("Page",1); column1Contents = Page.getContents({column=1});

Which would return all of the Content objects assigned to that Page, but only those that are in column 1 (which is a property of the Content object). [More]

I'll Be Presenting at cf.Objective() in April

Thu, 07 Jan 2010 17:37:00 -0400

I am pleased and honoured to announce that I'll be presenting at cf.Objective(), billed as the Only Enterprise ColdFusion Conference, which runs from April 22-24 in Minneapolis, MN. It's going to be quite the experience for me. Not only am I speaking on two topics (details to follow in a separate post):

Easy and Flexible Validations for Objects
What Your Mother Never Told You About CF9 ORM

I'm also organizing a Pecha Kucha Birds of a Feather session (BoF), during which people will be giving mini-presentations in which they show 20 slides for 20 seconds each. I've written about this BoF on my blog previously, but I'll mention again that anyone interested in presenting should leave me a comment on my blog or email me directly at bob dot silverberg at gmail dot com.

As if that's not enough, Mark Mandel and I will be delivering a comprehensive hands-on two-day pre-conference workshop on Developing Applications with ColdFusion 9 Object Relational Mapping. A separate post with the details of that workshop will follow, but in a nutshell it is designed to give you all of the information you need to get up and running with ColdFusion 9's ORM features in your next project. You'll write a ton of code, learning the basics as well as best practices and things to watch out for. I think it's going to be a lot of fun (in addition to a great learning experience).

Registration is now open, both for the conference and for the CF9 ORM workshop (you can sign up for it during the conference registration). There is a discounted rate for both the conference and the training available until January 29th, so you might want to register sooner rather than later.

I hope to see many of you there in April.

CF9 ORM Quick Tip - Removing all items from a collection defined as a structure

Wed, 06 Jan 2010 11:20:00 -0400

I wrote a ColdFusion ORM Quick Tip awhile back on removing all items from a collection, which a number of folks were kind enough to comment on and provide even better solutions. I was recently faced with the same problem, but this time I wanted to remove all items from a collection that was defined as a structure (last time it was an array). My initial code generated an error, so I had to get creative. I'm putting this out there to see if anyone has any better ideas for doing this.

For this example, let's assume we have a User object and a Department object. The User object is defined like this: component persistent="true" output="false" entityname="User" { property name="UserId" fieldtype="id" generator="native"; property name="UserName"; }

The Department has a collection of Users, like so: component persistent="true" output="false" entityname="Department" { property name="DeptId" fieldtype="id" generator="native"; property name="Name"; property name="Users" fieldtype="one-to-many" type="struct" cfc="User" fkcolumn="DeptId" singularname="User" structkeycolumn="UserName" structkeytype="string"; }

Let's also say that Department 1 currently has 3 Users assigned to it, call them User1, User2 and User3. Now, we want to write some code that will empty the Department's collection of Users. A first attempt might look something like: Users = Department.getUsers(); for (user in Users) { Department.removeUser(user); }

Unfortunately, this code throws a java.util.ConcurrentModificationException error. A bit of Googling led me to believe that this is an issue with the way Hibernate is manipulating the collection, which is a Java HashMap. It sounds like when you're iterating over a HashMap you must ask the iterator to remove an item, rather than removing it yourself. This sounds like a bug in Hibernate, but I'd be very surprised if there were such an obvious bug in Hibernate, so maybe it has something to do with the way that Hibernate has been integrated into CF. Either way, it simply doesn't work, so I needed to come up with another way of removing all of the items from the collection.

As with my last post on the topic, the simplest way to achieve this is to call the setter for the collection and pass in an empty struct: Department.setUsers({});

The way that I ended up doing it was to use a while loop, checking whether the collection has any remaining items, and to remove the first item in the collection inside the loop. It looks like this: Users = Department.getUsers(); while (Department.hasUser()) { user = listFirst(structKeyList(Users)); Department.removeUser(user); }

As discussed in the last post, I prefer the latter approach. The first seems a bit hacky to me, although both of them require that you program to the implementation of the collection (you are writing code expecting the collection to be a structure). Also as discussed previously you could make that a bit less painful by moving the code into the actual object itself. For example, in the Department object, add the following method: function void removeAllUsers() { var Users = this.getUsers(); while (this.hasUser()) { this.removeUser(listFirst(structKeyList(Users))); } }

Now you can call removeAllUsers() from outside of the object (e.g., from a Service) and nothing other than the object will have to know that your collection has been implemented as a structure.

What other methods can people think of for achieving this?