def get(self, column, useMethod=True, **context):
        """
        Returns the value for the column for this record.

        :param      column      | <orb.Column> || <str>
                    default     | <variant>
                    inflated    | <bool>

        :return     <variant>
        """

        # look for shortcuts (dot-noted path)
        if isinstance(column, (str, unicode)) and '.' in column:
            # create the sub context
            base_context = context.copy()
            base_context['inflated'] = True

            # generate the expansion to avoid unnecessary lookups
            parts = column.split('.')

            # include the target if it is a reference
            if isinstance(self.schema().column(column), orb.ReferenceColumn):
                expand_path_index = None

            # otherwise, just get to the end column
            else:
                expand_path_index = -1

            value = self
            for i, part in enumerate(parts[:-1]):
                sub_context = base_context.copy()
                expand_path = '.'.join(parts[i+1:expand_path_index])

                try:
                    sub_expand = sub_context['expand']
                except KeyError:
                    sub_context['expand'] = expand_path
                else:
                    if isinstance(sub_expand, basestring):
                        sub_context['expand'] += ',{0}'.format(expand_path)
                    elif isinstance(sub_expand, list):
                        sub_expand.append(expand_path)
                    elif isinstance(sub_expand, dict):
                        curr = {}
                        for x in xrange(len(parts) - 1 + (expand_path_index or 0), i, -1):
                            curr = {parts[x]: curr}
                        sub_expand.update(curr)

                value = value.get(part, useMethod=useMethod, **sub_context)
                if value is None:
                    return None

            return value.get(parts[-1], useMethod=useMethod, **context)

        # otherwise, lookup a column
        else:
            my_context = self.context()

            for k, v in my_context.raw_values.items():
                if k not in orb.Context.QueryFields:
                    context.setdefault(k, v)

            sub_context = orb.Context(**context)

            # normalize the given column
            if isinstance(column, orb.Column):
                col = column
            else:
                col = self.schema().column(column, raise_=False)

                if not col:
                    if isinstance(column, orb.Collector):
                        collector = column
                    else:
                        collector = self.schema().collector(column)

                    if collector:
                        try:
                            return self.__cache[collector][sub_context]
                        except KeyError:
                            records = collector(self, useMethod=useMethod, context=sub_context)
                            self.__cache[collector][sub_context] = records
                            return records
                    else:
                        raise errors.ColumnNotFound(schema=self.schema(), column=column)

            # don't inflate if the requested value is a field
            if sub_context.inflated is None and isinstance(col, orb.ReferenceColumn):
                sub_context.inflated = column != col.field()

            # lookup the shortuct value vs. the local one (bypass for views
            # since they define tables for shortcuts)
            if col.shortcut() and not isinstance(self, orb.View):
                return self.get(col.shortcut(), **context)

            # call the getter method fot this record if one exists
            elif useMethod and col.gettermethod():
                return col.gettermethod()(self, context=sub_context)

            else:
                # ensure content is actually loaded
                if self.isRecord() and self.__delayed:
                    self.__delayed = False
                    self.read()

                # grab the current value
                with ReadLocker(self.__dataLock):
                    old_value, value = self.__values.get(col.name(), (None, None))

                # return a reference when desired
                out_value = col.restore(value, sub_context)
                if isinstance(out_value, orb.Model) and not isinstance(value, orb.Model):
                    with WriteLocker(self.__dataLock):
                        self.__values[col.name()] = (old_value, out_value)

                return out_value
Returns the value for the column for this record.

        :param      column      | <orb.Column> || <str>
                    default     | <variant>
                    inflated    | <bool>

        :return     <variant>