code: def column(self, key, recurse=True, flags=0, raise_=True):
          
          if isinstance(key, orb.Column):
              return key
          else:
              cache_key = (key, recurse, flags)
              try:
                  last_column = self.__cache[cache_key]
              except KeyError:
  
                  parts = key.split('.')
                  schema = self
                  last_column = None
  
                  for part in parts:
                      cols = schema.columns(recurse=recurse, flags=flags)
                      found = None
  
                      for column in cols.values():
                          if part in (column.name(), column.field()):
                              found = column
                              break
  
                      if found is None:
                          break
  
                      elif isinstance(found, orb.ReferenceColumn):
                          schema = found.referenceModel().schema()
  
                      last_column = found
  
                  self.__cache[cache_key] = last_column
  
              # return the column response
              if last_column is not None:
                  return last_column
              elif raise_:
                  raise orb.errors.ColumnNotFound(schema=self, column=key)
              else:
                  return None
docs: Returns the column instance based on its name.  
          If error reporting is on, then the ColumnNotFound
          error will be thrown the key inputted is not a valid
          column name.
          
          :param      key     | <str> || <orb.Column> || <list>
                      recurse | <bool>
                      flags   | <int>
  
          :return     <orb.Column> || None