From b11172e4e72299d34c27eff635ad034f84a0cdb6 Mon Sep 17 00:00:00 2001
From: Justin Bronn <jbronn@gmail.com>
Date: Thu, 3 Jan 2008 19:02:18 +0000
Subject: [PATCH] gis: `LayerMapping`: Improved the internals (i.e., checking
 every feature in OGR Layer is no longer needed, removed unnecessary class
 constants); added real support `ForeignKey` model fields; added `field_types`
 property to `Layer`; fixed county shapefile because of Harris County,
 Georgia.

git-svn-id: http://code.djangoproject.com/svn/django/branches/gis@6992 bcc190cf-cafb-0310-a4f2-bffc1f526a37
---
 django/contrib/gis/gdal/layer.py              |  21 +-
 .../gis/tests/layermap/counties/counties.dbf  | Bin 2090 -> 3961 bytes
 .../gis/tests/layermap/counties/counties.shp  | Bin 41628 -> 37364 bytes
 .../gis/tests/layermap/counties/counties.shx  | Bin 300 -> 292 bytes
 django/contrib/gis/tests/layermap/models.py   |   6 +
 django/contrib/gis/tests/layermap/tests.py    |  44 +-
 django/contrib/gis/utils/layermapping.py      | 434 ++++++++++--------
 7 files changed, 289 insertions(+), 216 deletions(-)

diff --git a/django/contrib/gis/gdal/layer.py b/django/contrib/gis/gdal/layer.py
index d4d8e1b7c6..a41b28819b 100644
--- a/django/contrib/gis/gdal/layer.py
+++ b/django/contrib/gis/gdal/layer.py
@@ -5,6 +5,7 @@ from ctypes import byref
 from django.contrib.gis.gdal.envelope import Envelope, OGREnvelope
 from django.contrib.gis.gdal.error import OGRException, OGRIndexError, SRSException
 from django.contrib.gis.gdal.feature import Feature
+from django.contrib.gis.gdal.field import FIELD_CLASSES
 from django.contrib.gis.gdal.geometries import OGRGeomType
 from django.contrib.gis.gdal.srs import SpatialReference
 
@@ -12,8 +13,8 @@ from django.contrib.gis.gdal.srs import SpatialReference
 from django.contrib.gis.gdal.prototypes.ds import \
     get_extent, get_fd_geom_type, get_fd_name, get_feature, get_feature_count, \
     get_field_count, get_field_defn, get_field_name, get_field_precision, \
-    get_field_width, get_layer_defn, get_layer_srs, get_next_feature, \
-    reset_reading
+    get_field_width, get_field_type, get_layer_defn, get_layer_srs, \
+    get_next_feature, reset_reading
 from django.contrib.gis.gdal.prototypes.srs import clone_srs
 
 # For more information, see the OGR C API source code:
@@ -107,10 +108,24 @@ class Layer(object):
 
     @property
     def fields(self):
-        "Returns a list of the fields available in this Layer."
+        """
+        Returns a list of string names corresponding to each of the Fields
+        available in this Layer.
+        """
         return [get_field_name(get_field_defn(self._ldefn, i)) 
                 for i in xrange(self.num_fields) ]
     
+    @property
+    def field_types(self):
+        """
+        Returns a list of the types of fields in this Layer.  For example,
+        the list [OFTInteger, OFTReal, OFTString] would be returned for
+        an OGR layer that had an integer, a floating-point, and string
+        fields.
+        """
+        return [FIELD_CLASSES[get_field_type(get_field_defn(self._ldefn, i))]
+                for i in xrange(self.num_fields)]
+
     @property 
     def field_widths(self):
         "Returns a list of the maximum field widths for the features."
diff --git a/django/contrib/gis/tests/layermap/counties/counties.dbf b/django/contrib/gis/tests/layermap/counties/counties.dbf
index 23b9c18d0c5267ea9a1e6483a25f0b4dfa6dfbd4..ccdbb264b9365ec7d406c91a322683180177c1ca 100644
GIT binary patch
literal 3961
zcmeIxu?hk)3<ltWgOj^B<ypMJPI92T<gi1bUZB^iuj89q;iijAFoQ!nTp<^Jem>~x
zvfgc-bLd{}%g+&SVV-uMyI-uF3YK}{>;Db(H4KSB?R1nV<5e%wW6p6>>j&rXM8!CO
zeGANb{qzeSFx|scXjCexF8KEaJ&lxVs!D+1@qsaFrL`O@_$#IfnxIg?Ua=62t(zbt
c5e`gH2*%b;kdX)nCMX1B>n6xZgad8CHwdvsO8@`>

literal 2090
zcmZRMXP1&>U|?`$2n3Rtz%Ma36)Nfsq65&B@G1n9rY7a&D^L%3Bo-BA7E{kW1*#k9
zlv<HkL`4TGxF_b6r52au=TXa0svGE$pO>Fgno~+G2P%vjNO@3>hT&)!k`V%<$%c$T
KL(?+y!Vmym#5hs_

diff --git a/django/contrib/gis/tests/layermap/counties/counties.shp b/django/contrib/gis/tests/layermap/counties/counties.shp
index e2e867c449c7f71d41c61b8a7dc88b7d24b14c6f..2e7dca5e438cfbf386e92bb2a2ce06d6b86907c9 100644
GIT binary patch
delta 171
zcmV;c095~+#RBxB0+1R4Ncxc+7zcK_kr%s{SFt<C2D7RcB{Bg6v(QOL9RUQh7-x3~
z0R^*=Z`Tq52D4~_X8{2RlhA|b0SJ@0gvS91lYoVX0SdDShF1Xr3zJ}nw*d^37>K6<
z4U@o#rvVO=Xo=?m50g-e_W=--NQ<Wd5tHzX#{m+PxQxdE6O(|A=K&P6XpR>F0Tq*g
ZkH-NPlSq)40T;92kf#s<7_*3>6aixzKkxtm

delta 4466
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

diff --git a/django/contrib/gis/tests/layermap/counties/counties.shx b/django/contrib/gis/tests/layermap/counties/counties.shx
index 189450fd4825bf0634f538077d23c51df00d9eae..46ed3bb20374af403e57e83dc069b79c31757814 100644
GIT binary patch
delta 202
zcmXZVyAHu%7>DtPNF4^TIo^T6AfdEXqe*PUARWaZVi23vs9mfg27`!6BJRQ90$hv#
z7pC8PelPJ;d{>S|VWp5<J;MBRKMbAbrkI0D1la>r8<4P}wuJN)><@5*mijE9ZOK5+
zWLIA08Jw{k$-5kYoB2DD+H>D>4PO6O_l`1vjz#?!n1dSZn1@^NO|Aj|C42f+f|L&T
H=BEDz!vG-p

literal 300
zcmZQzQ0HR64yL_eW?*22$TfWON;~jCcfx`nj;0P?=Q?e-Xonu?@eaN9$jR9OyLJ>&
zBL)U$4<N2%VBiQ~VBo&Qz#u8Wz@YMsfq`!U1A}oF0|Sc%1B3Z71_sUy1_no<dWH=^
z8Ys_Dz`)=X1*8*z^gbZ%z`)?l1f*90>2*Llf`P#W<OiU+E^$zL6Oab#b5#S<6+n6s
sMBMcokWOG=aD$rX1~Lz*&K+c52apEwf$|<oKpN;?k35Kb0}g@Y0fY7|iU0rr

diff --git a/django/contrib/gis/tests/layermap/models.py b/django/contrib/gis/tests/layermap/models.py
index 4b106fc5ba..fe7604f980 100644
--- a/django/contrib/gis/tests/layermap/models.py
+++ b/django/contrib/gis/tests/layermap/models.py
@@ -1,7 +1,12 @@
 from django.contrib.gis.db import models
 
+class State(models.Model):
+    name = models.CharField(max_length=20)
+    objects = models.GeoManager()
+
 class County(models.Model):
     name = models.CharField(max_length=25)
+    state = models.ForeignKey(State)
     mpoly = models.MultiPolygonField(srid=4269) # Multipolygon in NAD83
     objects = models.GeoManager()
 
@@ -26,6 +31,7 @@ class Interstate(models.Model):
 
 # Mapping dictionaries for the models above.
 co_mapping = {'name' : 'Name',
+              'state' : {'name' : 'State'}, # ForeignKey's use another mapping dictionary for the _related_ Model (State in this case).
               'mpoly' : 'MULTIPOLYGON', # Will convert POLYGON features into MULTIPOLYGONS.
               }
 
diff --git a/django/contrib/gis/tests/layermap/tests.py b/django/contrib/gis/tests/layermap/tests.py
index 44ff980ed3..382cef56ce 100644
--- a/django/contrib/gis/tests/layermap/tests.py
+++ b/django/contrib/gis/tests/layermap/tests.py
@@ -2,8 +2,8 @@ import os, unittest
 from copy import copy
 from datetime import date
 from decimal import Decimal
-from models import City, County, CountyFeat, Interstate, city_mapping, co_mapping, cofeat_mapping, inter_mapping
-from django.contrib.gis.utils.layermapping import LayerMapping, LayerMapError, InvalidDecimal
+from models import City, County, CountyFeat, Interstate, State, city_mapping, co_mapping, cofeat_mapping, inter_mapping
+from django.contrib.gis.utils.layermapping import LayerMapping, LayerMapError, InvalidDecimal, MissingForeignKey
 from django.contrib.gis.gdal import DataSource
 
 shp_path = os.path.dirname(__file__)
@@ -111,8 +111,8 @@ class LayerMapTest(unittest.TestCase):
                 self.assertAlmostEqual(p1[0], p2[0], 6)
                 self.assertAlmostEqual(p1[1], p2[1], 6)
 
-    def test04_layermap_unique_multigeometry(self):
-        "Testing the `unique`, and `transform` keywords and geometry collection conversion."
+    def test04_layermap_unique_multigeometry_fk(self):
+        "Testing the `unique`, and `transform`, geometry collection conversion, and ForeignKey mappings."
         # All the following should work.
         try:
             # Telling LayerMapping that we want no transformations performed on the data.
@@ -135,6 +135,23 @@ class LayerMapTest(unittest.TestCase):
         # No source reference system defined in the shapefile, should raise an error.
         self.assertRaises(LayerMapError, LayerMapping, County, co_shp, co_mapping)
 
+        # Passing in invalid ForeignKey mapping parameters -- must be a dictionary
+        # mapping for the model the ForeignKey points to.
+        bad_fk_map1 = copy(co_mapping); bad_fk_map1['state'] = 'name'
+        bad_fk_map2 = copy(co_mapping); bad_fk_map2['state'] = {'nombre' : 'State'}
+        self.assertRaises(TypeError, LayerMapping, County, co_shp, bad_fk_map1, transform=False)
+        self.assertRaises(LayerMapError, LayerMapping, County, co_shp, bad_fk_map2, transform=False)
+
+        # There exist no State models for the ForeignKey mapping to work -- should raise
+        # a MissingForeignKey exception (this error would be ignored if the `strict`
+        # keyword is not set).
+        lm = LayerMapping(County, co_shp, co_mapping, transform=False, unique='name', silent=True, strict=True)
+        self.assertRaises(MissingForeignKey, lm.save)
+
+        # Now creating the state models so the ForeignKey mapping may work.
+        co, hi, tx = State(name='Colorado'), State(name='Hawaii'), State(name='Texas')
+        co.save(), hi.save(), tx.save()
+
         # If a mapping is specified as a collection, all OGR fields that
         # are not collections will be converted into them.  For example,
         # a Point column would be converted to MultiPoint. Other things being done
@@ -148,21 +165,26 @@ class LayerMapTest(unittest.TestCase):
         #    appended to the geometry collection of the unique model.  Thus,
         #    all of the various islands in Honolulu county will be in in one
         #    database record with a MULTIPOLYGON type.
-        lm = LayerMapping(County, co_shp, co_mapping, transform=False, unique='name', silent=True)
+        lm = LayerMapping(County, co_shp, co_mapping, transform=False, unique='name', silent=True, strict=True)
         lm.save()
 
         # A reference that doesn't use the unique keyword; a new database record will
         # created for each polygon.
-        lm = LayerMapping(CountyFeat, co_shp, cofeat_mapping, transform=False, silent=True)
+        lm = LayerMapping(CountyFeat, co_shp, cofeat_mapping, transform=False, silent=True, strict=True)
         lm.save()
 
         # Dictionary to hold what's expected in the shapefile.
-        exp = {'names' : ('Bexar', 'Galveston', 'Harris', 'Honolulu', 'Pueblo'),
-               'num' : (1, 2, 2, 19, 1), # Number of polygons for each.
-               }
-        for name, n in zip(exp['names'], exp['num']):
-            c = County.objects.get(name=name) # Should only be one record.
+        names = ('Bexar', 'Galveston', 'Harris', 'Honolulu', 'Pueblo')
+        nums  = (1, 2, 1, 19, 1) # Number of polygons for each.
+        states = ('Texas', 'Texas', 'Texas', 'Hawaii', 'Colorado')
+
+        for name, n, st in zip(names, nums, states):
+            # Should only be one record b/c of `unique` keyword.
+            c = County.objects.get(name=name)
             self.assertEqual(n, len(c.mpoly))
+            self.assertEqual(st, c.state.name) # Checking ForeignKey mapping.
+
+            # Multiple records because `unique` was not set.
             qs = CountyFeat.objects.filter(name=name)
             self.assertEqual(n, qs.count())
             
diff --git a/django/contrib/gis/utils/layermapping.py b/django/contrib/gis/utils/layermapping.py
index cbc94d8139..ec102f24b6 100644
--- a/django/contrib/gis/utils/layermapping.py
+++ b/django/contrib/gis/utils/layermapping.py
@@ -45,10 +45,13 @@
    encoding parameters.
 
   check:
-   By default, LayerMapping increments through each feature in the
-   layer to ensure that it is compatible with the given model and
-   mapping.  Setting this keyword to False, disables this action,
-   which will speed up execution time for very large files.
+   Due to optimizations, this keyword argument is deprecated and will
+   be removed in future revisions.
+
+  pipe:
+   Status information will be written to this file handle.  Defaults
+   to using `sys.stdout`, but any object with a `write` method is 
+   supported.
 
   silent:
    By default, non-fatal error notifications are printed to stdout; this
@@ -56,7 +59,8 @@
 
   strict:
    Setting this keyword to True will instruct the save() method to
-   cease execution on the first error encountered.
+   cease execution on the first error encountered.  The default behavior
+   is to attempt to continue even if errors are encountered.
 
   transaction_mode:
    May be 'commit_on_success' (default) or 'autocommit'.
@@ -121,64 +125,48 @@ Example:
  the layer, use the `source_srs` keyword with a SpatialReference object to
  specify one.
 """
+import sys
 from datetime import date, datetime
 from decimal import Decimal
 from django.core.exceptions import ObjectDoesNotExist
-from django.db import connection, transaction
-from django.db.models.fields.related import ForeignKey
+from django.contrib.gis.db.models.fields import GeometryField
 from django.contrib.gis.db.backend import SPATIAL_BACKEND
 from django.contrib.gis.gdal import CoordTransform, DataSource, \
     OGRException, OGRGeometry, OGRGeomType, SpatialReference
-from django.contrib.gis.gdal.field import OFTDate, OFTDateTime, OFTInteger, OFTReal, OFTString, OFTTime
+from django.contrib.gis.gdal.field import \
+    OFTDate, OFTDateTime, OFTInteger, OFTReal, OFTString, OFTTime
 from django.contrib.gis.models import GeometryColumns, SpatialRefSys
+from django.db import models, transaction
 
 # LayerMapping exceptions.
 class LayerMapError(Exception): pass
 class InvalidString(LayerMapError): pass
 class InvalidDecimal(LayerMapError): pass
+class MissingForeignKey(LayerMapError): pass
 
 class LayerMapping(object):
     "A class that maps OGR Layers to GeoDjango Models."
     
-    # A mapping of given geometry types to their OGR integer type.
-    OGC_TYPES = {'POINT' : OGRGeomType('Point'),
-                 'LINESTRING' : OGRGeomType('LineString'),
-                 'POLYGON' : OGRGeomType('Polygon'),
-                 'MULTIPOINT' : OGRGeomType('MultiPoint'),
-                 'MULTILINESTRING' : OGRGeomType('MultiLineString'),
-                 'MULTIPOLYGON' : OGRGeomType('MultiPolygon'),
-                 'GEOMETRYCOLLECTION' : OGRGeomType('GeometryCollection'),
-                 }
-
-    # The django.contrib.gis model types.
-    GIS_FIELDS = {'PointField' : 'POINT',
-                  'LineStringField': 'LINESTRING',
-                  'PolygonField': 'POLYGON',
-                  'MultiPointField' : 'MULTIPOINT',
-                  'MultiLineStringField' : 'MULTILINESTRING',
-                  'MultiPolygonField' : 'MULTIPOLYGON',
-                  'GeometryCollectionField' : 'GEOMETRYCOLLECTION',
-                  }
-
     # Acceptable 'base' types for a multi-geometry type.
-    MULTI_TYPES = {'POINT' : OGRGeomType('MultiPoint'),
-                   'LINESTRING' : OGRGeomType('MultiLineString'),
-                   'POLYGON' : OGRGeomType('MultiPolygon'),
+    MULTI_TYPES = {1 : OGRGeomType('MultiPoint'),
+                   2 : OGRGeomType('MultiLineString'),
+                   3 : OGRGeomType('MultiPolygon'),
                    }
 
-    # The acceptable Django field types that map to OGR fields.
+    # Acceptable Django field types and corresponding acceptable OGR
+    # counterparts.
     FIELD_TYPES = {
-        'AutoField' : OFTInteger,
-        'IntegerField' : OFTInteger,
-        'FloatField' : OFTReal,
-        'DateField' : OFTDate,
-        'DateTimeField' : OFTDateTime,
-        'TimeField' : OFTTime,
-        'DecimalField' : OFTReal,
-        'CharField' : OFTString,
-        'TextField' : OFTString,
-        'SmallIntegerField' : OFTInteger,
-        'PositiveSmallIntegerField' : OFTInteger,
+        models.AutoField : OFTInteger,
+        models.IntegerField : (OFTInteger, OFTReal),
+        models.FloatField : (OFTInteger, OFTReal),
+        models.DateField : OFTDate,
+        models.DateTimeField : OFTDateTime,
+        models.TimeField : OFTTime,
+        models.DecimalField : (OFTInteger, OFTReal),
+        models.CharField : OFTString,
+        models.TextField : OFTString,
+        models.SmallIntegerField : (OFTInteger, OFTReal),
+        models.PositiveSmallIntegerField : (OFTInteger, OFTReal),
         }
 
     # The acceptable transaction modes.
@@ -187,17 +175,17 @@ class LayerMapping(object):
                          }
 
     def __init__(self, model, data, mapping, layer=0, 
-                 source_srs=None, encoding=None, check=True, 
+                 source_srs=None, encoding=None, check=True, pipe=sys.stdout,
                  progress=False, interval=1000, strict=False, silent=False,
                  transaction_mode='commit_on_success', transform=True,
                  unique=False):
-        "Takes the Django model, the data source, and the mapping (dictionary)"
-
-        # Getting the field names and types from the model
-        self.fields = dict((f.name, self.map_foreign_key(f)) for f in model._meta.fields)
-        self.field_classes = dict((f.name, f) for f in model._meta.fields)
-
-        # Getting the DataSource and its Layer
+        """
+        A LayerMapping object is initialized using the given Model (not an instance),
+        a DataSource (or string path to an OGR-supported data file), and a mapping
+        dictionary.  See the module level docstring for more details and keyword
+        argument usage.
+        """
+        # Getting the DataSource and the associated Layer.
         if isinstance(data, basestring):
             self.ds = DataSource(data)
         else:
@@ -223,14 +211,16 @@ class LayerMapping(object):
             self.transform = transform
 
         # Checking the layer -- intitialization of the object will fail if
-        # things don't check out before hand.  This may be time-consuming,
-        # and disabled by setting the `check` keyword to False.
-        if check: self.check_layer()
+        # things don't check out before hand.
+        self.check_layer()
 
-        # The silent, strict, progress, and interval flags.
-        self.silent = silent
+        # The strict flag -- if it is set, exceptions will be propagated up.
         self.strict = strict
+
+        # Setting the keyword arguments related to status printing.
+        self.silent = silent
         self.progress = progress
+        self.pipe = pipe
         self.interval = interval
 
         # Setting the encoding for OFTString fields, if specified.
@@ -257,63 +247,92 @@ class LayerMapping(object):
             self.transaction_mode = transaction_mode
         else:
             raise LayerMapError('Unrecognized transaction mode: %s' % transaction_mode)
-
-    def check_feature(self, feat):
-        "Checks the OGR feature against the model fields and mapping."
-        HAS_GEO = False   
-
-        # Incrementing through each model_field & ogr_field in the given mapping.
-        for model_field, ogr_field in self.mapping.items():
-            # Making sure the given mapping model field is in the given model fields.
-            if model_field in self.fields:
-                model_type = self.fields[model_field]
-            elif model_field[:-3] in self.fields: #foreign key
-                model_type = self.fields[model_field[:-3]]
-            else:
-                raise LayerMapError('Given mapping field "%s" not in given Model fields!' % model_field)
-
-            ### Handling if we get a geometry in the Field ###
-            if ogr_field in self.OGC_TYPES:
-                # At this time, no more than one geographic field per model =(
-                if HAS_GEO:
-                    raise LayerMapError('More than one geographic field in mapping not allowed (yet).')
-                else:
-                    HAS_GEO = ogr_field
-
-                # Making sure this geometry field type is a valid Django GIS field.
-                if not model_type in self.GIS_FIELDS:
-                    raise LayerMapError('Unknown Django GIS field type "%s"' % model_type)
-
-                # Getting the OGRGeometry, it's type (an integer) and it's name (a string)
-                geom  = feat.geom
-                gtype = geom.geom_type
-                gname = geom.geom_name
-
-                if self.make_multi(gname, model_type):
-                    # Do we have to 'upsample' into a Geometry Collection?
-                    pass
-                elif gtype == self.OGC_TYPES[self.GIS_FIELDS[model_type]]:
-                    # The geometry type otherwise was expected
-                    pass
-                else:
-                    raise LayerMapError('Invalid mapping geometry; model has %s, feature has %s' % (model_type, gtype))
-            ### Handling other fields ###
-            else:
-                # Making sure the model field is supported.
-                if not model_type in self.FIELD_TYPES:
-                    raise LayerMapError('Django field type "%s" has no OGR mapping (yet).' % model_type)
-
-                # Otherwise, we've got an OGR Field.  Making sure that an
-                # index exists for the mapping OGR field.
-                try:
-                    fi = feat.index(ogr_field)
-                except:
-                    raise LayerMapError('Given mapping OGR field "%s" not in given OGR layer feature!' % ogr_field)
-
+    
+    #### Checking routines used during initialization ####
     def check_layer(self):
-        "Checks every feature in this object's layer."
-        for feat in self.layer:
-            self.check_feature(feat)
+        """
+        This checks the Layer metadata, and ensures that it is compatible
+        with the mapping information and model.  Unlike previous revisions,
+        there is no need to increment through each feature in the Layer.
+        """
+        # The geometry field of the model is set here.
+        # TODO: Support more than one geometry field / model.
+        self.geom_field = False
+        self.fields = {}
+
+        # Getting lists of the field names and the field types available in
+        # the OGR Layer.
+        ogr_fields = self.layer.fields
+        ogr_field_types = self.layer.field_types
+
+        # Function for determining if the OGR mapping field is in the Layer.
+        def check_ogr_fld(ogr_map_fld):
+            try:
+                idx = ogr_fields.index(ogr_map_fld)
+            except ValueError:
+                raise LayerMapError('Given mapping OGR field "%s" not found in OGR Layer.' % ogr_map_fld)
+            return idx
+
+        # No need to increment through each feature in the model, simply check
+        # the Layer metadata against what was given in the mapping dictionary.
+        for field_name, ogr_name in self.mapping.items():
+            # Ensuring that a corresponding field exists in the model
+            # for the given field name in the mapping.
+            try:
+                model_field = self.model._meta.get_field(field_name)
+            except models.fields.FieldDoesNotExist:
+                raise LayerMapError('Given mapping field "%s" not in given Model fields.' % field_name)
+
+            # Getting the string name for the Django field class (e.g., 'PointField').
+            fld_name = model_field.__class__.__name__
+
+            if isinstance(model_field, GeometryField):
+                if self.geom_field:
+                    raise LayerMapError('LayerMapping does not support more than one GeometryField per model.')
+
+                try:
+                    gtype = OGRGeomType(ogr_name)
+                except OGRException:
+                    raise LayerMapError('Invalid mapping for GeometryField "%s".' % field_name)
+
+                # Making sure that the OGR Layer's Geometry is compatible.
+                ltype = self.layer.geom_type
+                if not (gtype == ltype or self.make_multi(ltype, model_field)):
+                    raise LayerMapError('Invalid mapping geometry; model has %s, feature has %s.' % (fld_name, gtype))
+
+                # Setting the `geom_field` attribute w/the name of the model field
+                # that is a Geometry.
+                self.geom_field = field_name
+                fields_val = model_field
+            elif isinstance(model_field, models.ForeignKey):
+                if isinstance(ogr_name, dict):
+                    # Is every given related model mapping field in the Layer?
+                    rel_model = model_field.rel.to
+                    for rel_name, ogr_field in ogr_name.items(): 
+                        idx = check_ogr_fld(ogr_field)
+                        try:
+                            rel_field = rel_model._meta.get_field(rel_name)
+                        except models.fields.FieldDoesNotExist:
+                            raise LayerMapError('ForeignKey mapping field "%s" not in %s fields.' % 
+                                                (rel_name, rel_model.__class__.__name__))
+                    fields_val = rel_model
+                else:
+                    raise TypeError('ForeignKey mapping must be of dictionary type.')
+            else:
+                # Is the model field type supported by LayerMapping?
+                if not model_field.__class__ in self.FIELD_TYPES:
+                    raise LayerMapError('Django field type "%s" has no OGR mapping (yet).' % fld_name)
+
+                # Is the OGR field in the Layer?
+                idx = check_ogr_fld(ogr_name)
+                
+                # Can the OGR field type be mapped to the Django field type?
+                if not issubclass(ogr_field_types[idx], self.FIELD_TYPES[model_field.__class__]):
+                    raise LayerMapError('OGR field "%s" (of type %s) cannot be mapped to Django %s.' % 
+                                        (ogr_field, ogr_field_types[idx].__name__, fld_name))
+                fields_val = model_field
+        
+            self.fields[field_name] = fields_val
 
     def check_srs(self, source_srs):
         "Checks the compatibility of the given spatial reference object."
@@ -321,12 +340,12 @@ class LayerMapping(object):
             sr = source_srs
         elif isinstance(source_srs, SpatialRefSys):
             sr = source_srs.srs
-        elif isinstance(source_srs, (int, str)):
+        elif isinstance(source_srs, (int, basestring)):
             sr = SpatialReference(source_srs)
         else:
             # Otherwise just pulling the SpatialReference from the layer
             sr = self.layer.srs
-            
+        
         if not sr:
             raise LayerMapError('No source reference system defined.')
         else:
@@ -334,14 +353,6 @@ class LayerMapping(object):
 
     def check_unique(self, unique):
         "Checks the `unique` keyword parameter -- may be a sequence or string."
-        # Getting the geometry field; only the first encountered GeometryField
-        # will be used.
-        self.geom_field = False
-        for model_field, ogr_fld in self.mapping.items():
-            if ogr_fld in self.OGC_TYPES:
-                self.geom_field = model_field
-                break
-
         if isinstance(unique, (list, tuple)):
             # List of fields to determine uniqueness with
             for attr in unique: 
@@ -352,20 +363,14 @@ class LayerMapping(object):
         else:
             raise TypeError('Unique keyword argument must be set with a tuple, list, or string.')
 
-    def coord_transform(self):
-        "Returns the coordinate transformation object."
-        try:
-            # Getting the target spatial reference system
-            target_srs = SpatialRefSys.objects.get(srid=self.geo_col.srid).srs
-        
-            # Creating the CoordTransform object
-            return CoordTransform(self.source_srs, target_srs)
-        except Exception, msg:
-            raise LayerMapError('Could not translate between the data source and model geometry: %s' % msg)
-
+    #### Keyword argument retrieval routines ####
     def feature_kwargs(self, feat):
-        "Returns the keyword arguments needed for saving a feature."
-        
+        """
+        Given an OGR Feature, this will return a dictionary of keyword arguments
+        for constructing the mapped model.  Also returned is the `all_prepped`
+        flag, which is used to signal that a model corresponding to a ForeignKey
+        mapping does not exist.
+        """
         # The keyword arguments for model construction.
         kwargs = {}
 
@@ -375,37 +380,24 @@ class LayerMapping(object):
 
         # Incrementing through each model field and OGR field in the
         # dictionary mapping.
-        for model_field, ogr_field in self.mapping.items():
-            is_fk = False
-            try:
-                model_type = self.fields[model_field]
-            except KeyError: #foreign key
-                # The -3 index is b/c foreign keys are appended w/'_id'.
-                model_type = self.fields[model_field[:-3]]
-                is_fk = True
+        for field_name, ogr_name in self.mapping.items():
+            model_field = self.fields[field_name]
             
-            if ogr_field in self.OGC_TYPES:
+            if isinstance(model_field, GeometryField):
                 # Verify OGR geometry.
-                val = self.verify_geom(feat.geom, model_type)
+                val = self.verify_geom(feat.geom, model_field)
+            elif isinstance(model_field, models.base.ModelBase):
+                # The related _model_, not a field was passed in -- indicating
+                # another mapping for the related Model.
+                val = self.verify_fk(feat, model_field, ogr_name)
+                if not val: all_prepped = False
             else:
                 # Otherwise, verify OGR Field type.
-                val = self.verify_field(feat[ogr_field], model_field)
+                val = self.verify_ogr_field(feat[ogr_name], model_field)
 
-            if is_fk:
-                # Handling if foreign key.
-                rel_obj = None
-                field_name = model_field[:-3]
-                try:
-                    # FIXME: refactor to efficiently fetch FKs.
-                    #  Requires significant re-work. :-/
-                    rel = self.model._meta.get_field(field_name).rel
-                    rel_obj = rel.to._default_manager.get(**{('%s__exact' % rel.field_name):val})
-                except ObjectDoesNotExist:
-                    all_prepped = False
-
-                kwargs[model_field[:-3]] = rel_obj
-            else:
-                kwargs[model_field] = val
+            # Setting the keyword arguments for the field name with the
+            # value obtained above.
+            kwargs[field_name] = val
             
         return kwargs, all_prepped
 
@@ -420,29 +412,29 @@ class LayerMapping(object):
         else:
             return dict((fld, kwargs[fld]) for fld in self.unique)
 
-    def verify_field(self, fld, model_field):
+    #### Verification routines used in constructing model keyword arguments. ####
+    def verify_ogr_field(self, ogr_field, model_field):
         """
         Verifies if the OGR Field contents are acceptable to the Django
         model field.  If they are, the verified value is returned, 
         otherwise the proper exception is raised.
         """
-        field_class = self.field_classes[model_field]
-        if isinstance(fld, OFTString):
+        if isinstance(ogr_field, OFTString):
             if self.encoding:
                 # The encoding for OGR data sources may be specified here
                 # (e.g., 'cp437' for Census Bureau boundary files).
-                val = unicode(fld.value, self.encoding)
+                val = unicode(ogr_field.value, self.encoding)
             else:
-                val = fld.value
-                if len(val) > field_class.max_length:
+                val = ogr_field.value
+                if len(val) > model_field.max_length:
                     raise InvalidString('%s model field maximum string length is %s, given %s characters.' %
-                                        (model_field, field_class.max_length, len(val)))
-        elif isinstance(fld, OFTReal):
+                                        (model_field.name, model_field.max_length, len(val)))
+        elif isinstance(ogr_field, OFTReal):
             try:
                 # Creating an instance of the Decimal value to use.
-                d = Decimal(str(fld.value))
+                d = Decimal(str(ogr_field.value))
             except:
-                raise InvalidDecimal('Could not construct decimal from: %s' % fld)
+                raise InvalidDecimal('Could not construct decimal from: %s' % ogr_field)
 
             # Getting the decimal value as a tuple.
             dtup = d.as_tuple()
@@ -450,7 +442,7 @@ class LayerMapping(object):
             d_idx = dtup[2] # index where the decimal is
 
             # Maximum amount of precision, or digits to the left of the decimal.
-            max_prec = field_class.max_digits - field_class.decimal_places
+            max_prec = model_field.max_digits - model_field.decimal_places
 
             # Getting the digits to the left of the decimal place for the 
             # given decimal.
@@ -463,17 +455,43 @@ class LayerMapping(object):
             # InvalidDecimal exception.
             if n_prec > max_prec:
                 raise InvalidDecimal('A DecimalField with max_digits %d, decimal_places %d must round to an absolute value less than 10^%d.' %
-                                     (field_class.max_digits, field_class.decimal_places, max_prec))
+                                     (model_field.max_digits, model_field.decimal_places, max_prec))
             val = d
         else:
-            val = fld.value
+            val = ogr_field.value
         return val
 
-    def verify_geom(self, geom, model_type):
-        "Verifies the geometry."
-        if self.make_multi(geom.geom_name, model_type):
+    def verify_fk(self, feat, rel_model, rel_mapping):
+        """
+        Given an OGR Feature, the related model and its dictionary mapping,
+        this routine will retrieve the related model for the ForeignKey
+        mapping.
+        """
+        # TODO: It is expensive to retrieve a model for every record --
+        #  explore if an efficient mechanism exists for caching related 
+        #  ForeignKey models.
+
+        # Constructing and verifying the related model keyword arguments.
+        fk_kwargs = {}
+        for field_name, ogr_name in rel_mapping.items():
+            fk_kwargs[field_name] = self.verify_ogr_field(feat[ogr_name], rel_model._meta.get_field(field_name))
+
+        # Attempting to retrieve and return the related model.
+        try:
+            return rel_model.objects.get(**fk_kwargs)
+        except ObjectDoesNotExist:
+            if self.strict: raise MissingForeignKey('No %s model found with keyword arguments: %s' % (rel_model.__name__, fk_kwargs))
+            else: return None
+
+    def verify_geom(self, geom, model_field):
+        """
+        Verifies the geometry -- will construct and return a GeometryCollection
+        if necessary (for example if the model field is MultiPolygonField while
+        the mapped shapefile only contains Polygons).
+        """
+        if self.make_multi(geom.geom_type, model_field):
             # Constructing a multi-geometry type to contain the single geometry
-            multi_type = self.MULTI_TYPES[geom.geom_name]
+            multi_type = self.MULTI_TYPES[geom.geom_type.num]
             g = OGRGeometry(multi_type)
             g.add(geom)
         else:
@@ -486,7 +504,19 @@ class LayerMapping(object):
         
         # Returning the WKT of the geometry.
         return g.wkt
-        
+
+    #### Other model methods ####
+    def coord_transform(self):
+        "Returns the coordinate transformation object."
+        try:
+            # Getting the target spatial reference system
+            target_srs = SpatialRefSys.objects.get(srid=self.geo_col.srid).srs
+
+            # Creating the CoordTransform object
+            return CoordTransform(self.source_srs, target_srs)
+        except Exception, msg:
+            raise LayerMapError('Could not translate between the data source and model geometry: %s' % msg)
+
     def geometry_column(self):
         "Returns the GeometryColumn model associated with the geographic column."
         # Getting the GeometryColumn object.
@@ -498,24 +528,23 @@ class LayerMapping(object):
         except Exception, msg:
             raise LayerMapError('Geometry column does not exist for model. (did you run syncdb?):\n %s' % msg)
 
-    def make_multi(self, geom_name, model_type):
-        "Determines whether the geometry should be made into a GeometryCollection."
-        return (geom_name in self.MULTI_TYPES) and (model_type.startswith('Multi'))
-
-    def map_foreign_key(self, django_field):
-        "Handles fields within foreign keys for the given field."
-        if not django_field.__class__ is ForeignKey:
-            # Returning the field's class name.
-            return django_field.__class__.__name__
-        else:
-            # Otherwise, getting the type of the related field's
-            # from the Foreign key.
-            rf = django_field.rel.get_related_field()
-            return rf.get_internal_type()
+    def make_multi(self, geom_type, model_field):
+        """
+        Given the OGRGeomType for a geometry and its associated GeometryField, 
+        determine whether the geometry should be turned into a GeometryCollection.
+        """
+        return (geom_type.num in self.MULTI_TYPES and 
+                model_field.__class__.__name__ == 'Multi%s' % geom_type.django)
 
     def save(self, verbose=False):
-        "Runs the layer mapping on the given SHP file, and saves to the database."
-        
+        """
+        Saves the contents from the OGR DataSource Layer into the database
+        according to the mapping dictionary given at initialization. If
+        the `verbose` keyword is set, information will be printed subsequent
+        to each model save executed on the database.
+        """
+        # Defining the 'real' save method, utilizing the transaction 
+        # decorator created during initialization.
         @self.transaction_decorator
         def _save():
             num_feat = 0
@@ -530,7 +559,7 @@ class LayerMapping(object):
                     # Something borked the validation
                     if self.strict: raise
                     elif not self.silent: 
-                        print 'Ignoring Feature ID %s because: %s' % (feat.fid, msg)
+                        self.pipe.write('Ignoring Feature ID %s because: %s\n' % (feat.fid, msg))
                 else:
                     # Constructing the model using the keyword args
                     if all_prepped:
@@ -561,7 +590,7 @@ class LayerMapping(object):
                             # Attempting to save.
                             m.save()
                             num_saved += 1
-                            if verbose: print 'Saved: %s' % m
+                            if verbose: self.pipe.write('Saved: %s\n' % m)
                         except SystemExit:
                             raise
                         except Exception, msg:
@@ -572,17 +601,18 @@ class LayerMapping(object):
                             if self.strict: 
                                 # Bailing out if the `strict` keyword is set.
                                 if not self.silent:
-                                    print 'Failed to save the feature (id: %s) into the model with the keyword arguments:' % feat.fid
-                                    print kwargs
+                                    self.pipe.write('Failed to save the feature (id: %s) into the model with the keyword arguments:\n' % feat.fid)
+                                    self.pipe.write('%s\n' % kwargs)
                                 raise
                             elif not self.silent:
-                                print 'Failed to save %s:\n %s\nContinuing' % (kwargs, msg)
+                                self.pipe.write('Failed to save %s:\n %s\nContinuing\n' % (kwargs, msg))
                     else:
-                        print 'Skipping %s due to missing relation.' % kwargs
+                        if not self.silent: self.pipe.write('Skipping due to missing relation:\n%s\n' % kwargs)
+                        
 
                 # Printing progress information, if requested.
                 if self.progress and num_feat % self.interval == 0:
-                    print 'Processed %d features, saved %d ...' % (num_feat, num_saved)
+                    self.pipe.write('Processed %d features, saved %d ...\n' % (num_feat, num_saved))
                
         # Calling our defined function, which will use the specified
         # trasaction mode.