การเพิ่ม GeoPandas Dataframe ไปยังตาราง PostGIS?

ฉันมี GeoPandas Dataframe ง่าย ๆ :

ฉันต้องการอัปโหลด GeoDataframe นี้ไปยังตาราง PostGIS ฉันมีการตั้งค่าฐานข้อมูลพร้อมส่วนขยาย PostGIS แล้ว แต่ไม่สามารถเพิ่ม Dataframe นี้เป็นตารางได้

ฉันได้ลองทำสิ่งต่อไปนี้แล้ว:

engine = <>
meta = MetaData(engine)
eld_test = Table('eld_test', meta, Column('id', Integer, primary_key=True), Column('key_comb_drvr', Text), 
                 Column('geometry', Geometry('Point', srid=4326))) 
eld_test.create(engine) 
conn = engine.connect() 
conn.execute(eld_test.insert(), df.to_dict('records'))

การใช้วิธีto_sqlของ Panda และSQLAlchemyคุณสามารถเก็บ dataframe ใน Postgres ได้ และเนื่องจากคุณกำลังเก็บ Geodataframe, GeoAlchemyจะจัดการคอลัมน์ geom สำหรับคุณ นี่คือตัวอย่างรหัส:

# Imports
from geoalchemy2 import Geometry, WKTElement
from sqlalchemy import *
import pandas as pd
import geopandas as gpd

# Creating SQLAlchemy's engine to use
engine = create_engine('postgresql://username:password@host:socket/database')


geodataframe = gpd.GeoDataFrame(pd.DataFrame.from_csv('<your dataframe source>'))
#... [do something with the geodataframe]

geodataframe['geom'] = geodataframe['geometry'].apply(lambda x: WKTElement(x.wkt, srid=<your_SRID>)

#drop the geometry column as it is now duplicative
geodataframe.drop('geometry', 1, inplace=True)

# Use 'dtype' to specify column's type
# For the geom column, we will use GeoAlchemy's type 'Geometry'
geodataframe.to_sql(table_name, engine, if_exists='append', index=False, 
                         dtype={'geom': Geometry('POINT', srid= <your_srid>)})

น่าสังเกตว่าพารามิเตอร์ 'if_exists' ช่วยให้คุณสามารถจัดการวิธีที่ dataframe จะถูกเพิ่มลงในตาราง postgres ของคุณ:

    if_exists = replace: If table exists, drop it, recreate it, and insert data.
    if_exists = fail: If table exists, do nothing.
    if_exists = append: If table exists, insert data. Create if does not exist.

ฉันยังมีคำถามเดียวกันกับที่คุณถามและใช้เวลาไปหลายวัน (มากกว่าที่ฉันยอมรับ) มองหาวิธีแก้ปัญหา สมมติว่าตาราง postgreSQL ต่อไปนี้มีนามสกุล postGIS

postgres=> \d cldmatchup.geo_points;
Table "cldmatchup.geo_points"
Column   |         Type         |                               Modifiers                                
-----------+----------------------+------------------------------------------------------------------------
gridid    | bigint               | not null default nextval('cldmatchup.geo_points_gridid_seq'::regclass)
lat       | real                 | 
lon       | real                 | 
the_point | geography(Point,4326) | 

Indexes:
"geo_points_pkey" PRIMARY KEY, btree (gridid)

นี่คือสิ่งที่ฉันได้ทำงานในที่สุด :

import geopandas as gpd
from geoalchemy2 import Geography, Geometry
from sqlalchemy import create_engine, MetaData, Table
from sqlalchemy.orm import sessionmaker
from shapely.geometry import Point
from psycopg2.extensions import adapt, register_adapter, AsIs

# From http://initd.org/psycopg/docs/advanced.html#adapting-new-types but 
# modified to accomodate postGIS point type rather than a postgreSQL 
# point type format
def adapt_point(point):
    from psycopg2.extensions import adapt, AsIs
    x = adapt(point.x).getquoted()
    y = adapt(point.y).getquoted()
    return AsIs("'POINT (%s %s)'" % (x, y))

register_adapter(Point, adapt_point)

engine = create_engine('postgresql://<yourUserName>:postgres@localhost:5432/postgres', echo=False)
Session = sessionmaker(bind=engine)
session = Session()
meta = MetaData(engine, schema='cldmatchup')

# Create reference to pre-existing "geo_points" table in schema "cldmatchup"
geoPoints = Table('geo_points', meta, autoload=True, schema='cldmatchup', autoload_with=engine)

df = gpd.GeoDataFrame({'lat':[45.15, 35., 57.], 'lon':[-35, -150, -90.]})

# Create a shapely.geometry point 
the_point = [Point(xy) for xy in zip(df.lon, df.lat)]

# Create a GeoDataFrame specifying 'the_point' as the column with the 
# geometry data
crs = {'init': 'epsg:4326'}
geo_df = gpd.GeoDataFrame(df.copy(), crs=crs, geometry=the_point)

# Rename the geometry column to match the database table's column name.
# From https://media.readthedocs.org/pdf/geopandas/latest/geopandas.pdf,
# Section 1.2.2 p 7
geo_df = geo_df.rename(columns{'geometry':'the_point'}).set_geometry('the_point')

# Write to sql table 'geo_points'
geo_df.to_sql(geoPoints.name, engine, if_exists='append', schema='cldmatchup', index=False)

session.close()

ฉันไม่สามารถบอกได้ว่าตรรกะการเชื่อมต่อฐานข้อมูลของฉันนั้นดีที่สุดเพราะฉันคัดลอกลิงก์นั้นมาจากลิงค์อื่นและมีความสุขที่ฉันสามารถสร้างตารางที่มีอยู่ของฉันโดยอัตโนมัติพร้อมกับนิยามเรขาคณิตได้ ฉันเขียนหลามไปที่รหัสพื้นที่ sql เพียงไม่กี่เดือนดังนั้นฉันจึงรู้ว่ามีอะไรมากมายให้เรียนรู้

ฉันมีทางออกที่ต้องการเพียง psycopg2 และหุ่นดี (นอกจาก geopandas แน่นอน) โดยทั่วไปแล้วมันเป็นการปฏิบัติที่ไม่ดีในการวนซ้ำ(Geo)DataFrameวัตถุต่าง ๆ เพราะมันช้า แต่สำหรับคนตัวเล็กหรือสำหรับงานที่ต้องทำครั้งเดียว

โดยทั่วไปแล้วมันจะทำงานโดยการทิ้งรูปทรงเรขาคณิตให้เป็นรูปแบบ WKB ในคอลัมน์อื่นแล้วพิมพ์ซ้ำอีกครั้งเพื่อGEOMETRYพิมพ์เมื่อทำการแทรก

โปรดทราบว่าคุณจะต้องสร้างตารางล่วงหน้าด้วยคอลัมน์ที่ถูกต้อง

import psycopg2 as pg2
from shapely.wkb import dumps as wkb_dumps
import geopandas as gpd


# Assuming you already have a GeoDataFrame called "gdf"...

# Copy the gdf if you want to keep the original intact
insert_gdf = gdf.copy()

# Make a new field containing the WKB dumped from the geometry column, then turn it into a regular 
insert_gdf["geom_wkb"] = insert_gdf["geometry"].apply(lambda x: wkb_dumps(x))

# Define an insert query which will read the WKB geometry and cast it to GEOMETRY type accordingly
insert_query = """
    INSERT INTO my_table (id, geom)
    VALUES (%(id)s, ST_GeomFromWKB(%(geom_wkb)s));
"""

# Build a list of execution parameters by iterating through the GeoDataFrame
# This is considered bad practice by the pandas community because it is slow.
params_list = [
    {
        "id": i,
        "geom_wkb": row["geom_wkb"]
    } for i, row in insert_gdf.iterrows()
]

# Connect to the database and make a cursor
conn = pg2.connect(host=<your host>, port=<your port>, dbname=<your dbname>, user=<your username>, password=<your password>)
cur = conn.cursor()

# Iterate through the list of execution parameters and apply them to an execution of the insert query
for params in params_list:
    cur.execute(insert_query, params)
conn.commit()