Alternativas ao ogr2ogr para carregar arquivos GeoJson grandes no PostGIS

Eu tenho um arquivo GeoJson de 7 GB que gostaria de carregar em um banco de dados PostGIS. Eu tentei usar ogr2ogr, mas ele falha porque o arquivo é muito grande para ogr2ogr carregar na memória e depois processar.

Existem outras alternativas para carregar esse arquivo geojson no PostGIS?

O erro ogr2ogr que recebo é:

ERRO 2: CPLMalloc (): falta de memória alocando -611145182 bytes. Este aplicativo solicitou que o tempo de execução o encerrasse de maneira incomum. Entre em contato com a equipe de suporte do aplicativo para obter mais informações.

A amostra que você enviou mostra que pode ser possível dividir manualmente o arquivo usando um editor como o bloco de notas ++

1) Para cada pedaço, crie um cabeçalho:

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

2) Após o cabeçalho, coloque muitos recursos:

{"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/[email protected]", "address": "Le\u00f3n Tolstoi #18 PH Col. Anzures", "owner": "simplegeo", "postcode": "11590"}},

3) Finalize o pedaço com:

]}

EDIT - Aqui está o código python que dividirá o arquivo em partes de tamanho definido (em número de recursos):

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.

Infelizmente, o JSON é muito parecido com o XML, pouco adequado para o processamento de fluxo, então quase todas as implementações exigem que todo o conjunto de dados seja carregado na memória. Embora isso seja bom para conjuntos pequenos no seu caso, não há outra opção além de dividir o conjunto de dados em blocos menores e gerenciáveis.

Melhorando a solução de Pablo, aqui está uma que não exige que você abra e carregue o arquivo em um editor e divida manualmente, mas tenta automatizar o máximo possível todo o processo.

Copie o arquivo json em um host Unix (linux, osx) ou instale as ferramentas cygwin no Windows. Em seguida, abra um shell e use o vim para remover a primeira e a última linha do arquivo:

$ vim places.json

digite dd para remover a primeira linha e, em seguida, SHIFT-G para mover o final do arquivo, digite dd novamente para remover a última linha. Agora digite : wq para salvar as alterações. Isso deve demorar apenas alguns minutos.

Agora vamos aproveitar o poder total do unix para dividir o arquivo em partes mais gerenciáveis. No tipo de shell:

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

Vá pegar uma cerveja. Isso dividirá o arquivo em muitos arquivos menores, cada um contendo 10000 linhas. Você pode aumentar o número de linhas, desde que o mantenha pequeno o suficiente para que o ogr2gr possa gerenciá-lo.

Agora vamos enfiar a cabeça e o rabo em cada um dos arquivos:

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

Vá pegar uma cobra. Os dois primeiros comandos simplesmente criam um arquivo de cabeçalho e rodapé com o conteúdo correto (apenas por conveniência), enquanto o último adiciona cabeçalho e rodapé a cada um dos blocos divididos acima e remove o bloco sem cabeçalho / rodapé (para economizar espaço) )

Neste ponto, esperamos que você possa processar os muitos arquivos places-chunks - *. Json com ogr2ogr:

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

É possível carregar seus dados com o FME Desktop. É muito fácil.

Deve ser fácil escrever um leitor e gravador preguiçoso em Python que converta seu arquivo geojson no formato shapefile muito menor ou diretamente no SQL sem fazer tudo na memória. Uma vez convertidas, as ferramentas nativas do PostGIS podem importar grandes conjuntos de dados. O suporte geojson no OGR é relativamente novo e não há sinalizadores para manipular arquivos grandes.

Se você puder compartilhar um pedaço gerenciável do seu arquivo, eu poderia ajudá-lo.

Isso melhorou no GDAL 2.3.0 https://trac.osgeo.org/gdal/wiki/Release/2.3.0-News agora é muito mais eficiente em termos de memória ao ler grandes arquivos GeoJSON.