Example #1
0
    def testSaveFields(self):
        # Create a new memory layer with no fields
        myMemoryLayer = QgsVectorLayer(('Point?crs=epsg:4326&index=yes'),
                                       'test', 'memory')

        # Add some fields to the layer
        myFields = [
            QgsField('TestInt', QVariant.Int, 'integer', 2, 0),
            QgsField('TestLong', QVariant.LongLong, 'long', -1, 0),
            QgsField('TestDbl', QVariant.Double, 'double', 8, 6),
            QgsField('TestString', QVariant.String, 'string', 50, 0),
            QgsField('TestDate', QVariant.Date, 'date'),
            QgsField('TestTime', QVariant.Time, 'time'),
            QgsField('TestDateTime', QVariant.DateTime, 'datetime')
        ]
        assert myMemoryLayer.startEditing()
        for f in myFields:
            assert myMemoryLayer.addAttribute(f)
        assert myMemoryLayer.commitChanges()
        myMemoryLayer.updateFields()

        # Export the layer to a layer-definition-XML
        qlr = QgsLayerDefinition.exportLayerDefinitionLayers(
            [myMemoryLayer], QgsReadWriteContext())
        assert qlr is not None

        # Import the layer from the layer-definition-XML
        layers = QgsLayerDefinition.loadLayerDefinitionLayers(
            qlr, QgsReadWriteContext())
        assert layers is not None
        myImportedLayer = layers[0]
        assert myImportedLayer is not None

        # Check for the presence of the fields
        importedFields = myImportedLayer.fields()
        assert importedFields is not None
        for f in myFields:
            assert f == importedFields.field(f.name())
Example #2
0
    def testSaveFields(self):
        # Create a new py layerwith no fields
        myPyLayer = QgsVectorLayer(
            ('Point?crs=epsg:4326&index=yes'),
            'test',
            'pythonprovider')

        # Add some fields to the layer
        myFields = [QgsField('TestInt', QVariant.Int, 'integer', 2, 0),
                    QgsField('TestLong', QVariant.LongLong, 'long', -1, 0),
                    QgsField('TestDbl', QVariant.Double, 'double', 8, 6),
                    QgsField('TestString', QVariant.String, 'string', 50, 0),
                    QgsField('TestDate', QVariant.Date, 'date'),
                    QgsField('TestTime', QVariant.Time, 'time'),
                    QgsField('TestDateTime', QVariant.DateTime, 'datetime')]
        assert myPyLayer.startEditing()
        for f in myFields:
            assert myPyLayer.addAttribute(f)
        assert myPyLayer.commitChanges()
        myPyLayer.updateFields()

        # Export the layer to a layer-definition-XML
        qlr = QgsLayerDefinition.exportLayerDefinitionLayers([myPyLayer], QgsReadWriteContext())
        assert qlr is not None

        # Import the layer from the layer-definition-XML
        layers = QgsLayerDefinition.loadLayerDefinitionLayers(qlr, QgsReadWriteContext())
        assert layers is not None
        myImportedLayer = layers[0]
        assert myImportedLayer is not None

        # Check for the presence of the fields
        importedFields = myImportedLayer.fields()
        assert importedFields is not None
        for f in myFields:
            assert f == importedFields.field(f.name())
Example #3
0
    def testSaveFields(self):
        # Create a new memory layer with no fields
        myMemoryLayer = QgsVectorLayer(('Point?crs=epsg:4326&index=yes'),
                                       'test', 'memory')

        # Add some fields to the layer
        myFields = [
            QgsField('TestInt', QVariant.Int, 'integer', 2, 0),
            QgsField('TestLong', QVariant.LongLong, 'long', -1, 0),
            QgsField('TestDbl', QVariant.Double, 'double', 8, 6),
            QgsField('TestString', QVariant.String, 'string', 50, 0),
            QgsField('TestDate', QVariant.Date, 'date'),
            QgsField('TestTime', QVariant.Time, 'time'),
            QgsField('TestDateTime', QVariant.DateTime, 'datetime'),
            QgsField("vallist", QVariant.List, subType=QVariant.Int),
            QgsField("stringlist",
                     QVariant.StringList,
                     subType=QVariant.String),
            QgsField("stringlist2", QVariant.List, subType=QVariant.String),
            QgsField("reallist", QVariant.List, subType=QVariant.Double),
            QgsField("longlist", QVariant.List, subType=QVariant.LongLong),
            QgsField("dict", QVariant.Map)
        ]
        self.assertTrue(myMemoryLayer.startEditing())
        for f in myFields:
            assert myMemoryLayer.addAttribute(f)
        self.assertTrue(myMemoryLayer.commitChanges())
        myMemoryLayer.updateFields()

        for f in myFields:
            self.assertEqual(f, myMemoryLayer.fields().field(f.name()))

        # Export the layer to a layer-definition-XML
        qlr = QgsLayerDefinition.exportLayerDefinitionLayers(
            [myMemoryLayer], QgsReadWriteContext())
        self.assertIsNotNone(qlr)

        # Import the layer from the layer-definition-XML
        layers = QgsLayerDefinition.loadLayerDefinitionLayers(
            qlr, QgsReadWriteContext())
        self.assertTrue(layers)
        myImportedLayer = layers[0]
        self.assertIsNotNone(myImportedLayer)

        # Check for the presence of the fields
        importedFields = myImportedLayer.fields()
        for f in myFields:
            self.assertEqual(f.name(), importedFields.field(f.name()).name())
            if f.name() != 'stringlist2':
                self.assertEqual(f.type(),
                                 importedFields.field(f.name()).type())
            else:
                # we automatically convert List with String subtype to StringList, to match other data providers
                self.assertEqual(
                    importedFields.field(f.name()).type(), QVariant.StringList)

            self.assertEqual(f.subType(),
                             importedFields.field(f.name()).subType())
            self.assertEqual(f.precision(),
                             importedFields.field(f.name()).precision())
            self.assertEqual(f.length(),
                             importedFields.field(f.name()).length())