Skip to content

Outputs

The Output_writer class is the base class for writing to different dataformats.

Output_Writer

Source code in python\engine\outputs.py 
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
class Output_Writer:

    logger = get_logger()

    def excel(layer: QgsVectorLayer, path : str):
        """
        A function that exports a QgsVectorLayer into an excel spredsheet.

        Args:
            layer (QgsVectorLayer): The QgsVectorLayer to be exported into an excel spredsheet.
            path (string): the ouput file to be created.
        """

        if layerHasFeatures(layer):
            logger.info(f'Writing {str(layer.featureCount())} features to Excel : {path}')
        try:
            parameter = {'LAYERS': [layer],
                    'USE_ALIAS': True,
                    'FORMATTED_VALUES': False,
                    'OUTPUT': path}
            processing.run("native:exporttospreadsheet", parameter)
            logger.info(f'Parameters: {str(parameter)}')
            logger.info("Export to Excel completed")
        except Exception as error:
            logger.error("An error occured exporting layer to Excel")
            logger.error(f'{type(error).__name__}  –  {str(error)}')
            logger.critical("Program terminated")
            script_failed()


    def postgis(layer: QgsVectorLayer, connection : str, dbname: str, schema: str, tablename: str, overwrite: bool = True):
        """
        A function that exports a QgsVectorLayer into a Postgis database.

        Args:
            layer (QgsVectorLayer): The QgsVectorLayer to be exported into Postgis
            connection (string): The name of the connection object in the settings file
            dbname (string): The database name
            schema (string): Schema name
            tablename (string): The name of the table that will be imported
            overwrite (boolean): Defaults to True. Should the resulting table in Postgis be overwritten if it exists. If set to False, then it will append the data.
        """

        if layerHasFeatures(layer):
            logger.info(f'Exporting {str(layer.featureCount())} features to Postgis')
        tempfile = create_tempfile(layer, 'postgis')
        logger.info('Temporary layer created')

        try:
            config = get_config()
            dbConnection = config['DatabaseConnections'][connection]

            # ogr2ogr parameters
            table = f'-nln "{schema}.{tablename}"'
            ogrconnection = f'PG:"host={dbConnection["host"]} port={dbConnection["port"]} dbname={dbname} schemas={schema} user={dbConnection["user"]} password={dbConnection["password"]}"'
            ogr2ogrstring = f'{config["QGIS_bin_folder"]}/ogr2ogr.exe -f "PostgreSQL" {ogrconnection} {tempfile} {table}'
            if overwrite:
                ogr2ogrstring = f'{ogr2ogrstring} -overwrite'
            logger.info(f'Writing to PostGIS database {dbname}')
            run = subprocess.run(ogr2ogrstring, capture_output=True)
            delete_tempfile(tempfile)
            logger.info('Temporary layer removed')
            logger.info('Export to PostGIS completed')

        except Exception as error:
            logger.error("An error occured exporting to Postgis")
            logger.error(f'{type(error).__name__}  –  {str(error)}')
            logger.critical("Program terminated")
            script_failed()

    def geopackage(layer: QgsVectorLayer, layername: str, geopackage: str, overwrite: bool):
        """
        A function that writes a QgsVectorLayer to a Geopackage file. 

        Args:
            layer (QgsVectorLayer): The QgsVectorLayer that is to be written to the geopackage
            layername (string): The name of the layer in the geopackage file
            geopackage (string): The full path for the geopackage to be created
            overwrite (boolean): Specify wheather the writer will overwrite existing geopackage or append layer. Boolean True/False
        """

        if layerHasFeatures(layer):
            logger.info(f'Writing {str(layer.featureCount())} features to geopackage : {geopackage}')
        try:
            layer.setName(layername)
            parameter = {'LAYERS': [layer],
                    'OUTPUT': geopackage,
                    'OVERWRITE': overwrite,
                    'SAVE_STYLES': False,
                    'SAVE_METADATA': False,
                    'SELECTED_FEATURES_ONLY': False}
            processing.run("native:package", parameter)
            logger.info(f'Parameters: {str(parameter)}')
            logger.info("Export to Geopackage completed")
        except Exception as error:
            logger.error("An error occured exporting layer to geopackage")
            logger.error(f'{type(error).__name__}  –  {str(error)}')
            logger.critical("Program terminated")
            script_failed()

    def append_geopackage(layer: str, layername: str, geopackage: str):
        """
        Append a layer to an existing geopackage.
        If the new layer does not exist, it will be created. It it exists, the features will be appended to the layer.

        Args:
            layer (QgsVectorLayer): The QgsVectorLayer that is to be written to a file
            layername (string): The name of the layer in the geopackage file
            geopackage (string): The full path for the geopackage to be created
        """

        logger.info("Running append layer to Geopackage")
        if os.path.isfile(geopackage):
            logger.info(f'Geopackage {geopackage} exists, appending layer')
            tempfile = create_tempfile(layer, 'append_geopackage')

            try:
                config = get_config()
                ## ogr2ogr parameters
                table = f'-nln "{layername}"'
                ogr2ogrstring = f'{config["QGIS_bin_folder"]}/ogr2ogr.exe -f "GPKG" {geopackage} {tempfile} -nln {layername} -update -append'
                logger.info(f'Writing new layer {layername} to: {geopackage}')
                logger.info(f'Ogr2ogr command {ogr2ogrstring}')
                ogr2ogrstring.join(' -progress')
                run = subprocess.run(ogr2ogrstring, stderr=subprocess.STDOUT)
                if run.stdout:
                    logger.info(run.stdout)
                delete_tempfile(tempfile)
                logger.info(f'Append to geopackage completed')

            except Exception as error:
                logger.error("An error occured appending layer to geopackage")
                logger.error(f'{type(error).__name__}  –  {str(error)}')
                logger.critical("Program terminated")
                script_failed() 
        else:
            logger.error("Target geopackage not found")
            logger.critical("Program terminated")
            script_failed()     

    def file(layer: str, path: str, format: str):
        """
        Args:
            layer (QgsVectorLayer): The QgsVectorLayer that is to be written to a file
            path (string): The full path for the file to be created
            format (string): The driver type used to write the data to the file. 
        """

        if layerHasFeatures(layer):
            logger.info(f'Writing {str(layer.featureCount())} features to: {path}')
        try:
            options = QgsVectorFileWriter.SaveVectorOptions()
            options.driverName = format
            QgsVectorFileWriter.writeAsVectorFormatV3(layer, path, QgsProject.instance().transformContext(), options)
            logger.info("Export completed")
        except Exception as error:
            logger.error("An error occured exporting layer")
            logger.error(f'{type(error).__name__}  –  {str(error)}')
            logger.critical("Program terminated")
            script_failed()

    def textfile(file: str, list: list, newline: bool):
        """
        Create an output file from a list of lines. 

        Args:
            file (string): The path to the resulting file
            list (list of strings): List of lines to be written to the file.
            newline (boolean): If true, a newline character will be added to the end of each line.
        """
        logger.info("Creating text file: " + file)
        try:
            with open(file, 'w', encoding="utf-8") as f:
                for line in list:
                    if newline == True:
                        f.write(line + '\\n')
                    else:
                        f.write(line)
            logger.info("File created")
        except Exception as error:
            logger.error("An error occured creating file")
            logger.error(f'{type(error).__name__}  –  {str(error)}')
            logger.critical("Program terminated")
            script_failed()

    def mssql(layer: QgsVectorLayer, connection: str, driver: str, schema: str, table: str, overwrite: str, geom_type: str, geom_name: str, ogr2ogr_params: str):
        """
        A function that exports a QgsVectorLayer into a MSSQL database using ogr2ogr.
        The function writes the data to a temporary geojson file, that is then importet to the database with ogr2ogr.

        Args:
            layer (QgsVectorLayer): The QgsVectorLayer that is to be written to a file.
            connection (string): The name of a connection from the settings.json file.
            driver (string): The driver used for writing to the database. Default value is : 'SQL Server'.
            schema (string): The target schema.
            table (string): The target table.
            overwrite (boolean): Overwrite or append.
            geom_type (string): Geometry type. One of geometry/geography.
            geom_name (string): Name of the geometry coloumn.
            ogr2ogr_params (string): Extra parameters for ogr2ogr besides the default.
        """

        try:
            config = get_config()
            logger.info(f'Exporting {layer} to MSSQL Server')
            dbconnection = config['DatabaseConnections'][connection]
            conn = copy.copy(dbconnection)
            conn['password'] = 'xxxxxxx'
            logger.info(f'Connection: {str(conn)}')
            logger.info(f'Creating temporary layer in Temp folder')
            tmp_path = f'{config["TempFolder"]}mssql_layer_{str(randrange(1000))}.geojson'
            options = QgsVectorFileWriter.SaveVectorOptions()
            options.driverName = 'GeoJSON'
            QgsVectorFileWriter.writeAsVectorFormatV3(layer, tmp_path, QgsProject.instance().transformContext(), options)
            logger.info('Temporary layer created')

            ## ogr2ogr parameters
            table = f'-nln "{schema}.{table}"'
            geometry = f'-lco "GEOM_TYPE={geom_type}" -lco "GEOM_NAME={geom_name}"'

            if driver != '':
                mssql_driver = driver
            else:
                 mssql_driver = 'SQL Server'

            if dbconnection['user'] == '' and dbconnection['password'] == '':
                ogrconnection = f"MSSQL:server={dbconnection['host']};driver={mssql_driver};database={dbconnection['databasename']};trusted_connection=yes;"
            else:
                ogrconnection = f"MSSQL:server={dbconnection['host']};driver=SQL Server;database={dbconnection['databasename']};uid={dbconnection['user']};pwd={dbconnection['password']}"

            if overwrite == True:
                ow = '-overwrite'
            else:
                ow = ''

            if ogr2ogr_params != '':
                ep = ' ' + ogr2ogr_params
            else:
                ep = ''

            ogr2ogrstring = f'{config["QGIS_bin_folder"]}/ogr2ogr.exe --config MSSQLSPATIAL_USE_BCP FALSE -f "MSSQLSpatial" "{ogrconnection}" "{tmp_path}" {geometry} {table} -lco UPLOAD_GEOM_FORMAT=wkt {ep}  {ow}'
            logger.info(f'Writing to MSSQL database {dbconnection["databasename"]}, {table}')
            ogr2ogrstring.join(' -progress')
            run = subprocess.run(ogr2ogrstring, stderr=subprocess.STDOUT)
            if run.stdout:
                logger.info(run.stdout)
            os.remove(tmp_path)
            logger.info(f'Export to MSSQL completed')

        except Exception as error:
            try:
                os.remove(tmp_path)
            except:
                pass

            logger.error("An error occured exporting to MSSQL")
            logger.error(f'{type(error).__name__}  –  {str(error)}')
            logger.critical("Program terminated")
            script_failed()

    def filegdb(layer: QgsVectorLayer, layername: str, path: str):
        """
        A function that export a QgsVectorLayer into an ESRI File

        Args:
            layer (QgsVectorLayer): The layer that is to be written to an ESRI File GeoDatabase
            path (string): The full path for the ESRI File Geodatabase to be created
            layername (string): The name of the resulting layer in the ESRI File Geodatabase
        """

        if layerHasFeatures(layer):
            logger.info(f'Writing {str(layer.featureCount())} features to: {path}')
        try:
            options = QgsVectorFileWriter.SaveVectorOptions()
            options.driverName = 'OpenFileGDB'
            options.layerName = layername
            QgsVectorFileWriter.writeAsVectorFormatV3(layer, path, QgsProject.instance().transformContext(), options)
        except Exception as error:
            logger.error("An error occured exporting layer to ESRI File Geodatabase")
            logger.error(f'{type(error).__name__}  –  {str(error)}')
            logger.critical("Program terminated")
            script_failed()

    def packageLayers(layers: list, path: str,  overwrite: bool, style: bool):
        """
        Adds layers to a GeoPackage.
        If the GeoPackage exists and Overwrite existing GeoPackage is checked, 
        it will be overwritten (removed and recreated). 
        If the GeoPackage exists and Overwrite existing GeoPackage is not checked, the layer will be appended.

        Args:
            input (list of QgsVectorLayers): The (vector) layers to import into the GeoPackage. Raster layers are not supported. If a raster layer is added, a QgsProcessingException will be thrown.
            overwrite (boolean): If the specified GeoPackage exists, setting this option to True will make sure that it is deleted and a new one will be created before the layers are added. If set to False, layers will be appended.
            style (boolean): Save the layer styles
            path (string): The full path for the Geopackage to be created
        """

        logger.info("Performing packageLayers")
        logger.info(f'Processing {str(len(layers))} layers')
        try:
            parameter = {
                'INPUT': layers,
                'OVERWRITE': overwrite,
                'SAVE_STYLES': style,
                'OUTPUT': path
            }
            logger.info(f'Parameters: {str(parameter)}')
            processing.run('native:package', parameter)['OUTPUT']           
            logger.info("packageLayers finished")
        except Exception as error:
            logger.error("An error occured in packageLayers")
            logger.error(f'{type(error).__name__}  –  {str(error)}')
            logger.critical("Program terminated" )
            script_failed()

append_geopackage(layer, layername, geopackage)

Append a layer to an existing geopackage. If the new layer does not exist, it will be created. It it exists, the features will be appended to the layer.

Parameters:

Name Type Description Default
layer QgsVectorLayer

The QgsVectorLayer that is to be written to a file

 required
layername string

The name of the layer in the geopackage file

 required
geopackage string

The full path for the geopackage to be created

 required
Source code in python\engine\outputs.py 
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
def append_geopackage(layer: str, layername: str, geopackage: str):
    """
    Append a layer to an existing geopackage.
    If the new layer does not exist, it will be created. It it exists, the features will be appended to the layer.

    Args:
        layer (QgsVectorLayer): The QgsVectorLayer that is to be written to a file
        layername (string): The name of the layer in the geopackage file
        geopackage (string): The full path for the geopackage to be created
    """

    logger.info("Running append layer to Geopackage")
    if os.path.isfile(geopackage):
        logger.info(f'Geopackage {geopackage} exists, appending layer')
        tempfile = create_tempfile(layer, 'append_geopackage')

        try:
            config = get_config()
            ## ogr2ogr parameters
            table = f'-nln "{layername}"'
            ogr2ogrstring = f'{config["QGIS_bin_folder"]}/ogr2ogr.exe -f "GPKG" {geopackage} {tempfile} -nln {layername} -update -append'
            logger.info(f'Writing new layer {layername} to: {geopackage}')
            logger.info(f'Ogr2ogr command {ogr2ogrstring}')
            ogr2ogrstring.join(' -progress')
            run = subprocess.run(ogr2ogrstring, stderr=subprocess.STDOUT)
            if run.stdout:
                logger.info(run.stdout)
            delete_tempfile(tempfile)
            logger.info(f'Append to geopackage completed')

        except Exception as error:
            logger.error("An error occured appending layer to geopackage")
            logger.error(f'{type(error).__name__}  –  {str(error)}')
            logger.critical("Program terminated")
            script_failed() 
    else:
        logger.error("Target geopackage not found")
        logger.critical("Program terminated")
        script_failed()

excel(layer, path)

A function that exports a QgsVectorLayer into an excel spredsheet.

Parameters:

Name Type Description Default
layer QgsVectorLayer

The QgsVectorLayer to be exported into an excel spredsheet.

 required
path string

the ouput file to be created.

 required
Source code in python\engine\outputs.py 
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
def excel(layer: QgsVectorLayer, path : str):
    """
    A function that exports a QgsVectorLayer into an excel spredsheet.

    Args:
        layer (QgsVectorLayer): The QgsVectorLayer to be exported into an excel spredsheet.
        path (string): the ouput file to be created.
    """

    if layerHasFeatures(layer):
        logger.info(f'Writing {str(layer.featureCount())} features to Excel : {path}')
    try:
        parameter = {'LAYERS': [layer],
                'USE_ALIAS': True,
                'FORMATTED_VALUES': False,
                'OUTPUT': path}
        processing.run("native:exporttospreadsheet", parameter)
        logger.info(f'Parameters: {str(parameter)}')
        logger.info("Export to Excel completed")
    except Exception as error:
        logger.error("An error occured exporting layer to Excel")
        logger.error(f'{type(error).__name__}  –  {str(error)}')
        logger.critical("Program terminated")
        script_failed()

file(layer, path, format)

Parameters:

Name Type Description Default
layer QgsVectorLayer

The QgsVectorLayer that is to be written to a file

 required
path string

The full path for the file to be created

 required
format string

The driver type used to write the data to the file.

 required
Source code in python\engine\outputs.py 
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
def file(layer: str, path: str, format: str):
    """
    Args:
        layer (QgsVectorLayer): The QgsVectorLayer that is to be written to a file
        path (string): The full path for the file to be created
        format (string): The driver type used to write the data to the file. 
    """

    if layerHasFeatures(layer):
        logger.info(f'Writing {str(layer.featureCount())} features to: {path}')
    try:
        options = QgsVectorFileWriter.SaveVectorOptions()
        options.driverName = format
        QgsVectorFileWriter.writeAsVectorFormatV3(layer, path, QgsProject.instance().transformContext(), options)
        logger.info("Export completed")
    except Exception as error:
        logger.error("An error occured exporting layer")
        logger.error(f'{type(error).__name__}  –  {str(error)}')
        logger.critical("Program terminated")
        script_failed()

filegdb(layer, layername, path)

A function that export a QgsVectorLayer into an ESRI File

Parameters:

Name Type Description Default
layer QgsVectorLayer

The layer that is to be written to an ESRI File GeoDatabase

 required
path string

The full path for the ESRI File Geodatabase to be created

 required
layername string

The name of the resulting layer in the ESRI File Geodatabase

 required
Source code in python\engine\outputs.py 
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
def filegdb(layer: QgsVectorLayer, layername: str, path: str):
    """
    A function that export a QgsVectorLayer into an ESRI File

    Args:
        layer (QgsVectorLayer): The layer that is to be written to an ESRI File GeoDatabase
        path (string): The full path for the ESRI File Geodatabase to be created
        layername (string): The name of the resulting layer in the ESRI File Geodatabase
    """

    if layerHasFeatures(layer):
        logger.info(f'Writing {str(layer.featureCount())} features to: {path}')
    try:
        options = QgsVectorFileWriter.SaveVectorOptions()
        options.driverName = 'OpenFileGDB'
        options.layerName = layername
        QgsVectorFileWriter.writeAsVectorFormatV3(layer, path, QgsProject.instance().transformContext(), options)
    except Exception as error:
        logger.error("An error occured exporting layer to ESRI File Geodatabase")
        logger.error(f'{type(error).__name__}  –  {str(error)}')
        logger.critical("Program terminated")
        script_failed()

geopackage(layer, layername, geopackage, overwrite)

A function that writes a QgsVectorLayer to a Geopackage file.

Parameters:

Name Type Description Default
layer QgsVectorLayer

The QgsVectorLayer that is to be written to the geopackage

 required
layername string

The name of the layer in the geopackage file

 required
geopackage string

The full path for the geopackage to be created

 required
overwrite boolean

Specify wheather the writer will overwrite existing geopackage or append layer. Boolean True/False

 required
Source code in python\engine\outputs.py 
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
def geopackage(layer: QgsVectorLayer, layername: str, geopackage: str, overwrite: bool):
    """
    A function that writes a QgsVectorLayer to a Geopackage file. 

    Args:
        layer (QgsVectorLayer): The QgsVectorLayer that is to be written to the geopackage
        layername (string): The name of the layer in the geopackage file
        geopackage (string): The full path for the geopackage to be created
        overwrite (boolean): Specify wheather the writer will overwrite existing geopackage or append layer. Boolean True/False
    """

    if layerHasFeatures(layer):
        logger.info(f'Writing {str(layer.featureCount())} features to geopackage : {geopackage}')
    try:
        layer.setName(layername)
        parameter = {'LAYERS': [layer],
                'OUTPUT': geopackage,
                'OVERWRITE': overwrite,
                'SAVE_STYLES': False,
                'SAVE_METADATA': False,
                'SELECTED_FEATURES_ONLY': False}
        processing.run("native:package", parameter)
        logger.info(f'Parameters: {str(parameter)}')
        logger.info("Export to Geopackage completed")
    except Exception as error:
        logger.error("An error occured exporting layer to geopackage")
        logger.error(f'{type(error).__name__}  –  {str(error)}')
        logger.critical("Program terminated")
        script_failed()

mssql(layer, connection, driver, schema, table, overwrite, geom_type, geom_name, ogr2ogr_params)

A function that exports a QgsVectorLayer into a MSSQL database using ogr2ogr. The function writes the data to a temporary geojson file, that is then importet to the database with ogr2ogr.

Parameters:

Name Type Description Default
layer QgsVectorLayer

The QgsVectorLayer that is to be written to a file.

 required
connection string

The name of a connection from the settings.json file.

 required
driver string

The driver used for writing to the database. Default value is : 'SQL Server'.

 required
schema string

The target schema.

 required
table string

The target table.

 required
overwrite boolean

Overwrite or append.

 required
geom_type string

Geometry type. One of geometry/geography.

 required
geom_name string

Name of the geometry coloumn.

 required
ogr2ogr_params string

Extra parameters for ogr2ogr besides the default.

 required
Source code in python\engine\outputs.py 
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
def mssql(layer: QgsVectorLayer, connection: str, driver: str, schema: str, table: str, overwrite: str, geom_type: str, geom_name: str, ogr2ogr_params: str):
    """
    A function that exports a QgsVectorLayer into a MSSQL database using ogr2ogr.
    The function writes the data to a temporary geojson file, that is then importet to the database with ogr2ogr.

    Args:
        layer (QgsVectorLayer): The QgsVectorLayer that is to be written to a file.
        connection (string): The name of a connection from the settings.json file.
        driver (string): The driver used for writing to the database. Default value is : 'SQL Server'.
        schema (string): The target schema.
        table (string): The target table.
        overwrite (boolean): Overwrite or append.
        geom_type (string): Geometry type. One of geometry/geography.
        geom_name (string): Name of the geometry coloumn.
        ogr2ogr_params (string): Extra parameters for ogr2ogr besides the default.
    """

    try:
        config = get_config()
        logger.info(f'Exporting {layer} to MSSQL Server')
        dbconnection = config['DatabaseConnections'][connection]
        conn = copy.copy(dbconnection)
        conn['password'] = 'xxxxxxx'
        logger.info(f'Connection: {str(conn)}')
        logger.info(f'Creating temporary layer in Temp folder')
        tmp_path = f'{config["TempFolder"]}mssql_layer_{str(randrange(1000))}.geojson'
        options = QgsVectorFileWriter.SaveVectorOptions()
        options.driverName = 'GeoJSON'
        QgsVectorFileWriter.writeAsVectorFormatV3(layer, tmp_path, QgsProject.instance().transformContext(), options)
        logger.info('Temporary layer created')

        ## ogr2ogr parameters
        table = f'-nln "{schema}.{table}"'
        geometry = f'-lco "GEOM_TYPE={geom_type}" -lco "GEOM_NAME={geom_name}"'

        if driver != '':
            mssql_driver = driver
        else:
             mssql_driver = 'SQL Server'

        if dbconnection['user'] == '' and dbconnection['password'] == '':
            ogrconnection = f"MSSQL:server={dbconnection['host']};driver={mssql_driver};database={dbconnection['databasename']};trusted_connection=yes;"
        else:
            ogrconnection = f"MSSQL:server={dbconnection['host']};driver=SQL Server;database={dbconnection['databasename']};uid={dbconnection['user']};pwd={dbconnection['password']}"

        if overwrite == True:
            ow = '-overwrite'
        else:
            ow = ''

        if ogr2ogr_params != '':
            ep = ' ' + ogr2ogr_params
        else:
            ep = ''

        ogr2ogrstring = f'{config["QGIS_bin_folder"]}/ogr2ogr.exe --config MSSQLSPATIAL_USE_BCP FALSE -f "MSSQLSpatial" "{ogrconnection}" "{tmp_path}" {geometry} {table} -lco UPLOAD_GEOM_FORMAT=wkt {ep}  {ow}'
        logger.info(f'Writing to MSSQL database {dbconnection["databasename"]}, {table}')
        ogr2ogrstring.join(' -progress')
        run = subprocess.run(ogr2ogrstring, stderr=subprocess.STDOUT)
        if run.stdout:
            logger.info(run.stdout)
        os.remove(tmp_path)
        logger.info(f'Export to MSSQL completed')

    except Exception as error:
        try:
            os.remove(tmp_path)
        except:
            pass

        logger.error("An error occured exporting to MSSQL")
        logger.error(f'{type(error).__name__}  –  {str(error)}')
        logger.critical("Program terminated")
        script_failed()

packageLayers(layers, path, overwrite, style)

Adds layers to a GeoPackage. If the GeoPackage exists and Overwrite existing GeoPackage is checked, it will be overwritten (removed and recreated). If the GeoPackage exists and Overwrite existing GeoPackage is not checked, the layer will be appended.

Parameters:

Name Type Description Default
input list of QgsVectorLayers

The (vector) layers to import into the GeoPackage. Raster layers are not supported. If a raster layer is added, a QgsProcessingException will be thrown.

 required
overwrite boolean

If the specified GeoPackage exists, setting this option to True will make sure that it is deleted and a new one will be created before the layers are added. If set to False, layers will be appended.

 required
style boolean

Save the layer styles

 required
path string

The full path for the Geopackage to be created

 required
Source code in python\engine\outputs.py 
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
def packageLayers(layers: list, path: str,  overwrite: bool, style: bool):
    """
    Adds layers to a GeoPackage.
    If the GeoPackage exists and Overwrite existing GeoPackage is checked, 
    it will be overwritten (removed and recreated). 
    If the GeoPackage exists and Overwrite existing GeoPackage is not checked, the layer will be appended.

    Args:
        input (list of QgsVectorLayers): The (vector) layers to import into the GeoPackage. Raster layers are not supported. If a raster layer is added, a QgsProcessingException will be thrown.
        overwrite (boolean): If the specified GeoPackage exists, setting this option to True will make sure that it is deleted and a new one will be created before the layers are added. If set to False, layers will be appended.
        style (boolean): Save the layer styles
        path (string): The full path for the Geopackage to be created
    """

    logger.info("Performing packageLayers")
    logger.info(f'Processing {str(len(layers))} layers')
    try:
        parameter = {
            'INPUT': layers,
            'OVERWRITE': overwrite,
            'SAVE_STYLES': style,
            'OUTPUT': path
        }
        logger.info(f'Parameters: {str(parameter)}')
        processing.run('native:package', parameter)['OUTPUT']           
        logger.info("packageLayers finished")
    except Exception as error:
        logger.error("An error occured in packageLayers")
        logger.error(f'{type(error).__name__}  –  {str(error)}')
        logger.critical("Program terminated" )
        script_failed()

postgis(layer, connection, dbname, schema, tablename, overwrite=True)

A function that exports a QgsVectorLayer into a Postgis database.

Parameters:

Name Type Description Default
layer QgsVectorLayer

The QgsVectorLayer to be exported into Postgis

 required
connection string

The name of the connection object in the settings file

 required
dbname string

The database name

 required
schema string

Schema name

 required
tablename string

The name of the table that will be imported

 required
overwrite boolean

Defaults to True. Should the resulting table in Postgis be overwritten if it exists. If set to False, then it will append the data.

 True
Source code in python\engine\outputs.py 
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
def postgis(layer: QgsVectorLayer, connection : str, dbname: str, schema: str, tablename: str, overwrite: bool = True):
    """
    A function that exports a QgsVectorLayer into a Postgis database.

    Args:
        layer (QgsVectorLayer): The QgsVectorLayer to be exported into Postgis
        connection (string): The name of the connection object in the settings file
        dbname (string): The database name
        schema (string): Schema name
        tablename (string): The name of the table that will be imported
        overwrite (boolean): Defaults to True. Should the resulting table in Postgis be overwritten if it exists. If set to False, then it will append the data.
    """

    if layerHasFeatures(layer):
        logger.info(f'Exporting {str(layer.featureCount())} features to Postgis')
    tempfile = create_tempfile(layer, 'postgis')
    logger.info('Temporary layer created')

    try:
        config = get_config()
        dbConnection = config['DatabaseConnections'][connection]

        # ogr2ogr parameters
        table = f'-nln "{schema}.{tablename}"'
        ogrconnection = f'PG:"host={dbConnection["host"]} port={dbConnection["port"]} dbname={dbname} schemas={schema} user={dbConnection["user"]} password={dbConnection["password"]}"'
        ogr2ogrstring = f'{config["QGIS_bin_folder"]}/ogr2ogr.exe -f "PostgreSQL" {ogrconnection} {tempfile} {table}'
        if overwrite:
            ogr2ogrstring = f'{ogr2ogrstring} -overwrite'
        logger.info(f'Writing to PostGIS database {dbname}')
        run = subprocess.run(ogr2ogrstring, capture_output=True)
        delete_tempfile(tempfile)
        logger.info('Temporary layer removed')
        logger.info('Export to PostGIS completed')

    except Exception as error:
        logger.error("An error occured exporting to Postgis")
        logger.error(f'{type(error).__name__}  –  {str(error)}')
        logger.critical("Program terminated")
        script_failed()

textfile(file, list, newline)

Create an output file from a list of lines.

Parameters:

Name Type Description Default
file string

The path to the resulting file

 required
list list of strings

List of lines to be written to the file.

 required
newline boolean

If true, a newline character will be added to the end of each line.

 required
Source code in python\engine\outputs.py 
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
def textfile(file: str, list: list, newline: bool):
    """
    Create an output file from a list of lines. 

    Args:
        file (string): The path to the resulting file
        list (list of strings): List of lines to be written to the file.
        newline (boolean): If true, a newline character will be added to the end of each line.
    """
    logger.info("Creating text file: " + file)
    try:
        with open(file, 'w', encoding="utf-8") as f:
            for line in list:
                if newline == True:
                    f.write(line + '\\n')
                else:
                    f.write(line)
        logger.info("File created")
    except Exception as error:
        logger.error("An error occured creating file")
        logger.error(f'{type(error).__name__}  –  {str(error)}')
        logger.critical("Program terminated")
        script_failed()