Creating a custom field that automatically converts between db types and python types

I want to use Peewee to manage a collection of GIS data. I’ve defined some custom fields to handle the PostGIS geometry type:

class GeomField(Field):
    db_field = 'geometry'

    def __init__(self, geom_type=None, geom_srid=None, **kwargs):
        self.geom_srid = geom_srid
        self.geom_type = geom_type

        super(GeomField, self).__init__(**kwargs)
        if geom_type:
            if geom_srid:
                self.db_field = 'geometry(%s, %s)' % (geom_type, geom_srid)
            else:
                self.db_field = 'geometry(%s)' % (geom_type, )


class PointField(GeomField):
    def __init__(self, geom_srid=None, **kwargs):
        super(PointField, self).__init__(
            geom_type='Point',
            geom_srid=geom_srid,
            **kwargs)

This works fine so far. I would like to be able to set a PointField to a Python tuple and have it converted automatically to a geometry value (and I want the inverse as well). I started with this:

def db_value(self, value):
    return fn.st_setsrid(
      fn.st_makepoint(value[0],value[1],self.geom_srid))

But I guess that Peewee doesn’t interpolate these functions at the right point, because that gets me:

ValueError: only bytes values expected, got Func

So instead I’ve done this:

def python_value(self, value):
    res = database.execute_sql('select st_x(%s), st_y(%s)',
                               (value, value))
    return res.fetchone()

def db_value(self, value):
    res = database.execute_sql(
        'select st_setsrid(st_makepoint(%s,%s), %s)',
        (value[0], value[1], self.geom_srid))
    return res.fetchone()

This works, but it seems less than elegant and I am curious if I am missing a simpler solution.

[whalesalad]

@coleifer is there a way to override the fn called when performing a read?

IE, instead of

select foo, bar, baz from table

You could specify a wrapper fn for a field, so you could so something like

select foo, bar, ST_AsText(baz) from table

which would alleviate a lot of the trouble here (I too am trying to figure out how to read/write a simple geometry(Point) field with postgis.

[davidbernat]

This appears to create the same outcome as @nbolten , and allows the containment to be on the field itself. It is unclear to me whether _returning is only those fields selected by the select() method, and how this will affect performance in more complex queries. Posting here, though.

class PointField(pw.Field):
    """Geometry field type Point, conforming to MySQL 8.0+, format is WKT: 'POINT(18 23)'"""

    # Field type in MySQL is Point with a capital P.
    field_type = 'Point'

    def python_value(self, value):
        return value

    def db_value(self, ewkt):
        """Converts EWKT format to MySQL database requirements, e.g., SRID=3857;POINT(10,10)"""

        # Does the ewkt start with "SRID=XXXX;...".
        # If so, remove the value from the geometry and parse/extract the srid
        s = ewkt.split(";")
        if s[0].startswith("SRID="):
            geo = ";".join(s[1:])
            srid = s[0].split("=")[1]
            return pw.fn.ST_GeomFromText(geo, srid)
        else:
            return pw.fn.ST_GeomFromText(ewkt)

    def _db_wrangler(self, field):
        return pw.fn.ST_AsText(field).alias(field.name)

query = PadsLocations.select(PadsLocations)
for r_i, r in enumerate(query._returning):
    if hasattr(r, '_db_wrangler'):
        query._returning[r_i] = r._db_wrangler(r)