Alternative a ogr2ogr per il caricamento di file GeoJson di grandi dimensioni su PostGIS

Ho un file GeoJson da 7 GB che vorrei caricare in un database PostGIS. Ho provato a usare ogr2ogr ma non riesce perché il file è troppo grande per essere caricato in memoria e poi processato da ogr2ogr.

Esistono altre alternative per caricare questo file geojson in PostGIS?

L'errore ogr2ogr che ottengo è:

ERRORE 2: CPLMalloc (): memoria esaurita allocando -611145182 byte. Questa applicazione ha richiesto a Runtime di terminarlo in modo insolito. Per ulteriori informazioni, contattare il team di supporto dell'applicazione.

L'esempio che hai inviato mostra che potrebbe essere possibile dividere manualmente il file usando un editor come notepad ++

1) Per ogni pezzo creare un'intestazione:

{"type":"FeatureCollection","features":[

2) Dopo l'intestazione posizionare molte funzionalità:

{"geometry": {"type": "Point", "coordinates": [-103.422819, 20.686477]}, "type": "Feature", "id": "SG_3TspYXmaZcMIB8GxzXcayF_20.686477_-103.422819@1308163237", "properties": {"website": "http://www.buongiorno.com", "city": "M\u00e9xico D.F. ", "name": "Buongiorno", "tags": ["mobile", "vas", "community", "social-networking", "connected-devices", "android", "tablets", "smartphones"], "country": "MX", "classifiers": [{"category": "Professional", "type": "Services", "subcategory": "Computer Services"}], "href": "http://api.simplegeo.com/1.0/features/SG_3TspYXmaZcMIB8GxzXcayF_20.686477_-103.422819@1308163237.json", "address": "Le\u00f3n Tolstoi #18 PH Col. Anzures", "owner": "simplegeo", "postcode": "11590"}},

3) Termina il pezzo con:

]}

MODIFICA - Ecco il codice Python che divide il file in pezzi di dimensioni definite (in numero di funzioni):

import sys

class JsonFile(object):
    def __init__(self,file):
        self.file = open(file, 'r') 
    def split(self,csize):
        header=self.file.readline()
        number=0
        while True:
            output=open("chunk %s.geojson" %(number),'w')
            output.write(header)
            number+=1
            feature=self.file.readline()
            if feature==']}':
                break
            else:
                for i in range(csize):
                    output.write(feature)
                    feature=self.file.readline()
                    if feature==']}':
                        output.write("]}")
                        output.close()
                        sys.exit("Done!")
                output.write("]}")
                output.close()

if __name__=="__main__":
    myfile = JsonFile('places_mx.geojson')
    myfile.split(2000) #size of the chunks.

Sfortunatamente, JSON è molto simile a XML, non è adatto per l'elaborazione di flussi, quindi quasi tutte le implementazioni richiedono che l'intero set di dati venga caricato in memoria. Mentre questo è ok per piccoli insiemi nel tuo caso, non c'è altra opzione che suddividere il set di dati in blocchi più piccoli e gestibili.

Migliorando la soluzione di Pablo, eccone uno che non richiede di aprire e caricare il file in un editor e dividerlo manualmente, ma cerca di automatizzare il più possibile l'intero processo.

Copia il file json su un host Unix (linux, osx) o installa gli strumenti cygwin su Windows. Quindi apri una shell e usa vim per rimuovere la prima e l'ultima riga dal file:

$ vim places.json

digitare dd per rimuovere la prima riga, quindi MAIUSC-G per spostare la fine del file, digitare nuovamente dd per rimuovere l'ultima riga. Ora digita : wq per salvare le modifiche. Questo dovrebbe richiedere solo un paio di minuti al massimo.

Ora sfrutteremo la pura potenza di unix per dividere il file in blocchi più gestibili. Nel tipo di shell:

$ split -l 10000 places.json places-chunks-

Vai a prendere una birra. Questo dividerà il file in molti file più piccoli, ognuno contenente 10000 righe. È possibile aumentare il numero di righe, purché lo si mantenga abbastanza piccolo da consentire a ogr2gr di gestirlo.

Ora atteniamo testa e coda a ciascuno dei file:

$ echo '{"type":"FeatureCollection","features":[' > head
$ echo ']}' > tail
$ for f in places-chunks-* ; do cat head $f tail > $f.json && rm -f $f ; done

Vai a prendere uno snak. I primi due comandi creano semplicemente un file di intestazione e piè di pagina con il contenuto corretto (solo per praticità in realtà), mentre l'ultimo aggiungerà intestazione e piè di pagina a ciascuno dei blocchi che abbiamo diviso sopra e rimuoverà il pezzo di intestazione / footerless (per risparmiare spazio ).

A questo punto si spera di poter elaborare i molti file di luoghi-blocchi - *. Json con ogr2ogr:

$ for f in places-chunks-*.json ; do ogr2ogr -your-options-here $f ; done

È possibile caricare i tuoi dati con FME Desktop. È molto facile.

Dovrebbe essere semplice scrivere un lettore e uno scrittore pigro in Python che converti il ​​tuo file geojson in un formato molto più piccolo o direttamente in SQL senza fare tutto in memoria. Una volta convertiti, gli strumenti PostGIS nativi possono importare set di dati di grandi dimensioni. Il supporto geojson in OGR è relativamente nuovo e non ci sono flag per la gestione di file di grandi dimensioni.

Se riesci in qualche modo a condividere una parte gestibile del tuo file, potrei aiutarti.

Questo è migliorato in GDAL 2.3.0 https://trac.osgeo.org/gdal/wiki/Release/2.3.0-News ora è molto più efficiente in termini di memoria nella lettura di file GeoJSON di grandi dimensioni.