Changeset 903

Timestamp:

01/25/12 17:57:40 (16 months ago)

Author:

jjr8

Message:

* Incremented build number
* Continuing work on SpatiaLite? support
* Added OSU mesoscale eddies class

Location:

MGET/Branches/Jason/PythonPackage/src/GeoEco

Files:

• AggregatedModules/pyspatialite/dbapi2.py (modified) (1 diff)
• DataProducts/OSU (added)
• DataProducts/OSU/MesoscaleEddies.py (added)
• DataProducts/OSU/__init__.py (added)
• Datasets/ArcGIS.py (modified) (9 diffs)
• Datasets/Collections.py (modified) (1 diff)
• Datasets/SpatiaLite.py (modified) (31 diffs)
• Datasets/Virtual.py (modified) (1 diff)
• Datasets/__init__.py (modified) (13 diffs)
• __init__.py (modified) (1 diff)

MGET/Branches/Jason/PythonPackage/src/GeoEco/AggregatedModules/pyspatialite/dbapi2.py

@@ -61 +61 @@
 
     def convert_date(val):
-        return datetime.date(*map(int, val.split("-")))
+        return datetime.date(*map(int, val.split(" ")[0].split("-")))
 
     def convert_timestamp(val):

MGET/Branches/Jason/PythonPackage/src/GeoEco/Datasets/ArcGIS.py

@@ -23 +23 @@
 
 from GeoEco.ArcGIS import GeoprocessorManager
-from GeoEco.Datasets import CollectibleObject, Dataset, DatasetCollection, QueryableAttribute, Grid, Table, Field, SelectCursor, UpdateCursor, InsertCursor
+from GeoEco.Datasets import CollectibleObject, Dataset, DatasetCollection, QueryableAttribute, Grid, Database, Table, Field, SelectCursor, UpdateCursor, InsertCursor
 from GeoEco.Datasets.Collections import DatasetCollectionTree
 from GeoEco.Datasets.GDAL import GDALDataset, GDALRasterBand
@@ -377 +377 @@
 
 
-class ArcGISWorkspace(DatasetCollectionTree):
+class ArcGISWorkspace(DatasetCollectionTree, Database):
     __doc__ = DynamicDocString()
 
@@ -435 +435 @@
     def _GetDisplayName(self):
         return self._DisplayName
+
+    @classmethod
+    def _TestCapability(cls, capability):
+        if capability in ['createtable', 'deletetable']:
+            return None
+
+        capList = capability.split(' ', 2)
+        if len(capList) == 3 and capList[0] == 'geometrytype':
+            if capList[1] in ['point', 'point25d', 'linestring', 'linestring25d', 'polygon', 'polygon25d', 'multipoint', 'multipoint25d', 'multilinestring', 'multilinestring25d', 'multipolygon', 'multipolygon25d']:
+                return None
+            return RuntimeError(_(u'Cannot create table %(table)s with "%(geom)s" geometry in %(dn)s. ArcGIS does not support that geometry type.') % {u'tableName': capList[2], u'geom': capList[1], u'dn': cls._DisplayName})
+        
+        if isinstance(cls, ArcGISWorkspace):
+            return RuntimeError(_(u'The %(cls)s class does not support the "%(cap)s" capability.') % {u'cls': cls.__class__.__name__, u'cap': capability})
+        return RuntimeError(_(u'The %(cls)s class does not support the "%(cap)s" capability.') % {u'cls': cls.__name__, u'cap': capability})
 
     def _ListContents(self, pathComponents):
@@ -601 +616 @@
     def _ImportDatasetsToPath(self, pathComponents, sourceDatasets, mode, progressReporter, options):
         self.DatasetType._ImportDatasetsToPath(os.path.join(self.Path, *pathComponents), sourceDatasets, mode, progressReporter, options)
+
+    # Overridden methods of Database
+
+    def ImportTable(self, destTableName, sourceTable, fields=None, where=None, orderBy=None, rowCount=None, reportProgress=True, rowDescriptionSingular=None, rowDescriptionPlural=None, copiedOIDFieldName=None, allowSafeCoercions=True):
+
+        # First call the base class method to actually do the import.
+
+        table = super(ArcGISWorkspace, self).ImportTable(destTableName, sourceTable, fields, where, orderBy, rowCount, reportProgress, rowDescriptionSingular, rowDescriptionPlural, copiedOIDFieldName, allowSafeCoercions)
+
+        # Now, if the resulting table has a geometry column, check
+        # whether it has a spatial index. If not, create one. We do
+        # this specifically because I have noticed that sometimes for
+        # shapefiles, ArcGIS appears to discard the spatial index that
+        # was requested in the call to CreateFeatureClass_management.
+        # I have not determined whether it is caused by subsequently
+        # adding fields, by adding records, or what.
+
+        if table.GeometryType is not None:
+            gp = GeoprocessorManager.GetWrappedGeoprocessor()
+            d = gp.Describe(table._GetFullPath())
+
+            if hasattr(d, 'HasSpatialIndex') and not d.HasSpatialIndex:
+                if reportProgress:
+                    self._LogInfo(_(u'Adding a spatial index to %(dn)s.') % {u'dn': table.DisplayName})
+                else:
+                    self._LogDebug(_(u'Adding a spatial index to %(dn)s.') % {u'dn': table.DisplayName})
+                    
+                gp.AddSpatialIndex(table._GetFullPath(), 0, 0, 0)
+
+        # Return successfully.
+
+        return table
+
+    def _TableExists(self, tableName):
+        gp = GeoprocessorManager.GetWrappedGeoprocessor()
+        return gp.Exists(os.path.join(self._Path, tableName))
+
+    def _CreateTable(self, tableName, geometryType, spatialReference, geometryFieldName):
+
+        # If the caller did not specify a geometryType, create a
+        # regular table.
+
+        gp = GeoprocessorManager.GetWrappedGeoprocessor()
+        if geometryType is None:
+            gp.CreateTable_management(self._Path, tableName)
+
+        # Otherwise create a feature class.
+
+        else:
+            geometryType = geometryType.upper()
+
+            hasZ = {False: 'DISABLED', True: 'ENABLED'}[geometryType[-3:] == u'25D']
+            
+            if geometryType in [u'POINT', u'POINT25D']:
+                geometryType = u'POINT'
+            elif geometryType in [u'MULTIPOINT', u'MULTIPOINT25D']:
+                geometryType = u'MULTIPOINT'
+            elif geometryType in [u'LINESTRING', u'MULTILINESTRING', u'LINESTRING25D', u'MULTILINESTRING25D']:
+                geometryType = u'POLYLINE'
+            elif geometryType in [u'POLYGON', u'MULTIPOLYGON', u'POLYGON25D', u'MULTIPOLYGON25D']:
+                geometryType = u'POLYGON'
+
+            srString = Dataset.ConvertSpatialReference('Obj', spatialReference, 'ArcGIS')
+
+            gp.CreateFeatureClass_management(self._Path, tableName, geometryType, None, 'DISABLED', hasZ, srString, None, 0, 0, 0)
+
+        # Return an ArcGISTable instance for the new table.
+
+        return ArcGISTable(os.path.join(self._Path, tableName))
+
+    def _DeleteTable(self, tableName):
+        gp = GeoprocessorManager.GetWrappedGeoprocessor()
+        return gp.Delete_management(os.path.join(self._Path, tableName))
     
 
@@ -1535 +1623 @@
 
 
-class ArcGISTable(Table):
+class ArcGISTable(Table, ArcGISCopyableTable):
     __doc__ = DynamicDocString()
  
@@ -1792 +1880 @@
         GeoprocessorManager.GetWrappedGeoprocessor().DefineProjection_management(self._GetFullPath(), sr)
 
+    def GetArcGISCopyablePath(self):
+        return self._GetFullPath()
+
     def _AddField(self, name, dataType, length, precision, isNullable):
         if dataType == 'int16':
@@ -1866 +1957 @@
             raise ValueError(_(u'Cannot import %(count)i datasets into ArcGIS table or feature class "%(path)s". Importing of multiple datasets into a single table or feature class is not currently supported. If you are receiving this error from a tool that has a parameter that is a list of expressions that define the output dataset namen, you may have made a mistake in your expressions that caused the same output dataset name to be generated for multiple input datasets. If that is the problem, you can fix it by modifying the expressions to generate a unique output dataset name for each input dataset.') % {u'count': len(sourceDatasets), u'path': path})
 
-        # Validate that the source dataset is importable.
-        #
-        # TODO: Implement support for Table instances that are not
-        # ArcGISCopyableTable instances. (That is a lot of work
-        # because we have to create the destination table and its
-        # fields and then copy each row one at a time.)
-        
-        if not isinstance(sourceDatasets[0], ArcGISCopyableTable):
-            raise TypeError(_(u'Cannot import %(dn)s into ArcGIS table or feature class "%(path)s" because it is a %(type)s, which is not an ArcGISCopyableTable. At this time, only ArcGISCopyableTable can be imported.') % {u'dn': sourceDatasets[0].DisplayName, u'path': path, u'type': dataset.__class__.__name__})
-
         # If the mode is 'replace' and the destination dataset exists,
         # delete it.
@@ -1965 +2046 @@
                 raise NotImplementedError(_(u'Cannot import %(dn)s into destination ArcGIS table or feature class "%(path)s" because that destination is not a folder, personal geodatabase, or file geodatabase. Other destinations (e.g. ArcSDE geodatabases) are not fully supported. Please contact the author of this tool for assistance.') % {u'dn': sourceDatasets[0].DisplayName, u'path': path})
 
-        # Import the dataset.
+        # At this point, the parent workspace of the destination
+        # dataset exists, and the destination dataset does not exist.
+        # If the source dataset is copyable with ArcGIS's
+        # Copy_management tool, use it because it will be much faster
+        # than manually copying each row.
 
         if isinstance(sourceDatasets[0], ArcGISCopyableTable):
@@ -1974 +2059 @@
             finally:
                 sourceDatasets[0].Close()       # This will make sure it deletes temporary files, if it had to create any in order to make itself ArcGIS-copyable.
+
+        # Otherwise copy the rows manually. This will work with any
+        # Table instance.
+
+        else:
+            workspace = ArcGISWorkspace(os.path.dirname(path), ArcGISTable, pathParsingExpressions=[r'(?P<TableName>.+)'], queryableAttributes=(QueryableAttribute(u'TableName', _(u'Table name'), UnicodeStringTypeMetadata()),))
+            workspace.ImportTable(os.path.basename(path), sourceDatasets[0], reportProgress=False)
+
+        # Report progress.
             
-            if progressReporter is not None:
-                progressReporter.ReportProgress()
-
-        else:
-            raise TypeError(_(u'Cannot import %(dn)s into ArcGIS table or feature class "%(path)s" because it is a %(type)s, which is not an ArcGISCopyableTable. At this time, only ArcGISCopyableTable can be imported.') % {u'dn': sourceDatasets[0].DisplayName, u'path': path, u'type': dataset.__class__.__name__})
+        if progressReporter is not None:
+            progressReporter.ReportProgress()
 
 

MGET/Branches/Jason/PythonPackage/src/GeoEco/Datasets/Collections.py

@@ -809 +809 @@
             localPath = None
 
-        if localPath is not None and not os.path.splitext(localPath)[1] in [u'.bz2', u'.gz', u'.tar', u'.z', u'.zip'] and os.path.exists(localPath):
+        if localPath is not None and os.path.splitext(localPath)[1] not in [u'.bz2', u'.gz', u'.tar', u'.z', u'.zip'] and os.path.exists(localPath):
             return localPath, True
 

MGET/Branches/Jason/PythonPackage/src/GeoEco/Datasets/SpatiaLite.py

@@ -65 +65 @@
         super(PySpatiaLiteDependency, self).Initialize()
 
+        # Log a message giving version numbers.
+
+        from GeoEco.Logging import Logger
+        from pyspatialite import dbapi2 as spatialite
+
+        conn = spatialite.connect(':memory:')
+        try:
+            row = conn.execute('SELECT sqlite_version(), spatialite_version();').fetchone()
+            Logger.Debug(_(u'Initialized SQLite version %(v1)s and SpatiaLite version %(v2)s.') % {u'v1': row[0], u'v2': row[1]})
+        finally:
+            conn.close()
+
 
 class SpatiaLiteDatabase(FileDatasetCollection, Database):
     __doc__ = DynamicDocString()
+
+    def _GetConnection(self):
+        self._Open()
+        return self._Connection
+
+    Connection = property(_GetConnection, doc=DynamicDocString())
 
     def __init__(self, path, timeout=5., isolation_level=None, detect_types=sqlite3.PARSE_DECLTYPES|sqlite3.PARSE_COLNAMES, decompressedFileToReturn=None, displayName=None, parentCollection=None, queryableAttributes=None, queryableAttributeValues=None, lazyPropertyValues=None, cacheDirectory=None):
@@ -162 +180 @@
 
         self._Open()
-        tableNames = [row['name'] for row in self._Connection.execute("SELECT name FROM sqlite_master WHERE type='table' AND name NOT IN ('spatial_ref_sys', 'spatialite_history', 'sqlite_sequence', 'geometry_columns', 'views_geometry_columns', 'virts_geometry_columns', 'geometry_columns_auth', 'SpatialIndex')")]
+        tableNames = [row['name'] for row in self._Connection.execute("SELECT name FROM sqlite_master WHERE type='table' AND name NOT GLOB 'idx_?*_?*' AND name NOT IN ('spatial_ref_sys', 'spatialite_history', 'sqlite_sequence', 'geometry_columns', 'views_geometry_columns', 'virts_geometry_columns', 'geometry_columns_auth', 'SpatialIndex')")]
         datasetsFound = []
 
@@ -180 +198 @@
 
             if result:
-                datasetsFound.append(SpatiaLiteTable(self, tableName[i]))
+                datasetsFound.append(SpatiaLiteTable(self, tableNames[i]))
                 if progressReporter is not None:
                     progressReporter.ReportProgress()
@@ -192 +210 @@
         return self._Connection.execute("SELECT COUNT(*) FROM sqlite_master WHERE name=?;", (tableName,)).fetchone()[0] > 0
 
-    def _CreateTable(self, tableName, geometryType=None, spatialReference=None, geometryFieldName=u'geometry'):
+    def _CreateTable(self, tableName, geometryType, spatialReference, geometryFieldName):
 
         # Create the table. The CREATE TABLE statement requires at
@@ -316 +334 @@
 
     def _DeleteTable(self, tableName):
+
+        # Disable the SpatiaLite spatial index and geometry columns,
+        # if they exist. We have to do this explicitly first because
+        # the DROP TABLE statement does not accomplish it.
+        
         self._Open()
+
+        for row in self._Connection.execute("SELECT f_geometry_column, spatial_index_enabled FROM geometry_columns WHERE f_table_name = '%s';" % tableName):
+            if bool(row['spatial_index_enabled']):
+                sql = "SELECT DisableSpatialIndex('%s', '%s');" % (tableName, row['f_geometry_column'])
+                self._LogDebug(_(u'%(class)s 0x%(id)08X: Executing: %(sql)s'), {u'class': self.__class__.__name__, u'id': id(self), u'sql': sql})
+                self._Connection.execute(sql)
+
+                sql = "DROP TABLE idx_%s_%s;" % (tableName, row['f_geometry_column'])
+                self._LogDebug(_(u'%(class)s 0x%(id)08X: Executing: %(sql)s'), {u'class': self.__class__.__name__, u'id': id(self), u'sql': sql})
+                self._Connection.execute(sql)
+                
+            sql = "SELECT DiscardGeometryColumn('%s', '%s');" % (tableName, row['f_geometry_column'])
+            self._LogDebug(_(u'%(class)s 0x%(id)08X: Executing: %(sql)s'), {u'class': self.__class__.__name__, u'id': id(self), u'sql': sql})
+            self._Connection.execute(sql)
+
+        # Drop the table.
+        
         sql = "DROP TABLE %s;" % tableName
         self._LogDebug(_(u'%(class)s 0x%(id)08X: Executing: %(sql)s'), {u'class': self.__class__.__name__, u'id': id(self), u'sql': sql})
@@ -333 +373 @@
             # downloaded and/or decompressed.
 
-            if self.Path == u':memory:':
+            if self.Path == u':memory:' or not os.path.exists(self.Path):
                 path = self.Path
                 isOriginalFile = True
@@ -364 +404 @@
 
             if self.Path == u':memory:':
-                self._DisplayName = _(u'SpatiaLite in-memory database 0x%(id)08X') % {u'path': path, u'oldpath': self.Path, u'id': id(self._Connection)}
-                self._LogDebug(_(u'%(class)s 0x%(id)08X: Created new %(dn)s.'), {u'class': self.__class__.__name__, u'id': id(self), u'dn': self._DisplayName})
+                if not self._CallerProvidedDisplayName:
+                    self._DisplayName = _(u'SpatiaLite in-memory database 0x%(id)08X') % {u'id': id(self._Connection)}
+                    self._LogDebug(_(u'%(class)s 0x%(id)08X: Created new %(dn)s.'), {u'class': self.__class__.__name__, u'id': id(self), u'dn': self._DisplayName})
+                else:
+                    self._LogDebug(_(u'%(class)s 0x%(id)08X: Created new SpatiaLite in-memory database 0x%(id2)08X, hereafter referred to as "%(dn)s".'), {u'class': self.__class__.__name__, u'id': id(self), u'id2': id(self._Connection), u'dn': self._DisplayName})
 
             # If this database does not have a table named
@@ -387 +430 @@
     ######################### TODO: All methods below here need to be checked #########################
 
+##    @classmethod
+##    def _RemoveExistingDatasetsFromList(cls, path, datasets, progressReporter):
+##        numDatasets = len(datasets)
+##
+##        if path != ':memory:' and not os.path.exists(path):
+##            cls._LogDebug(_(u'%(class)s: SpatiaLite database "%(path)s" does not exist.'), {u'class': cls.__name__, u'path': path})
+##            while len(datasets) > 0:
+##                del datasets[0]
+##        else:
+##            from pyspatialite import dbapi2 as spatialite
+##
+##            try:
+##                conn = pyspatialite.connect(path)
+##            except Exception, e:
+##                raise RuntimeError(_(u'The file %(path)s exists but it could not be opened as a SpatiaLite database. Detailed error information: pyspatialite.connect failed with %(e)s: %(msg)s.') % {u'path': path, u'e': e.__class__.__name__, u'msg': self._Str(e)})
+##
+##            try:
+##                i = 0
+##                while i < len(datasets):
+##                    tableName = datasets[i].GetQueryableAttributeValue(u'TableName')
+##                    if tableName is None:
+##                        if path == ':memory:':
+##                            raise RuntimeError(_(u'Cannot import %(dn)s into a SpatiaLite in-memory database because that dataset does not have a value for the TableName queryable attribute. In order to import a dataset into a SpatiaLite database, the dataset must have a value for that queryable attribute.') % {u'dn': datasets[i].DisplayName})
+##                        raise RuntimeError(_(u'Cannot import %(dn)s into SpatiaLite database %(path)s because that dataset does not have a value for the TableName queryable attribute. In order to import a dataset into a SpatiaLite database, the dataset must have a value for that queryable attribute.') % {u'dn': datasets[i].DisplayName, u'path': path})
+##                    
+##                    if conn.execute("SELECT COUNT(*) FROM sqlite_master WHERE name=?;", (tableName,)).fetchone()[0] > 0:
+##                        if path != ':memory:':
+##                            cls._LogDebug(_(u'%(class)s: Table %(table)s exists in SpatiaLite database %(path)s.'), {u'class': cls.__name__, u'table': tableName, u'path': path})
+##                        del datasets[i]
+##                    else:
+##                        i += 1
+##            finally:
+##                conn.close()
+##
+##        if progressReporter is not None:
+##            progressReporter.ReportProgress(numDatasets)
+##
+##    @classmethod
+##    def _ImportDatasetsToPath(cls, path, sourceDatasets, mode, progressReporter, options):
+##
+##        # If path is not ":memory:" it is a file. If that file does
+##        # not exist, create the parent directories, if they do not
+##        # exist already.
+##
+##        if path != ':memory:' and not os.path.isfile(path) and (path[0] in ['/', '\\'] or hasattr(os.path, 'splitdrive') and os.path.splitdrive(path)[0] != '' or hasattr(os.path, 'splitunc') and os.path.splitunc(path)[0] != '') and not os.path.isdir(os.path.dirname(path)):
+##            cls._LogDebug(_(u'%(class)s: Creating directory "%(path)s".'), {u'class': cls.__name__, u'path': os.path.dirname(path)})
+##            try:
+##                os.makedirs(os.path.dirname(path))
+##            except Exception, e:
+##                raise RuntimeError(_(u'Failed to create directory "%(path)s". Python\'s os.makedirs function failed and reported %(e)s: %(msg)s') % {u'path': os.path.dirname(path), u'e': e.__class__.__name__, u'msg': cls._Unicode(e)})
+##
+##        # Open the SpatiaLite database. This will create it if it doesn't
+##        # exist already. Then import each dataset into it.
+##
+##        database = SpatiaLiteDatabase(path)
+##        try:
+##            for dataset in sourceDatasets:
+##                cls._ImportTableToDatabase(dataset, database, mode, progressReporter)
+##        finally:
+##            db.Close()
+##
+##    @classmethod
+##    def _ImportTableToDatabase(cls, dataset, database, mode, progressReporter):
+##
+##        # Perform additional validation.
+##
+##        if not isinstance(dataset, Table):
+##            raise ValueError(_(u'Cannot import %(dn1)s into %(dn2)s because the former is not a Table instance. Only Tables can be imported into SpatiaLite databases.') % {u'dn1': dataset.DisplayName, u'dn2': database.DisplayName})
+##
+##        tableName = dataset.GetQueryableAttributeValue(u'TableName')
+##        if tableName is None:
+##            raise RuntimeError(_(u'Cannot import %(dn1)s into %(dn2)s because the former does not have a value for the TableName queryable attribute. In order to import a dataset into a SpatiaLite database, the dataset must have a value for that queryable attribute.') % {u'dn1': dataset.DisplayName, u'dn2': database.DisplayName})
+##
+##        # If the table already exists and the mode is 'replace',
+##        # delete it (otherwise raise an error).
+##
+##        if database._Connection.execute("SELECT COUNT(*) FROM sqlite_master WHERE name=?;", (tableName,)).fetchone()[0] > 0:
+##            if mode != u'replace':
+##                raise RuntimeError(_(u'Cannot import %(dn1)s into %(dn2)s because that database already has a table named %(table)s.') % {u'dn1': dataset.DisplayName, u'dn2': database.DisplayName, u'table': tableName})
+##
+##            cls._LogDebug(_(u'%(class)s: Deleting existing table %(table)s from %(dn)s.'), {u'class': cls.__name__, u'table': tableName, u'dn': database.DisplayName})
+##            try:
+##                database._Connection.execute("DROP TABLE %s;" % tableName)
+##            except Exception, e:
+##                raise RuntimeError(_(u'Failed to delete existing table %(table)s from %(dn)s. SpatiaLite reported %(e)s: %(msg)s') % {u'table': tableName, u'dn': database.DisplayName, u'e': e.__class__.__name__, u'msg': cls._Unicode(e)})
+##
+##        # Create the table.
+##
+##        if dataset.GeometryType is not None:
+##            self._LogWarning(_(u'When %(dn1)s is imported to %(dn2)s as table %(table)s, the geometry field will be lost because SpatiaLite does not support geometry '))
+
+    ######################### TODO: All methods above here need to be checked #########################
+
     @classmethod
-    def _RemoveExistingDatasetsFromList(cls, path, datasets, progressReporter):
-        numDatasets = len(datasets)
-
-        if path != ':memory:' and not os.path.exists(path):
-            cls._LogDebug(_(u'%(class)s: SpatiaLite database "%(path)s" does not exist.'), {u'class': cls.__name__, u'path': path})
-            while len(datasets) > 0:
-                del datasets[0]
+    def ExportToArcGISWorkspace(cls, spatiaLiteDB, arcGISWorkspace, tableNames=None, skipExisting=False, overwriteExisting=False):
+        cls.__doc__.Obj.ValidateMethodInvocation()
+
+        # Create the ArcGIS workspace, if it does not exist already.
+        # The validation code above should have already created the
+        # parent directories, if they did not exist.
+
+        from GeoEco.ArcGIS import GeoprocessorManager, ArcGISDependency
+        gp = GeoprocessorManager.GetWrappedGeoprocessor()
+        outputTypeSingular = _(u'feature class')
+        outputTypePlural = _(u'feature classes')
+
+        if not gp.Exists(arcGISWorkspace):
+            if os.path.splitext(arcGISWorkspace)[1].lower() == u'.mdb':
+                cls._LogInfo(_(u'Creating personal geodatabase %s.') % arcGISWorkspace)
+                gp.CreatePersonalGDB_management(os.path.dirname(arcGISWorkspace), os.path.basename(arcGISWorkspace))
+
+            elif os.path.splitext(arcGISWorkspace)[1].lower() == u'.gdb':
+                cls._LogInfo(_(u'Creating file geodatabase %s.') % arcGISWorkspace)
+                d = ArcGISDependency(9,2)
+                d.Initialize()
+                gp.CreateFileGDB_management(os.path.dirname(arcGISWorkspace), os.path.basename(arcGISWorkspace))
+
+            else:
+                cls._LogInfo(_(u'Creating directory %s.') % arcGISWorkspace)
+                gp.CreateFolder_management(os.path.dirname(arcGISWorkspace), os.path.basename(arcGISWorkspace))
+                outputTypeSingular = _(u'shapefile')
+                outputTypePlural = _(u'shapefiles')
+
+        elif os.path.isdir(arcGISWorkspace) and os.path.splitext(arcGISWorkspace)[1].lower() != '.gdb':
+            outputTypeSingular = _(u'shapefile')
+            outputTypePlural = _(u'shapefiles')
+                
+        # Enumerate the SpatiaLite tables we will copy, and if the
+        # caller has requested that we skip existing outputs or not
+        # overwrite them, check whether they exist.
+
+        from GeoEco.Datasets.ArcGIS import ArcGISWorkspace, ArcGISTable
+
+        db = SpatiaLiteDatabase(spatiaLiteDB)
+        workspace = ArcGISWorkspace(arcGISWorkspace, ArcGISTable, pathParsingExpressions=[u'(?P<TableName>.+)'], queryableAttributes=(QueryableAttribute(u'TableName', _(u'Table name'), UnicodeStringTypeMetadata()),))
+        
+        if tableNames is None:
+            tables = db.QueryDatasets(reportProgress=False)
         else:
-            from pyspatialite import dbapi2 as spatialite
-
-            try:
-                conn = pyspatialite.connect(path)
-            except Exception, e:
-                raise RuntimeError(_(u'The file %(path)s exists but it could not be opened as a SpatiaLite database. Detailed error information: pyspatialite.connect failed with %(e)s: %(msg)s.') % {u'path': path, u'e': e.__class__.__name__, u'msg': self._Str(e)})
-
-            try:
-                i = 0
-                while i < len(datasets):
-                    tableName = datasets[i].GetQueryableAttributeValue(u'TableName')
-                    if tableName is None:
-                        if path == ':memory:':
-                            raise RuntimeError(_(u'Cannot import %(dn)s into a SpatiaLite in-memory database because that dataset does not have a value for the TableName queryable attribute. In order to import a dataset into a SpatiaLite database, the dataset must have a value for that queryable attribute.') % {u'dn': datasets[i].DisplayName})
-                        raise RuntimeError(_(u'Cannot import %(dn)s into SpatiaLite database %(path)s because that dataset does not have a value for the TableName queryable attribute. In order to import a dataset into a SpatiaLite database, the dataset must have a value for that queryable attribute.') % {u'dn': datasets[i].DisplayName, u'path': path})
+            tables = db.QueryDatasets(expression='TableName IN (%s)' % ', '.join(["'" + name.replace("'", "''") + "'" for name in tableNames]), reportProgress=False)
+
+        if len(tables) <= 0:
+            if tableNames is None:
+                cls._LogInfo(_(u'There are no tables in %(spatiaLiteDB)s to copy.') % {u'spatiaLiteDB': db.DisplayName})
+            else:
+                cls._LogInfo(_(u'None of the requested tables exist in %(spatiaLiteDB)s.') % {u'spatiaLiteDB': db.DisplayName})
+            return
+
+        outputTableNames = []
+        for table in tables:
+            tableName = table.GetQueryableAttributeValue(u'TableName')
+            if outputTypeSingular == _(u'shapefile'):
+                if table.GeometryType is not None:
+                    outputTableNames.append(tableName + '.shp')
+                else:
+                    outputTableNames.append(tableName + '.dbf')
+            else:
+                outputTableNames.append(tableName)
+
+        numSkipped = 0
+        if skipExisting or not overwriteExisting:
+            cls._LogInfo(_(u'Checking %(arcGISWorkspace)s for existing tables and %(outputTypePlural)s...') % {u'arcGISWorkspace': arcGISWorkspace, u'outputTypePlural': outputTypePlural})
+            i = 0
+            while i < len(tables):
+                if gp.Exists(os.path.join(arcGISWorkspace, outputTableNames[i])):
+                    if not overwriteExisting:
+                        raise ValueError(_(u'Cannot copy %(input)s to %(outputTypeSingular)s %(output)s. The %(outputTypeSingular)s already exists.') % {u'input': table.DisplayName, u'outputTypeSingular': outputTypeSingular, u'output': os.path.join(arcGISWorkspace, outputTableNames[i])})
+
+                    cls._LogDebug(_(u'Skipping %(input)s; the %(outputTypeSingular)s %(output)s already exists.') % {u'input': table.DisplayName, u'outputTypeSingular': outputTypeSingular, u'output': os.path.join(arcGISWorkspace, outputTableNames[i])})
                     
-                    if conn.execute("SELECT COUNT(*) FROM sqlite_master WHERE name=?;", (tableName,)).fetchone()[0] > 0:
-                        if path != ':memory:':
-                            cls._LogDebug(_(u'%(class)s: Table %(table)s exists in SpatiaLite database %(path)s.'), {u'class': cls.__name__, u'table': tableName, u'path': path})
-                        del datasets[i]
-                    else:
-                        i += 1
-            finally:
-                conn.close()
-
-        if progressReporter is not None:
-            progressReporter.ReportProgress(numDatasets)
+                    del tables[i]
+                    del outputTableNames [i]
+                    numSkipped += 1
+                else:
+                    i += 1
+
+        if numSkipped > 0:
+            if len(tables) <= 0:
+                cls._LogInfo(_(u'Skipping all %(numSkipped)i tables in %(spatiaLiteDB)s. All of the corresponding tables and %(outputTypePlural)s already exist.') % {u'numSkipped': numSkipped, u'spatiaLiteDB': db.DisplayName, u'outputTypePlural': outputTypePlural})
+                return
+            else:
+                cls._LogInfo(_(u'Skipping %(numSkipped)i tables in %(spatiaLiteDB)s because the corresponding tables and %(outputTypePlural)s already exist.') % {u'numSkipped': numSkipped, u'spatiaLiteDB': db.DisplayName, u'outputTypePlural': outputTypePlural})
+
+        # Copy the tables.
+
+        cls._LogInfo(_(u'Copying %(num)i tables from %(spatiaLiteDB)s to %(arcGISWorkspace)s.') % {u'num': len(tables), u'spatiaLiteDB': db.DisplayName, u'arcGISWorkspace': arcGISWorkspace})
+
+        for i in range(len(tables)):
+            if overwriteExisting and workspace.TableExists(outputTableNames[i]):
+                workspace.DeleteTable(outputTableNames[i])
+            workspace.ImportTable(outputTableNames[i], tables[i])
+
+            # Explicitly add a spatial index.
+            # CreateFeatureClass_management is supposed to do that
+            # automatically if you pass 0, 0, 0 for the Spatial Grid
+            # parameters, but that does not seem to work, at least for
+            # shapfiles on ArcGIS 10 SP2.
+
+            #gp.AddSpatialIndex_Management(os.path.join(arcGISWorkspace, outputTableNames[i]), 0, 0, 0)
+
+        # Return successfully.
+
+        return arcGISWorkspace
 
     @classmethod
-    def _ImportDatasetsToPath(cls, path, sourceDatasets, mode, progressReporter, options):
-
-        # If path is not ":memory:" it is a file. If that file does
-        # not exist, create the parent directories, if they do not
-        # exist already.
-
-        if path != ':memory:' and not os.path.isfile(path) and (path[0] in ['/', '\\'] or hasattr(os.path, 'splitdrive') and os.path.splitdrive(path)[0] != '' or hasattr(os.path, 'splitunc') and os.path.splitunc(path)[0] != '') and not os.path.isdir(os.path.dirname(path)):
-            cls._LogDebug(_(u'%(class)s: Creating directory "%(path)s".'), {u'class': cls.__name__, u'path': os.path.dirname(path)})
-            try:
-                os.makedirs(os.path.dirname(path))
-            except Exception, e:
-                raise RuntimeError(_(u'Failed to create directory "%(path)s". Python\'s os.makedirs function failed and reported %(e)s: %(msg)s') % {u'path': os.path.dirname(path), u'e': e.__class__.__name__, u'msg': cls._Unicode(e)})
-
-        # Open the SpatiaLite database. This will create it if it doesn't
-        # exist already. Then import each dataset into it.
-
-        database = SpatiaLiteDatabase(path)
-        try:
-            for dataset in sourceDatasets:
-                cls._ImportTableToDatabase(dataset, database, mode, progressReporter)
-        finally:
-            db.Close()
-
-    @classmethod
-    def _ImportTableToDatabase(cls, dataset, database, mode, progressReporter):
-
-        # Perform additional validation.
-
-        if not isinstance(dataset, Table):
-            raise ValueError(_(u'Cannot import %(dn1)s into %(dn2)s because the former is not a Table instance. Only Tables can be imported into SpatiaLite databases.') % {u'dn1': dataset.DisplayName, u'dn2': database.DisplayName})
-
-        tableName = dataset.GetQueryableAttributeValue(u'TableName')
-        if tableName is None:
-            raise RuntimeError(_(u'Cannot import %(dn1)s into %(dn2)s because the former does not have a value for the TableName queryable attribute. In order to import a dataset into a SpatiaLite database, the dataset must have a value for that queryable attribute.') % {u'dn1': dataset.DisplayName, u'dn2': database.DisplayName})
-
-        # If the table already exists and the mode is 'replace',
-        # delete it (otherwise raise an error).
-
-        if database._Connection.execute("SELECT COUNT(*) FROM sqlite_master WHERE name=?;", (tableName,)).fetchone()[0] > 0:
-            if mode != u'replace':
-                raise RuntimeError(_(u'Cannot import %(dn1)s into %(dn2)s because that database already has a table named %(table)s.') % {u'dn1': dataset.DisplayName, u'dn2': database.DisplayName, u'table': tableName})
-
-            cls._LogDebug(_(u'%(class)s: Deleting existing table %(table)s from %(dn)s.'), {u'class': cls.__name__, u'table': tableName, u'dn': database.DisplayName})
-            try:
-                database._Connection.execute("DROP TABLE %s;" % tableName)
-            except Exception, e:
-                raise RuntimeError(_(u'Failed to delete existing table %(table)s from %(dn)s. SpatiaLite reported %(e)s: %(msg)s') % {u'table': tableName, u'dn': database.DisplayName, u'e': e.__class__.__name__, u'msg': cls._Unicode(e)})
-
-        # Create the table.
-
-        if dataset.GeometryType is not None:
-            self._LogWarning(_(u'When %(dn1)s is imported to %(dn2)s as table %(table)s, the geometry field will be lost because SpatiaLite does not support geometry '))
+    def ImportFromArcGISWorkspace(cls, arcGISWorkspace, spatiaLiteDB, tableNames=None, skipExisting=False, overwriteExisting=False):
+        cls.__doc__.Obj.ValidateMethodInvocation()
+
+        # Create the SpatialLite database, if it does not exist
+        # already. The validation code above should have already
+        # created the parent directories, if they did not exist.
+        # Calling _Open creates the database if it does not exist
+        # already.
+
+        if not os.path.exists(spatiaLiteDB):
+            cls._LogInfo(_(u'Creating SpatiaLite database %s.') % spatiaLiteDB)
+
+        db = SpatiaLiteDatabase(spatiaLiteDB, isolation_level='DEFERRED')
+        db._Open()
+
+        # Enumerate the ArcGIS tables and features classes we will
+        # copy, and if the caller has requested that we skip existing
+        # outputs or not overwrite them, check whether they exist.
+
+        from GeoEco.Datasets.ArcGIS import ArcGISWorkspace, ArcGISTable
+
+        workspace = ArcGISWorkspace(arcGISWorkspace, ArcGISTable, pathParsingExpressions=[u'(?P<TableName>.+)'], queryableAttributes=(QueryableAttribute(u'TableName', _(u'Table name'), UnicodeStringTypeMetadata()),))
+        
+        if tableNames is None:
+            tables = workspace.QueryDatasets(reportProgress=False)
+        else:
+            tables = workspace.QueryDatasets(expression='TableName IN (%s)' % ', '.join(["'" + name.replace("'", "''") + "'" for name in tableNames]), reportProgress=False)
+
+        if os.path.isdir(arcGISWorkspace) and os.path.splitext(arcGISWorkspace)[1].lower() != '.gdb':
+            inputTypePlural = _(u'shapefiles')
+        else:
+            inputTypePlural = _(u'feature classes')
+
+        if len(tables) <= 0:
+            if tableNames is None:
+                cls._LogInfo(_(u'There are no tables or %(inputTypePlural)s in %(arcGISWorkspace)s to copy.') % {u'inputTypePlural': inputTypePlural, u'arcGISWorkspace': arcGISWorkspace})
+            else:
+                cls._LogInfo(_(u'None of the requested tables or %(inputTypePlural)s exist in %(arcGISWorkspace)s.') % {u'inputTypePlural': inputTypePlural, u'arcGISWorkspace': arcGISWorkspace})
+            return
+
+        outputTableNames = []
+        for table in tables:
+            tableName = table.GetQueryableAttributeValue(u'TableName')
+            if inputTypePlural == _(u'shapefiles'):
+                outputTableNames.append(os.path.splitext(tableName)[0])
+            else:
+                outputTableNames.append(tableName)
+
+        numSkipped = 0
+        if skipExisting or not overwriteExisting:
+            cls._LogInfo(_(u'Checking %(spatiaLiteDB)s for existing tables...') % {u'spatiaLiteDB': db.DisplayName})
+            i = 0
+            while i < len(tables):
+                if db.TableExists(outputTableNames[i]):
+                    if not overwriteExisting:
+                        raise ValueError(_(u'Cannot copy %(input)s to table %(output)s in %(spatiaLiteDB)s. The SpatiaLite table already exists.') % {u'input': table.DisplayName, u'output': outputTableNames[i], u'spatiaLiteDB': db.DisplayName})
+
+                    cls._LogDebug(_(u'Skipping %(input)s; the table %(output)s already exists in %(spatiaLiteDB)s.') % {u'input': table.DisplayName, u'output': outputTableNames[i], u'spatiaLiteDB': db.DisplayName})
+                    
+                    del tables[i]
+                    del outputTableNames [i]
+                    numSkipped += 1
+                else:
+                    i += 1
+
+        if numSkipped > 0:
+            if len(tables) <= 0:
+                cls._LogInfo(_(u'Skipping all %(numSkipped)i tables and %(inputTypePlural)s in %(arcGISWorkspace)s. All of the corresponding tables already exist.') % {u'numSkipped': numSkipped, u'inputTypePlural': inputTypePlural, u'arcGISWorkspace': arcGISWorkspace})
+                return
+            else:
+                cls._LogInfo(_(u'Skipping %(numSkipped)i tables and %(inputTypePlural)s in %(arcGISWorkspace)s because the corresponding tables already exist.') % {u'numSkipped': numSkipped, u'inputTypePlural': inputTypePlural, u'arcGISWorkspace': arcGISWorkspace})
+
+        # Copy the tables.
+
+        cls._LogInfo(_(u'Copying %(num)i tables and %(inputTypePlural)s from %(arcGISWorkspace)s to %(spatiaLiteDB)s.') % {u'num': len(tables), u'inputTypePlural': inputTypePlural, u'arcGISWorkspace': arcGISWorkspace, u'spatiaLiteDB': db.DisplayName})
+
+        for i in range(len(tables)):
+            if overwriteExisting and db.TableExists(outputTableNames[i]):
+                db.DeleteTable(outputTableNames[i])
+            db.ImportTable(outputTableNames[i], tables[i])
 
 
@@ -514 +752 @@
         # If it is not a known lazy property, return None.
 
-        if name not in ['SpatialReference', 'HasOID', 'OIDFieldName', 'GeometryType', 'GeometryFieldName', 'Fields']:
+        if name not in ['SpatialReference', 'HasOID', 'OIDFieldName', 'GeometryType', 'GeometryFieldName', 'SpatiaLiteSRID', 'Fields']:
             return None
 
@@ -569 +807 @@
 
         if geometryType is not None:
-            wkt = self.ParentCollection._Connection.execute("SELECT srs_wkt FROM spatial_ref_sys WHERE srid IN (SELECT srid FROM geometry_columns WHERE f_table_name=? AND f_geometry_column=?);", (self._TableName, field.Name)).fetchone()[0]
+            self.SetLazyPropertyValue('SpatiaLiteSRID', self.ParentCollection._Connection.execute("SELECT srid FROM geometry_columns WHERE f_table_name=? AND f_geometry_column=?;", (self._TableName, geometryFieldName)).fetchone()[0])
+
+            wkt = self.ParentCollection._Connection.execute("SELECT srs_wkt FROM spatial_ref_sys WHERE srid IN (SELECT srid FROM geometry_columns WHERE f_table_name=? AND f_geometry_column=?);", (self._TableName, geometryFieldName)).fetchone()[0]
             if isinstance(wkt, basestring) and len(wkt) > 0:
                 self.SetLazyPropertyValue('SpatialReference', Dataset.ConvertSpatialReference('WKT', wkt, 'Obj'))
@@ -575 +815 @@
                 self.SetLazyPropertyValue('SpatialReference', None)
         else:
+            self.SetLazyPropertyValue('SpatiaLiteSRID', None)
             self.SetLazyPropertyValue('SpatialReference', None)
 
@@ -633 +874 @@
     @classmethod
     def _TestCapability(cls, capability):
-        if capability in ['addfield', 'selectcursor', 'updatecursor', 'insertcursor', 'updaterow', 'deleterow']:
+        if capability in ['addfield', 'createindex', 'deleteindex', 'selectcursor', 'updatecursor', 'insertcursor', 'updaterow', 'deleterow']:
             return None
 
@@ -686 +927 @@
         return Field(name, dataType, None, None, isNullable, True)
 
+    def _CreateIndex(self, fields, indexName, unique, ascending):
+
+        # Make sure the caller specified an index name.
+
+        if indexName is None:
+            raise ValueError(_(u'The index name must be provided.'))
+
+        # Drop the existing index, if it exists.
+        
+        self.ParentCollection._Open()
+        self.ParentCollection._Connection.execute("DROP INDEX IF EXISTS %s;" % (indexName))
+
+        # Create the new index.
+
+        self.ParentCollection._Connection.execute("CREATE %s INDEX %s ON %s (%s);" % ({False: '', True: 'UNIQUE'}[unique], indexName, self._TableName, ', '.join([field + {False: ' DESC', True: ' ASC'}[ascending] for field in fields])))
+
+    def _DeleteIndex(self, indexName):
+
+        # Make sure the caller specified an index name.
+
+        if indexName is None:
+            raise ValueError(_(u'The index name must be provided.'))
+
+        # Drop the existing index, if it exists.
+        
+        self.ParentCollection._Open()
+        self.ParentCollection._Connection.execute("DROP INDEX IF EXISTS %s;" % (indexName))
+
     def _GetRowCount(self):
         self.ParentCollection._Open()
@@ -712 +981 @@
     def _GetValue(self, field):
         if field not in self._RowValues:
-            self._RowValues[field] = self._Row[field]
+            value = self._Row[str(field)]
+            if isinstance(value, datetime.date):
+                value = datetime.datetime(value.year, value.month, value.day, 0, 0, 0)
+            self._RowValues[field] = value
         return self._RowValues[field]
 
@@ -720 +992 @@
     def _GetGeometry(self):
         if self._Table.GeometryFieldName not in self._RowValues:
-            geometry = self._Row[self._Table.GeometryFieldName + '_WKB']
+            geometry = self._Row[str(self._Table.GeometryFieldName + '_WKB')]
             if geometry is not None:
                 ogr = self._Table._ogr()
@@ -738 +1010 @@
         if geometry is not None and geometry.IsEmpty():
             geometry = None
+        elif geometry.GetGeometryName() == 'POINT' and self._Table.GeometryType == 'MultiPoint':
+            geometry = self._Table._ogr().ForceToMultiPoint(geometry)
+        elif geometry.GetGeometryName() == 'LINESTRING' and self._Table.GeometryType == 'MultiLineString':
+            geometry = self._Table._ogr().ForceToMultiLineString(geometry)
+        elif geometry.GetGeometryName() == 'POLYGON' and self._Table.GeometryType == 'MultiPolygon':
+            geometry = self._Table._ogr().ForceToMultiPolygon(geometry)
+            
         self._RowValues[self._Table.GeometryFieldName] = geometry
         self._SetFields.add(self._Table.GeometryFieldName)
@@ -759 +1038 @@
         if fields is None:
             if self._Table.GeometryType is not None:
-                sql += 'SELECT *, ST_AsBinary(%(field)s) AS %(field)s_WKB ' % {'field': self._Table.GeometryFieldName}
+                sql = 'SELECT *, ST_AsBinary(%(field)s) AS %(field)s_WKB ' % {'field': self._Table.GeometryFieldName}
             else:
-                sql += 'SELECT *'
+                sql = 'SELECT *'
         else:
             if self._Table.GeometryType is not None and self._Table.GeometryFieldName in fields:
@@ -768 +1047 @@
                         fields[i] = 'ST_AsBinary(%(field)s) AS %(field)s_WKB' % {'field': self._Table.GeometryFieldName}
                         break
-            sql += 'SELECT %s' % ', '.join(fields)
+            sql = 'SELECT %s' % ', '.join(fields)
 
         sql += ' FROM %s' % self._Table.TableName
@@ -799 +1078 @@
     def _Open(self, fields, where, orderBy):
         self._Cursor = None
+        self._InTransaction = False
         self._Row = None
         self._RowValues = None
-        self._SetFields = set()
+        self._SetFields = None
 
         # Build the SQL SELECT statement from the caller's parameters.
@@ -818 +1098 @@
         if fields is None:
             if self._Table.GeometryType is not None:
-                sql += 'SELECT *, ST_AsBinary(%(field)s) AS %(field)s_WKB ' % {'field': self._Table.GeometryFieldName}
+                sql = 'SELECT *, ST_AsBinary(%(field)s) AS %(field)s_WKB ' % {'field': self._Table.GeometryFieldName}
             else:
-                sql += 'SELECT *'
+                sql = 'SELECT *'
         else:
             if self._Table.OIDFieldName not in fields:
@@ -831 +1111 @@
                         break
                     
-            sql += 'SELECT %s' % ', '.join(fields)
+            sql = 'SELECT %s' % ', '.join(fields)
 
         sql += ' FROM %s' % self._Table.TableName
@@ -843 +1123 @@
         # Open the cursor.
 
-        self._Cursor = self._Table.ParentCollection._Connection.execute(sql)
+        try:
+            self._Cursor = self._Table.ParentCollection._Connection.execute(sql)
+        except:
+            self._Table.ParentCollection._Connection.rollback()
+            self._InTransaction = False
+            raise
+
+        self._InTransaction = True
 
     def _Close(self):
@@ -850 +1137 @@
         self._SetFields = None
         if hasattr(self, '_Cursor') and self._Cursor is not None:
+            if self._InTransaction:
+                try:
+                    self._Table.ParentCollection._Connection.commit()
+                except:
+                    pass
             try:
                 self._Cursor.close()
@@ -859 +1151 @@
     def _UpdateRow(self):
 
+        # Fail if we are not in a transaction. The only way this can
+        # happen is if an error occurred with a previous call to this
+        # cursor. That will cause the transaction to be rolled back.
+        # The cursor can no longer be used after that point.
+
+        if not self._InTransaction:
+            raise RuntimeError(_(u'Due to the previous error, no more updates can be performed with this cursor. To perform updates, close this cursor and open a new one.'))
+
         # Only execute the UPDATE statement some fields have been set.
 
@@ -866 +1166 @@
             # instance that is currently in self._RowValues with a buffer
             # containing the WKB representation of it.
+            #
+            # Note that the Spatialite documentation contains the
+            # note:
+            #
+            #     both ST_GeomFromText() and ST_GeomFromWKB() accept
+            #     an optional SRID argument. If the SRID is
+            #     unspecified (not at all a good practice), then -1 is
+            #     assumed.
+            #
+            # It looks like if the SRID argument is not provided (and
+            # -1 is presumably used) then INSERTs or UPDATEs of the
+            # geometry column will consistently fail with:
+            #
+            #     IntegrityError: ... violates Geometry constraint
+            #     [geom-type or SRID not allowed]
+            #
+            # To work around that, we always specify the SRID.
 
             fieldsToSet = list(self._SetFields)
@@ -874 +1191 @@
                 for i in range(len(fieldsToSet)):
                     if fieldsToSet[i] == self._Table.GeometryFieldName:
-                        valueStrings[i] = 'ST_GeomFromWKB(?)'
+                        srid = self._Table.GetLazyPropertyValue('SpatiaLiteSRID')
+                        if srid is not None:
+                            valueStrings[i] = 'ST_GeomFromWKB(?, %i)' % srid
+                        else:
+                            valueStrings[i] = 'ST_GeomFromWKB(?)'
                         break
 
@@ -883 +1204 @@
             # Update the row.
 
-            self._Table.ParentCollection._Connection.execute(sql, [self._RowValues[field] for field in fieldsToSet])
+            try:
+                self._Table.ParentCollection._Connection.execute(sql, [self._RowValues[field] for field in fieldsToSet])
+            except:
+                self._Table.ParentCollection._Connection.rollback()
+                self._InTransaction = False
+                raise
 
         self._Row = None
 
     def _DeleteRow(self):
-        self._Table.ParentCollection._Connection.execute('DELETE %s WHERE ObjectID = %s' % (self._Table.TableName, self._GetValue(self._Table.OIDFieldName)))
+        if not self._InTransaction:
+            raise RuntimeError(_(u'Due to the previous error, no more deletes can be performed with this cursor. To perform deletes, close this cursor and open a new one.'))
+        try:
+            self._Table.ParentCollection._Connection.execute('DELETE %s WHERE ObjectID = %s' % (self._Table.TableName, self._GetValue(self._Table.OIDFieldName)))
+        except:
+            self._Table.ParentCollection._Connection.rollback()
+            self._InTransaction = False
+            raise
         self._Row = None
 
@@ -895 +1228 @@
     __doc__ = DynamicDocString()
 
-    def _Open(self, fields, where, orderBy):
-        self._RowValues = None
+    def _Open(self):
+        self._RowValues = {}
         self._SetFields = set()
+        self._InTransaction = None
 
     def _Close(self):
         self._RowValues = None
         self._SetFields = None
-        super(SpatiaLiteSelectCursor, self)._Close()
-
-    def _UpdateRow(self):
+        if self._InTransaction:
+            try:
+                self._Table.ParentCollection._Connection.commit()
+            except:
+                pass
+        super(SpatiaLiteInsertCursor, self)._Close()
+
+    def _InsertRow(self):
+
+        # Fail if we are not in a transaction. The only way this can
+        # happen is if an error occurred with a previous call to this
+        # cursor. That will cause the transaction to be rolled back.
+        # The cursor can no longer be used after that point.
+
+        if self._InTransaction is not None and not self._InTransaction:
+            raise RuntimeError(_(u'Due to the previous error, no more inserts can be performed with this cursor. To perform inserts, close this cursor and open a new one.'))
 
         # Build the SQL INSERT statement. If no fields have been set,
         # try the DEFAULT VALUES syntax. This will succeed if all of
         # the fields are nullable.
-
+        
         if len(self._SetFields) <= 0:
             sql = 'INSERT INTO %s DEFAULT VALUES' % self._Table.TableName
@@ -924 +1271 @@
             valueStrings = ['?'] * len(self._SetFields)
 
-            if self._Table.GeometryType is not None and self._Table.GeometryFieldName in self._SetFields and self._RowValues[self._Table.GeometryType] is not None:
-                self._RowValues[self._Table.GeometryType] = buffer(self._RowValues[self._Table.GeometryType].ExportToWKB)
+            if self._Table.GeometryType is not None and self._Table.GeometryFieldName in self._SetFields and self._RowValues[self._Table.GeometryFieldName] is not None:
+                self._RowValues[self._Table.GeometryFieldName] = buffer(self._RowValues[self._Table.GeometryFieldName].ExportToWkb())
                 for i in range(len(fieldsToSet)):
                     if fieldsToSet[i] == self._Table.GeometryFieldName:
-                        valueStrings[i] = 'ST_GeomFromWKB(?)'
+                        srid = self._Table.GetLazyPropertyValue('SpatiaLiteSRID')
+                        if srid is not None:
+                            valueStrings[i] = 'ST_GeomFromWKB(?, %i)' % srid
+                        else:
+                            valueStrings[i] = 'ST_GeomFromWKB(?)'
                         break
 
-            # Build the SQL INSERT statement.
-
-            sql = 'INSERT INTO %s (%s) VALUES %s' % (self._Table.TableName, ', '.join(fieldsToSet), ', '.join(valueStrings[i]))
-
-            # Insert the row.
-
+        # Build the SQL INSERT statement.
+
+        sql = 'INSERT INTO %s (%s) VALUES (%s)' % (self._Table.TableName, ', '.join(fieldsToSet), ', '.join(valueStrings))
+
+        # Insert the row.
+        
+        try:
             self._Table.ParentCollection._Connection.execute(sql, [self._RowValues[field] for field in fieldsToSet])
-
-        self._RowValues = None
+        except:
+            self._Table.ParentCollection._Connection.rollback()
+            self._InTransaction = False
+            raise
+
+        self._InTransaction = True
+        self._RowValues = {}
         self._SetFields = set()
 
@@ -947 +1304 @@
 ###############################################################################
 
+from GeoEco.ArcGIS import ArcGISDependency
 from GeoEco.Dependencies import PythonDependency
 from GeoEco.Metadata import *
@@ -1050 +1408 @@
     description=_(u'%s instance.') % SpatiaLiteDatabase.__name__)
 
+# Public method: SpatiaLiteDatabase.ExportToArcGISWorkspace
+
+AddMethodMetadata(SpatiaLiteDatabase.ExportToArcGISWorkspace,
+    shortDescription=_(u'Converts tables in a SpatiaLite database to ArcGIS tables, shapefiles, and feature classes.'),
+    isExposedToPythonCallers=True,
+    isExposedByCOM=True,
+    isExposedAsArcGISTool=True,
+    arcGISDisplayName=_(u'Convert SpatiaLite Tables to ArcGIS Geodatasets'),
+    arcGISToolCategory=_(u'Conversion\\To Table, Shapefile, or Feature Class'),
+    dependencies=[ArcGISDependency(9, 1), PySpatiaLiteDependency()])
+
+AddArgumentMetadata(SpatiaLiteDatabase.ExportToArcGISWorkspace, u'cls',
+    typeMetadata=ClassOrClassInstanceTypeMetadata(cls=SpatiaLiteDatabase),
+    description=_(u'SpatiaLiteDatabase class or instance.'))
+
+AddArgumentMetadata(SpatiaLiteDatabase.ExportToArcGISWorkspace, u'spatiaLiteDB',
+    typeMetadata=FileTypeMetadata(mustExist=True),
+    description=_(
+u"""SpatiaLite database containing the tables to convert.
+
+The tables may have, at most, one geometry column."""),
+    arcGISDisplayName=_(u'SpatiaLite database'))
+
+AddArgumentMetadata(SpatiaLiteDatabase.ExportToArcGISWorkspace, u'arcGISWorkspace',
+    typeMetadata=ArcGISWorkspaceTypeMetadata(createParentDirectories=True, mustBeDifferentThanArguments=[u'spatiaLiteDB']),
+    description=_(
+u"""Directory or geodatabase to receive the geodatasets.
+
+If a directory is specified, SpatiaLite tables without geometry will
+be converted to dBASE tables (.dbf files) and SpatiaLite tables with
+geometry will be converted to shapefiles.
+
+If a geodatabase is specified, SpatiaLite tables without geometry will
+be converted to geodatabase tables and SpatiaLite tables with geometry
+will be converted to feature classes."""),
+    arcGISDisplayName=_(u'Workspace'))
+
+AddArgumentMetadata(SpatiaLiteDatabase.ExportToArcGISWorkspace, u'tableNames',
+    typeMetadata=ListTypeMetadata(elementType=UnicodeStringTypeMetadata(), canBeNone=True),
+    description=_(
+u"""Names of the SpatiaLite tables to convert.
+
+Table names are case-sensitive. If this parameter is omitted, all
+tables in the database will be converted."""),
+    arcGISDisplayName=_(u'Tables to convert'))
+
+AddArgumentMetadata(SpatiaLiteDatabase.ExportToArcGISWorkspace, u'skipExisting',
+    typeMetadata=BooleanTypeMetadata(),
+    description=_(
+u"""If True, existing geodatasets will be skipped."""),
+    arcGISDisplayName=_(u'Skip existing geodatasets'))
+
+AddArgumentMetadata(SpatiaLiteDatabase.ExportToArcGISWorkspace, u'overwriteExisting',
+    typeMetadata=BooleanTypeMetadata(),
+    description=_(
+u"""If True, existing geodatasets will be overwritten. If False, a
+ValueError will be raised if a geodataset already exists."""),
+    initializeToArcGISGeoprocessorVariable=u'OverwriteOutput')
+
+AddResultMetadata(SpatiaLiteDatabase.ExportToArcGISWorkspace, u'updatedArcGISWorkspace',
+    typeMetadata=ArcGISWorkspaceTypeMetadata(),
+    description=_(u'Updated workspace.'),
+    arcGISDisplayName=_(u'Updated workspace'),
+    arcGISParameterDependencies=[u'ArcGISWorkspace'])
+
+# Public method: SpatiaLiteDatabase.ImportFromArcGISWorkspace
+
+AddMethodMetadata(SpatiaLiteDatabase.ImportFromArcGISWorkspace,
+    shortDescription=_(u'Converts ArcGIS tables, shapefiles, and feature classes to tables in a SpatiaLite database.'),
+    isExposedToPythonCallers=True,
+    isExposedByCOM=True,
+    isExposedAsArcGISTool=True,
+    arcGISDisplayName=_(u'Convert ArcGIS Geodatasets to SpatiaLite Tables'),
+    arcGISToolCategory=_(u'Conversion\\To SpatiaLite Database'),
+    dependencies=[ArcGISDependency(9, 1), PySpatiaLiteDependency()])
+
+CopyArgumentMetadata(SpatiaLiteDatabase.ExportToArcGISWorkspace, u'cls', SpatiaLiteDatabase.ImportFromArcGISWorkspace, u'cls')
+
+AddArgumentMetadata(SpatiaLiteDatabase.ImportFromArcGISWorkspace, u'arcGISWorkspace',
+    typeMetadata=ArcGISWorkspaceTypeMetadata(mustExist=True),
+    description=_(
+u"""ArcGIS database containing tables, shapefiles, and feature classes
+to convert."""),
+    arcGISDisplayName=_(u'Workspace'))
+
+AddArgumentMetadata(SpatiaLiteDatabase.ImportFromArcGISWorkspace, u'spatiaLiteDB',
+    typeMetadata=FileTypeMetadata(createParentDirectories=True, mustBeDifferentThanArguments=[u'arcGISWorkspace']),
+    description=_(
+u"""SpatiaLite database to receive the geodatasets."""),
+    direction=u'Output',
+    arcGISDisplayName=_(u'SpatiaLite database'))
+
+AddArgumentMetadata(SpatiaLiteDatabase.ImportFromArcGISWorkspace, u'tableNames',
+    typeMetadata=ListTypeMetadata(elementType=UnicodeStringTypeMetadata(), canBeNone=True),
+    description=_(
+u"""Names of the tables, shapefiles, and feature classes to convert.
+
+The names may be case-sensitive, depending on the type of workspace.
+dBASE tables and shapefiles should be specified with their file
+extensions (.dbf and .shp, respectively).
+
+If this parameter is omitted, all vector geodatasets in the workspace
+will be converted."""),
+    arcGISDisplayName=_(u'Tables to convert'))
+
+AddArgumentMetadata(SpatiaLiteDatabase.ImportFromArcGISWorkspace, u'skipExisting',
+    typeMetadata=BooleanTypeMetadata(),
+    description=_(
+u"""If True, existing tables will be skipped."""))
+
+AddArgumentMetadata(SpatiaLiteDatabase.ImportFromArcGISWorkspace, u'overwriteExisting',
+    typeMetadata=BooleanTypeMetadata(),
+    description=_(
+u"""If True, existing tables will be overwritten. If False, a
+ValueError will be raised if a table already exists."""),
+    initializeToArcGISGeoprocessorVariable=u'OverwriteOutput')
+
 ###############################################################################
 # Metadata: SpatiaLiteTable class

MGET/Branches/Jason/PythonPackage/src/GeoEco/Datasets/Virtual.py

@@ -1606 +1606 @@
                     regionToRead.append(remainingRegion[i])
                 else:
-                    regionToRead.append(slice(max(0, remainingRegion[i].start - int(math.floor((self._MinBlockSize[i] - cellsRemaining) / 2.))), min(self.Shape[i], int(math.ceil(remainingRegion[i].stop + (self._MinBlockSize[i] - cellsRemaining) / 2.)))))
-            
+                    maxIndex = self.Shape[self.Dimensions.index(self.GetLazyPropertyValue('PhysicalDimensions')[i])]
+                    regionToRead.append(slice(max(0, remainingRegion[i].start - int(math.floor((self._MinBlockSize[i] - cellsRemaining) / 2.))), min(maxIndex, int(math.ceil(remainingRegion[i].stop + (self._MinBlockSize[i] - cellsRemaining) / 2.)))))
+
             self._Cache.insert(0, [regionToRead, self._Grid._ReadNumpyArray(regionToRead)[0]])
 

MGET/Branches/Jason/PythonPackage/src/GeoEco/Datasets/__init__.py

@@ -1182 +1182 @@
         if geometryType is not None:
             self._RequireCapability('GeometryType %s %s' % (geometryType, tableName))
-            if geometryType is not None:
+            if geometryFieldName is not None:
                 self._RequireCapability('GeometryFieldName')
         
@@ -1242 +1242 @@
 
         if createGeometryField:
-            table = self.CreateTable(tableName, templateTable.GeometryType, templateTable.GetSpatialReference('Obj'), templateTable.GeometryFieldName)
+
+            # If we support assigning the name of the geometry field,
+            # try to use the same name as the template table. If not,
+            # do not try to assign the geometry field name (it will
+            # likely fail).
+            
+            if self._TestCapability('GeometryFieldName') is None:
+                geometryFieldName = templateTable.GeometryFieldName
+            else:
+                geometryFieldName = None
+                
+            table = self.CreateTable(tableName, templateTable.GeometryType, templateTable.GetSpatialReference('Obj'), geometryFieldName)
         else:
             table = self.CreateTable(tableName)
@@ -1284 +1295 @@
         else:
             fields = [field.Name for field in sourceTable.Fields]
-            if copiedOIDFieldName is None:
+            if copiedOIDFieldName is None and sourceTable.OIDFieldName is not None:
                 fields.remove(sourceTable.OIDFieldName)
-            if destTable.GeometryType is None:
+            if destTable.GeometryType is None and sourceTable.GeometryFieldName is not None:
                 fields.remove(sourceTable.GeometryFieldName)
 
@@ -1296 +1307 @@
             insertCursor = destTable.OpenInsertCursor(rowCount, reportProgress, rowDescriptionSingular, rowDescriptionPlural)
             try:
+                if rowCount is not None:
+                    message = _(u'Copying %(rowCount)i %(desc)s from %(dn1)s to %(dn2)s.') % {u'rowCount': rowCount, u'desc': selectCursor.RowDescriptionPlural, u'dn1': sourceTable.DisplayName, u'dn2': destTable.DisplayName}
+                else:
+                    message = _(u'Copying %(desc)s from %(dn1)s to %(dn2)s.') % {u'desc': selectCursor.RowDescriptionPlural, u'dn1': sourceTable.DisplayName, u'dn2': destTable.DisplayName}
+                if reportProgress:
+                    self._LogInfo(message)
+                else:
+                    self._LogDebug(message)
+                
                 while selectCursor.NextRow():
                     for field in fields:
@@ -1303 +1323 @@
                             insertCursor.SetGeometry(selectCursor.GetGeometry())
                         else:
-                            insertCursor.SetValue(field, selectCursor.GetValue(value))
+                            insertCursor.SetValue(field, selectCursor.GetValue(field))
+                    insertCursor.InsertRow()
             finally:
                 del insertCursor
@@ -1309 +1330 @@
             del selectCursor
 
+        # Return successfully.
+
+        return destTable
 
     def DeleteTable(self, tableName, failIfNotExists=False):
@@ -1327 +1351 @@
         except Exception, e:
             raise RuntimeError(_(u'Failed to delete %(objectType)s %(tableName)s from %(dn)s due to %(e)s: %(msg)s.') % {u'objectType': self._GetObjectTypeDisplayName(tableName), u'tableName': tableName, u'dn': self._DisplayName, u'e': e.__class__.__name__, u'msg': self._Str(e)})
-            
 
     # Private members that the derived class should override.
@@ -1337 +1360 @@
         raise RuntimeError(_(u'Programming error in this tool: The %(cls)s class does not define the Database._TableExists method. Please contact the author of this tool for assistance.') % {u'cls': self.__class__.__name__})
 
-    def _CreateTable(self, tableName, geometryType=None, spatialReference=None, geometryFieldName=u'geometry'):
+    def _CreateTable(self, tableName, geometryType, spatialReference, geometryFieldName):
         raise RuntimeError(_(u'Programming error in this tool: The %(cls)s class does not define the Database._CreateTable method. Please contact the author of this tool for assistance.') % {u'cls': self.__class__.__name__})
 
@@ -1426 +1449 @@
             self._RequireCapability(dataType + ' IsNullable')
 
-        # If the data type is 'string', verify that the length
-        # parameter was supplied and that it does not exceed the
-        # maximum allowed length.
-
-        if dataType == 'string':
-            if length is None:
-                raise ValueError(_(u'Cannot add string field %(name)s to %(dn)s because the field length was not specified. When adding a string field, you must specify the field length.') % {u'name': name, u'dn': self.DisplayName})
-            if self.MaxStringLength is not None and length > self.MaxStringLength:
-                raise ValueError(_(u'Cannot add string field %(name)s to %(dn)s because the field length (%(length)i) exceeds the maximum allowed for this dataset (%(max)i).') % {u'name': name, u'length': length, u'dn': self.DisplayName, u'max': self.MaxStringLength})
+        # If the data type is 'string' and length was supplied, verify
+        # that it does not exceed the maximum allowed length.
+
+        if dataType == 'string' and length is not None and self.MaxStringLength is not None and length > self.MaxStringLength:
+            raise ValueError(_(u'Cannot add string field %(name)s to %(dn)s because the field length (%(length)i) exceeds the maximum allowed for this dataset (%(max)i).') % {u'name': name, u'length': length, u'dn': self.DisplayName, u'max': self.MaxStringLength})
 
         # If the field already exists with the exact parameters
@@ -1462 +1481 @@
         # dictionary of fields.
 
-        self.Fields.append(field)
+        fields = list(self.GetLazyPropertyValue('Fields'))
+        fields.append(field)
+        self.SetLazyPropertyValue('Fields', tuple(fields))
+
         self._FieldsDict[name.upper()] = field
 
@@ -1480 +1502 @@
                 self._LogDebug(_(u'%(class)s 0x%(id)08X: Not deleting field with name %(Name)s because it does not exist.'), {u'class': self.__class__.__name__, u'id': id(self), u'Name': name})
                 return
-            raise ValueError(_(u'Cannot delete field %(name)s from %(dn)s because a field with that name does not exist.') % {u'name': name, u'dn': self.DisplayName})
+            raise ValueError(_(u'Cannot delete field %(name)s from %(dn)s because that field does not exist.') % {u'name': name, u'dn': self.DisplayName})
 
         # Call the derived class to delete the field.
@@ -1499 +1521 @@
         # fields.
 
-        del self.Fields[i]
+        fields = list(self.GetLazyPropertyValue('Fields'))
+        del fields[i]
+        self.SetLazyPropertyValue('Fields', tuple(fields))
+
         del self._FieldsDict[existingField.Name.upper()]
+
+    def CreateIndex(self, fields, indexName, unique=False, ascending=True):
+        # TODO: self.__class__.__doc__.Obj.ValidateMethodInvocation()
+
+        # Verify that we have the required capabilities.
+
+        self._RequireCapability('CreateIndex')
+
+        # Verify that all of the fields exist and that they are not
+        # trying to create an index on the geometry field.
+
+        for name in fields:
+            field = self.GetFieldByName(name)
+            if field is None:
+                raise ValueError(_(u'Cannot create an index on field %(name)s of %(dn)s because that field does not exist.') % {u'name': name, u'dn': self.DisplayName})
+            if field.DataType == u'geometry':
+                raise ValueError(_(u'Cannot create a non-spatial index on field %(name)s of %(dn)s because that is the geometry field. Only spatial indexes can be created on the geometry field.') % {u'name': name, u'dn': self.DisplayName})
+
+        # Call the derived class to create the index.
+
+        if indexName is None:
+            name = ''
+        else:
+            name = ' ' + indexName
+            
+        self._LogDebug(_(u'%(class)s 0x%(id)08X: Creating %(unique)s %(ascending)s index%(name)s on fields [%(fields)s] of %(dn)s.'),
+                       {u'class': self.__class__.__name__, u'id': id(self), u'unique': {False: _(u'non-unique'), True: _(u'unique')}[unique], u'ascending': {False: _(u'descending'), True: _(u'ascending')}[ascending], u'name': name, u'fields': u', '.join(fields), u'dn': self.DisplayName})
+
+        try:
+            self._CreateIndex(fields, indexName, unique, ascending)
+        except Exception, e:
+            raise RuntimeError(_(u'Failed to create %(unique)s %(ascending)s index%(name)s on fields [%(fields)s] of %(dn)s due to %(e)s: %(msg)s') % {u'unique': {False: _(u'non-unique'), True: _(u'unique')}[unique], u'ascending': {False: _(u'descending'), True: _(u'ascending')}[ascending], u'name': name, u'fields': u', '.join(fields), u'dn': self.DisplayName, u'e': e.__class__.__name__, u'msg': self._Unicode(e)})
+
+    def DeleteIndex(self, indexName):
+
+        # Verify that we have the required capabilities.
+
+        self._RequireCapability('DeleteIndex')
+
+        # Call the derived class to delete the index.
+
+        if indexName is None:
+            name = ''
+        else:
+            name = ' ' + indexName
+            
+        self._LogDebug(_(u'%(class)s 0x%(id)08X: Deleting index%(name)s.'), {u'class': self.__class__.__name__, u'id': id(self), u'name': name})
+
+        try:
+            self._DeleteIndex(indexName)
+        except Exception, e:
+            raise RuntimeError(_(u'Failed to delete index%(name)s of %(dn)s due to %(e)s: %(msg)s') % {u'name': name, u'dn': self.DisplayName, u'e': e.__class__.__name__, u'msg': self._Unicode(e)})
 
     def GetRowCount(self):
@@ -1535 +1612 @@
     def _DeleteField(self, name):
         raise NotImplementedError(_(u'The _DeleteField method of class %s has not been implemented.') % self.__class__.__name__)
+
+    def _CreateIndex(self, fields, indexName, unique, ascending):
+        raise NotImplementedError(_(u'The _CreateIndex method of class %s has not been implemented.') % self.__class__.__name__)
+
+    def _DeleteIndex(self, indexName):
+        raise NotImplementedError(_(u'The _DeleteIndex method of class %s has not been implemented.') % self.__class__.__name__)
 
     def _GetRowCount(self):

MGET/Branches/Jason/PythonPackage/src/GeoEco/__init__.py

@@ -1 @@
-__version__ = u'0.8a32'
+__version__ = u'0.8a33'