diff --git a/ogn/model/aircraft_beacon.py b/ogn/model/aircraft_beacon.py
index aed1cd8..69db821 100644
--- a/ogn/model/aircraft_beacon.py
+++ b/ogn/model/aircraft_beacon.py
@@ -1,48 +1,48 @@
-from sqlalchemy import Column, String, Integer, Float, Boolean, SmallInteger, ForeignKey, Index
-from sqlalchemy.orm import relationship
 from sqlalchemy.sql import func
 from .beacon import Beacon
 
+from ogn import db
+
 
 class AircraftBeacon(Beacon):
     __tablename__ = "aircraft_beacons"
 
     # Flarm specific data
-    address_type = Column(SmallInteger)
-    aircraft_type = Column(SmallInteger)
-    stealth = Column(Boolean)
-    address = Column(String)
-    climb_rate = Column(Float(precision=2))
-    turn_rate = Column(Float(precision=2))
-    signal_quality = Column(Float(precision=2))
-    error_count = Column(SmallInteger)
-    frequency_offset = Column(Float(precision=2))
-    gps_quality_horizontal = Column(SmallInteger)
-    gps_quality_vertical = Column(SmallInteger)
-    software_version = Column(Float(precision=2))
-    hardware_version = Column(SmallInteger)
-    real_address = Column(String(6))
-    signal_power = Column(Float(precision=2))
+    address_type = db.Column(db.SmallInteger)
+    aircraft_type = db.Column(db.SmallInteger)
+    stealth = db.Column(db.Boolean)
+    address = db.Column(db.String)
+    climb_rate = db.Column(db.Float(precision=2))
+    turn_rate = db.Column(db.Float(precision=2))
+    signal_quality = db.Column(db.Float(precision=2))
+    error_count = db.Column(db.SmallInteger)
+    frequency_offset = db.Column(db.Float(precision=2))
+    gps_quality_horizontal = db.Column(db.SmallInteger)
+    gps_quality_vertical = db.Column(db.SmallInteger)
+    software_version = db.Column(db.Float(precision=2))
+    hardware_version = db.Column(db.SmallInteger)
+    real_address = db.Column(db.String(6))
+    signal_power = db.Column(db.Float(precision=2))
     proximity = None
 
     # Calculated values
-    distance = Column(Float(precision=2))
-    radial = Column(SmallInteger)
-    quality = Column(Float(precision=2))        # signal quality normalized to 10km
-    location_mgrs = Column(String(15))          # full mgrs (15 chars)
-    location_mgrs_short = Column(String(9))     # reduced mgrs (9 chars), e.g. used for melissas range tool
-    agl = Column(Float(precision=2))
+    distance = db.Column(db.Float(precision=2))
+    radial = db.Column(db.SmallInteger)
+    quality = db.Column(db.Float(precision=2))        # signal quality normalized to 10km
+    location_mgrs = db.Column(db.String(15))          # full mgrs (15 chars)
+    location_mgrs_short = db.Column(db.String(9))     # reduced mgrs (9 chars), e.g. used for melissas range tool
+    agl = db.Column(db.Float(precision=2))
 
     # Relations
-    receiver_id = Column(Integer, ForeignKey('receivers.id', ondelete='SET NULL'))
-    receiver = relationship('Receiver', foreign_keys=[receiver_id], backref='aircraft_beacons')
+    receiver_id = db.Column(db.Integer, db.ForeignKey('receivers.id', ondelete='SET NULL'))
+    receiver = db.relationship('Receiver', foreign_keys=[receiver_id], backref='aircraft_beacons')
 
-    device_id = Column(Integer, ForeignKey('devices.id', ondelete='SET NULL'))
-    device = relationship('Device', foreign_keys=[device_id], backref='aircraft_beacons')
+    device_id = db.Column(db.Integer, db.ForeignKey('devices.id', ondelete='SET NULL'))
+    device = db.relationship('Device', foreign_keys=[device_id], backref='aircraft_beacons')
 
     # Multi-column indices
-    Index('ix_aircraft_beacons_receiver_id_distance', 'receiver_id', 'distance')
-    Index('ix_aircraft_beacons_device_id_timestamp', 'device_id', 'timestamp')
+    db.Index('ix_aircraft_beacons_receiver_id_distance', 'receiver_id', 'distance')
+    db.Index('ix_aircraft_beacons_device_id_timestamp', 'device_id', 'timestamp')
 
     def __repr__(self):
         return "<AircraftBeacon %s: %s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s>" % (
@@ -143,5 +143,5 @@ class AircraftBeacon(Beacon):
             self.location_mgrs_short]
 
 
-Index('ix_aircraft_beacons_date_device_id_address', func.date(AircraftBeacon.timestamp), AircraftBeacon.device_id, AircraftBeacon.address)
-Index('ix_aircraft_beacons_date_receiver_id_distance', func.date(AircraftBeacon.timestamp), AircraftBeacon.receiver_id, AircraftBeacon.distance)
+db.Index('ix_aircraft_beacons_date_device_id_address', func.date(AircraftBeacon.timestamp), AircraftBeacon.device_id, AircraftBeacon.address)
+db.Index('ix_aircraft_beacons_date_receiver_id_distance', func.date(AircraftBeacon.timestamp), AircraftBeacon.receiver_id, AircraftBeacon.distance)
diff --git a/ogn/model/airport.py b/ogn/model/airport.py
index 4dbc631..24ab452 100644
--- a/ogn/model/airport.py
+++ b/ogn/model/airport.py
@@ -1,5 +1,4 @@
 from geoalchemy2.types import Geometry
-from sqlalchemy import Column, String, Integer, Float, SmallInteger
 
 from ogn import db
 
@@ -7,21 +6,21 @@ from ogn import db
 class Airport(db.Model):
     __tablename__ = "airports"
 
-    id = Column(Integer, primary_key=True)
+    id = db.Column(db.Integer, primary_key=True)
 
-    location_wkt = Column('location', Geometry('POINT', srid=4326))
-    altitude = Column(Float(precision=2))
+    location_wkt = db.Column('location', Geometry('POINT', srid=4326))
+    altitude = db.Column(db.Float(precision=2))
 
-    name = Column(String, index=True)
-    code = Column(String(6))
-    country_code = Column(String(2))
-    style = Column(SmallInteger)
-    description = Column(String)
-    runway_direction = Column(SmallInteger)
-    runway_length = Column(SmallInteger)
-    frequency = Column(Float(precision=2))
+    name = db.Column(db.String, index=True)
+    code = db.Column(db.String(6))
+    country_code = db.Column(db.String(2))
+    style = db.Column(db.SmallInteger)
+    description = db.Column(db.String)
+    runway_direction = db.Column(db.SmallInteger)
+    runway_length = db.Column(db.SmallInteger)
+    frequency = db.Column(db.Float(precision=2))
 
-    border = Column('border', Geometry('POLYGON', srid=4326))
+    border = db.Column('border', Geometry('POLYGON', srid=4326))
 
     def __repr__(self):
         return "<Airport %s: %s,%s,%s,%s,%s,%s,%s,%s,%s,% s>" % (
diff --git a/ogn/model/beacon.py b/ogn/model/beacon.py
index df3d38c..cba8e4e 100644
--- a/ogn/model/beacon.py
+++ b/ogn/model/beacon.py
@@ -1,6 +1,5 @@
 from geoalchemy2.shape import to_shape
 from geoalchemy2.types import Geometry
-from sqlalchemy import Column, String, SmallInteger, Float, DateTime
 from sqlalchemy.ext.declarative import AbstractConcreteBase
 from sqlalchemy.ext.hybrid import hybrid_property
 
@@ -11,18 +10,18 @@ from ogn import db
 
 class Beacon(AbstractConcreteBase, db.Model):
     # APRS data
-    location_wkt = Column('location', Geometry('POINT', srid=4326))
-    altitude = Column(Float(precision=2))
+    location_wkt = db.Column('location', Geometry('POINT', srid=4326))
+    altitude = db.Column(db.Float(precision=2))
 
-    name = Column(String, primary_key=True, nullable=True)
-    dstcall = Column(String)
-    relay = Column(String)
-    receiver_name = Column(String(9), primary_key=True, nullable=True)
-    timestamp = Column(DateTime, primary_key=True, nullable=True)
+    name = db.Column(db.String, primary_key=True, nullable=True)
+    dstcall = db.Column(db.String)
+    relay = db.Column(db.String)
+    receiver_name = db.Column(db.String(9), primary_key=True, nullable=True)
+    timestamp = db.Column(db.DateTime, primary_key=True, nullable=True)
     symboltable = None
     symbolcode = None
-    track = Column(SmallInteger)
-    ground_speed = Column(Float(precision=2))
+    track = db.Column(db.SmallInteger)
+    ground_speed = db.Column(db.Float(precision=2))
     comment = None
 
     # Type information
diff --git a/ogn/model/country.py b/ogn/model/country.py
index 5c25e4c..93b00a6 100644
--- a/ogn/model/country.py
+++ b/ogn/model/country.py
@@ -1,5 +1,4 @@
 from geoalchemy2.types import Geometry
-from sqlalchemy import Column, String, Integer, Float, SmallInteger, BigInteger
 
 from ogn import db
 
@@ -7,22 +6,22 @@ from ogn import db
 class Country(db.Model):
     __tablename__ = "countries"
 
-    gid = Column(Integer, primary_key=True)
+    gid = db.Column(db.Integer, primary_key=True)
 
-    fips = Column(String(2))
-    iso2 = Column(String(2))
-    iso3 = Column(String(3))
+    fips = db.Column(db.String(2))
+    iso2 = db.Column(db.String(2))
+    iso3 = db.Column(db.String(3))
 
-    un = Column(SmallInteger)
-    name = Column(String(50))
-    area = Column(Integer)
-    pop2005 = Column(BigInteger)
-    region = Column(SmallInteger)
-    subregion = Column(SmallInteger)
-    lon = Column(Float)
-    lat = Column(Float)
+    un = db.Column(db.SmallInteger)
+    name = db.Column(db.String(50))
+    area = db.Column(db.Integer)
+    pop2005 = db.Column(db.BigInteger)
+    region = db.Column(db.SmallInteger)
+    subregion = db.Column(db.SmallInteger)
+    lon = db.Column(db.Float)
+    lat = db.Column(db.Float)
 
-    geom = Column('geom', Geometry('MULTIPOLYGON', srid=4326))
+    geom = db.Column('geom', Geometry('MULTIPOLYGON', srid=4326))
 
     def __repr__(self):
         return "<Country %s: %s,%s,%s,%s,%s,%s,%s,%s,%s,%s>" % (
diff --git a/ogn/model/device.py b/ogn/model/device.py
index 1984813..21288a2 100644
--- a/ogn/model/device.py
+++ b/ogn/model/device.py
@@ -1,22 +1,20 @@
-from sqlalchemy import Column, Integer, String, Float, Boolean, SmallInteger, DateTime
-
 from ogn import db
 
 
 class Device(db.Model):
     __tablename__ = 'devices'
 
-    id = Column(Integer, primary_key=True)
+    id = db.Column(db.Integer, primary_key=True)
 
-    #address = Column(String(6), index=True)
-    address = Column(String, index=True)
-    firstseen = Column(DateTime, index=True)
-    lastseen = Column(DateTime, index=True)
-    aircraft_type = Column(SmallInteger, index=True)
-    stealth = Column(Boolean)
-    software_version = Column(Float(precision=2))
-    hardware_version = Column(SmallInteger)
-    real_address = Column(String(6))
+    #address = db.Column(db.String(6), index=True)
+    address = db.Column(db.String, index=True)
+    firstseen = db.Column(db.DateTime, index=True)
+    lastseen = db.Column(db.DateTime, index=True)
+    aircraft_type = db.Column(db.SmallInteger, index=True)
+    stealth = db.Column(db.Boolean)
+    software_version = db.Column(db.Float(precision=2))
+    hardware_version = db.Column(db.SmallInteger)
+    real_address = db.Column(db.String(6))
 
     def __repr__(self):
         return "<Device: %s,%s,%s,%s,%s,%s>" % (
diff --git a/ogn/model/device_info.py b/ogn/model/device_info.py
index db8932d..fa06f0d 100644
--- a/ogn/model/device_info.py
+++ b/ogn/model/device_info.py
@@ -1,28 +1,25 @@
-from sqlalchemy import Column, Integer, String, Boolean, SmallInteger, ForeignKey
-from sqlalchemy.orm import relationship, backref
-
 from ogn import db
 
 
 class DeviceInfo(db.Model):
     __tablename__ = 'device_infos'
 
-    id = Column(Integer, primary_key=True)
+    id = db.Column(db.Integer, primary_key=True)
     address_type = None
-    #address = Column(String(6), index=True)
-    address = Column(String, index=True)
-    aircraft = Column(String)
-    registration = Column(String(7))
-    competition = Column(String(3))
-    tracked = Column(Boolean)
-    identified = Column(Boolean)
-    aircraft_type = Column(SmallInteger)
+    #address = db.Column(db.String(6), index=True)
+    address = db.Column(db.String, index=True)
+    aircraft = db.Column(db.String)
+    registration = db.Column(db.String(7))
+    competition = db.Column(db.String(3))
+    tracked = db.Column(db.Boolean)
+    identified = db.Column(db.Boolean)
+    aircraft_type = db.Column(db.SmallInteger)
 
-    address_origin = Column(SmallInteger)
+    address_origin = db.Column(db.SmallInteger)
 
     # Relations
-    device_id = Column(Integer, ForeignKey('devices.id', ondelete='SET NULL'), index=True)
-    device = relationship('Device', foreign_keys=[device_id], backref=backref('infos', order_by='DeviceInfo.address_origin.asc()'))
+    device_id = db.Column(db.Integer, db.ForeignKey('devices.id', ondelete='SET NULL'), index=True)
+    device = db.relationship('Device', foreign_keys=[device_id], backref=db.backref('infos', order_by='DeviceInfo.address_origin.asc()'))
 
     def __repr__(self):
         return "<DeviceInfo: %s,%s,%s,%s,%s,%s,%s,%s,%s>" % (
diff --git a/ogn/model/device_stats.py b/ogn/model/device_stats.py
index 2cc1cf8..6bb3078 100644
--- a/ogn/model/device_stats.py
+++ b/ogn/model/device_stats.py
@@ -1,49 +1,46 @@
-from sqlalchemy import Column, Integer, Date, DateTime, Float, ForeignKey, SmallInteger, Boolean, String, Index
-from sqlalchemy.orm import relationship, backref
-
 from ogn import db
 
 
 class DeviceStats(db.Model):
     __tablename__ = "device_stats"
 
-    id = Column(Integer, primary_key=True)
+    id = db.Column(db.Integer, primary_key=True)
 
-    date = Column(Date)
+    date = db.Column(db.Date)
 
     # Static data
-    firstseen = Column(DateTime)
-    lastseen = Column(DateTime)
-    aircraft_type = Column(SmallInteger)
-    stealth = Column(Boolean)
-    software_version = Column(Float(precision=2))
-    hardware_version = Column(SmallInteger)
-    real_address = Column(String(6))
+    firstseen = db.Column(db.DateTime)
+    lastseen = db.Column(db.DateTime)
+    aircraft_type = db.Column(db.SmallInteger)
+    stealth = db.Column(db.Boolean)
+    software_version = db.Column(db.Float(precision=2))
+    hardware_version = db.Column(db.SmallInteger)
+    real_address = db.Column(db.String(6))
 
     # Statistic data
-    max_altitude = Column(Float(precision=2))
-    receiver_count = Column(SmallInteger)
-    aircraft_beacon_count = Column(Integer)
-    jumps = Column(SmallInteger)
-    ambiguous = Column(Boolean)
-    quality = Column(Float(precision=2))
+    max_altitude = db.Column(db.Float(precision=2))
+    receiver_count = db.Column(db.SmallInteger)
+    aircraft_beacon_count = db.Column(db.Integer)
+    jumps = db.Column(db.SmallInteger)
+    ambiguous = db.Column(db.Boolean)
+    quality = db.Column(db.Float(precision=2))
 
     # Relation statistic data
-    quality_offset = Column(Float(precision=2))
+    quality_offset = db.Column(db.Float(precision=2))
 
     # Ranking data
-    max_altitude_ranking_worldwide = Column(Integer)
-    max_altitude_ranking_country = Column(Integer)
-    receiver_count_ranking_worldwide = Column(Integer)
-    receiver_count_ranking_country = Column(Integer)
-    aircraft_beacon_count_ranking_worldwide = Column(Integer)
-    aircraft_beacon_count_ranking_country = Column(Integer)
-    quality_ranking_worldwide = Column(Integer)
-    quality_ranking_country = Column(Integer)
+    max_altitude_ranking_worldwide = db.Column(db.Integer)
+    max_altitude_ranking_country = db.Column(db.Integer)
+    receiver_count_ranking_worldwide = db.Column(db.Integer)
+    receiver_count_ranking_country = db.Column(db.Integer)
+    aircraft_beacon_count_ranking_worldwide = db.Column(db.Integer)
+    aircraft_beacon_count_ranking_country = db.Column(db.Integer)
+    quality_ranking_worldwide = db.Column(db.Integer)
+    quality_ranking_country = db.Column(db.Integer)
 
     # Relations
-    device_id = Column(Integer, ForeignKey('devices.id', ondelete='SET NULL'), index=True)
-    device = relationship('Device', foreign_keys=[device_id], backref=backref('stats', order_by='DeviceStats.date.asc()'))
+    device_id = db.Column(db.Integer, db.ForeignKey('devices.id', ondelete='SET NULL'), index=True)
+    device = db.relationship('Device', foreign_keys=[device_id], backref=db.backref('stats', order_by='DeviceStats.date.asc()'))
 
     def __repr__(self):
         return "<DeviceStats: %s,%s,%s,%s>" % (
@@ -53,4 +50,4 @@ class DeviceStats(db.Model):
             self.max_altitude)
 
 
-Index('ix_device_stats_date_device_id', DeviceStats.date, DeviceStats.device_id)
+db.Index('ix_device_stats_date_device_id', DeviceStats.date, DeviceStats.device_id)
diff --git a/ogn/model/flights2d.py b/ogn/model/flights2d.py
index 36eec17..d7cf29b 100644
--- a/ogn/model/flights2d.py
+++ b/ogn/model/flights2d.py
@@ -1,6 +1,4 @@
 from geoalchemy2.types import Geometry
-from sqlalchemy import Column, Integer, Date, Index, ForeignKey
-from sqlalchemy.orm import relationship
 
 from ogn import db
 
@@ -8,14 +6,14 @@ from ogn import db
 class Flight2D(db.Model):
     __tablename__ = "flights2d"
 
-    date = Column(Date, primary_key=True)
+    date = db.Column(db.Date, primary_key=True)
 
-    path_wkt = Column('path', Geometry('MULTILINESTRING', srid=4326))
-    path_simple_wkt = Column('path_simple', Geometry('MULTILINESTRING', srid=4326))     # this is the path simplified with ST_Simplify(path, 0.0001)
+    path_wkt = db.Column('path', Geometry('MULTILINESTRING', srid=4326))
+    path_simple_wkt = db.Column('path_simple', Geometry('MULTILINESTRING', srid=4326))     # this is the path simplified with ST_Simplify(path, 0.0001)
 
     # Relations
-    device_id = Column(Integer, ForeignKey('devices.id', ondelete='SET NULL'), primary_key=True)
-    device = relationship('Device', foreign_keys=[device_id], backref='flights2d')
+    device_id = db.Column(db.Integer, db.ForeignKey('devices.id', ondelete='SET NULL'), primary_key=True)
+    device = db.relationship('Device', foreign_keys=[device_id], backref='flights2d')
 
     def __repr__(self):
         return "<Flight %s: %s,%s>" % (
@@ -24,5 +22,5 @@ class Flight2D(db.Model):
             self.path_simple_wkt)
 
 
-Index('ix_flights2d_date_device_id', Flight2D.date, Flight2D.device_id)
-#Index('ix_flights2d_date_path', Flight2D.date, Flight2D.path_wkt) --> CREATE INDEX ix_flights2d_date_path ON flights2d USING GIST("date", path)
+db.Index('ix_flights2d_date_device_id', Flight2D.date, Flight2D.device_id)
+#db.Index('ix_flights2d_date_path', Flight2D.date, Flight2D.path_wkt) --> CREATE INDEX ix_flights2d_date_path ON flights2d USING GIST("date", path)
diff --git a/ogn/model/logbook.py b/ogn/model/logbook.py
index 1a23d5f..ca34f04 100644
--- a/ogn/model/logbook.py
+++ b/ogn/model/logbook.py
@@ -1,6 +1,4 @@
-from sqlalchemy import Integer, SmallInteger, Float, DateTime, Column, ForeignKey, case, null
 from sqlalchemy.ext.hybrid import hybrid_property
-from sqlalchemy.orm import relationship, backref
 
 from ogn import db
 
@@ -8,24 +6,24 @@ from ogn import db
 class Logbook(db.Model):
     __tablename__ = 'logbook'
 
-    id = Column(Integer, primary_key=True)
+    id = db.Column(db.Integer, primary_key=True)
 
-    reftime = Column(DateTime, index=True)
-    takeoff_timestamp = Column(DateTime)
-    takeoff_track = Column(SmallInteger)
-    landing_timestamp = Column(DateTime)
-    landing_track = Column(SmallInteger)
-    max_altitude = Column(Float(precision=2))
+    reftime = db.Column(db.DateTime, index=True)
+    takeoff_timestamp = db.Column(db.DateTime)
+    takeoff_track = db.Column(db.SmallInteger)
+    landing_timestamp = db.Column(db.DateTime)
+    landing_track = db.Column(db.SmallInteger)
+    max_altitude = db.Column(db.Float(precision=2))
 
     # Relations
-    takeoff_airport_id = Column(Integer, ForeignKey('airports.id', ondelete='CASCADE'), index=True)
-    takeoff_airport = relationship('Airport', foreign_keys=[takeoff_airport_id])
+    takeoff_airport_id = db.Column(db.Integer, db.ForeignKey('airports.id', ondelete='CASCADE'), index=True)
+    takeoff_airport = db.relationship('Airport', foreign_keys=[takeoff_airport_id])
 
-    landing_airport_id = Column(Integer, ForeignKey('airports.id', ondelete='CASCADE'), index=True)
-    landing_airport = relationship('Airport', foreign_keys=[landing_airport_id])
+    landing_airport_id = db.Column(db.Integer, db.ForeignKey('airports.id', ondelete='CASCADE'), index=True)
+    landing_airport = db.relationship('Airport', foreign_keys=[landing_airport_id])
 
-    device_id = Column(Integer, ForeignKey('devices.id', ondelete='CASCADE'), index=True)
-    device = relationship('Device', foreign_keys=[device_id], backref=backref('logbook', order_by='Logbook.reftime'))
+    device_id = db.Column(db.Integer, db.ForeignKey('devices.id', ondelete='CASCADE'), index=True)
+    device = db.relationship('Device', foreign_keys=[device_id], backref=db.backref('logbook', order_by='Logbook.reftime'))
 
     @hybrid_property
     def duration(self):
diff --git a/ogn/model/receiver.py b/ogn/model/receiver.py
index 8b0d54f..8a72a78 100644
--- a/ogn/model/receiver.py
+++ b/ogn/model/receiver.py
@@ -1,7 +1,5 @@
 from geoalchemy2.shape import to_shape
 from geoalchemy2.types import Geometry
-from sqlalchemy import Column, Float, String, Integer, DateTime, ForeignKey
-from sqlalchemy.orm import relationship, backref
 
 from .geo import Location
 
@@ -11,20 +9,20 @@ from ogn import db
 class Receiver(db.Model):
     __tablename__ = "receivers"
 
-    id = Column(Integer, primary_key=True)
+    id = db.Column(db.Integer, primary_key=True)
 
-    location_wkt = Column('location', Geometry('POINT', srid=4326))
-    altitude = Column(Float(precision=2))
+    location_wkt = db.Column('location', Geometry('POINT', srid=4326))
+    altitude = db.Column(db.Float(precision=2))
 
-    name = Column(String(9), index=True)
-    firstseen = Column(DateTime, index=True)
-    lastseen = Column(DateTime, index=True)
-    version = Column(String)
-    platform = Column(String)
+    name = db.Column(db.String(9), index=True)
+    firstseen = db.Column(db.DateTime, index=True)
+    lastseen = db.Column(db.DateTime, index=True)
+    version = db.Column(db.String)
+    platform = db.Column(db.String)
 
     # Relations
-    country_id = Column(Integer, ForeignKey('countries.gid', ondelete='SET NULL'), index=True)
-    country = relationship('Country', foreign_keys=[country_id], backref=backref('receivers', order_by='Receiver.name.asc()'))
+    country_id = db.Column(db.Integer, db.ForeignKey('countries.gid', ondelete='SET NULL'), index=True)
+    country = db.relationship('Country', foreign_keys=[country_id], backref=db.backref('receivers', order_by='Receiver.name.asc()'))
 
     @property
     def location(self):
diff --git a/ogn/model/receiver_beacon.py b/ogn/model/receiver_beacon.py
index a342bb8..67e3859 100644
--- a/ogn/model/receiver_beacon.py
+++ b/ogn/model/receiver_beacon.py
@@ -1,8 +1,8 @@
-from sqlalchemy import Column, Float, String, Integer, ForeignKey, Index
-from sqlalchemy.orm import relationship
 from sqlalchemy.sql import func
 from .beacon import Beacon
 
+from ogn import db
+
 
 class ReceiverBeacon(Beacon):
     __tablename__ = "receiver_beacons"
@@ -12,34 +12,34 @@ class ReceiverBeacon(Beacon):
     ground_speed = None
 
     # ReceiverBeacon specific data
-    version = Column(String)
-    platform = Column(String)
-    cpu_load = Column(Float(precision=2))
-    free_ram = Column(Float(precision=2))
-    total_ram = Column(Float(precision=2))
-    ntp_error = Column(Float(precision=2))
-    rt_crystal_correction = Column(Float(precision=2))
-    voltage = Column(Float(precision=2))
-    amperage = Column(Float(precision=2))
-    cpu_temp = Column(Float(precision=2))
-    senders_visible = Column(Integer)
-    senders_total = Column(Integer)
-    rec_input_noise = Column(Float(precision=2))
-    senders_signal = Column(Float(precision=2))
-    senders_messages = Column(Integer)
-    good_senders_signal = Column(Float(precision=2))
-    good_senders = Column(Integer)
-    good_and_bad_senders = Column(Integer)
+    version = db.Column(db.String)
+    platform = db.Column(db.String)
+    cpu_load = db.Column(db.Float(precision=2))
+    free_ram = db.Column(db.Float(precision=2))
+    total_ram = db.Column(db.Float(precision=2))
+    ntp_error = db.Column(db.Float(precision=2))
+    rt_crystal_correction = db.Column(db.Float(precision=2))
+    voltage = db.Column(db.Float(precision=2))
+    amperage = db.Column(db.Float(precision=2))
+    cpu_temp = db.Column(db.Float(precision=2))
+    senders_visible = db.Column(db.Integer)
+    senders_total = db.Column(db.Integer)
+    rec_input_noise = db.Column(db.Float(precision=2))
+    senders_signal = db.Column(db.Float(precision=2))
+    senders_messages = db.Column(db.Integer)
+    good_senders_signal = db.Column(db.Float(precision=2))
+    good_senders = db.Column(db.Integer)
+    good_and_bad_senders = db.Column(db.Integer)
 
     # User comment: used for additional information like hardware configuration, web site, email address, ...
     user_comment = None
 
     # Relations
-    receiver_id = Column(Integer, ForeignKey('receivers.id', ondelete='SET NULL'))
-    receiver = relationship('Receiver', foreign_keys=[receiver_id], backref='receiver_beacons')
+    receiver_id = db.Column(db.Integer, db.ForeignKey('receivers.id', ondelete='SET NULL'))
+    receiver = db.relationship('Receiver', foreign_keys=[receiver_id], backref='receiver_beacons')
 
     # Multi-column indices
-    Index('ix_receiver_beacons_receiver_id_name', 'receiver_id', 'name')
+    db.Index('ix_receiver_beacons_receiver_id_name', 'receiver_id', 'name')
 
     def __repr__(self):
         return "<ReceiverBeacon %s: %s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s>" % (
@@ -125,4 +125,4 @@ class ReceiverBeacon(Beacon):
             int(self.good_and_bad_senders) if self.good_and_bad_senders else None]
 
 
-Index('ix_receiver_beacons_date_receiver_id', func.date(ReceiverBeacon.timestamp), ReceiverBeacon.receiver_id)
+db.Index('ix_receiver_beacons_date_receiver_id', func.date(ReceiverBeacon.timestamp), ReceiverBeacon.receiver_id)
diff --git a/ogn/model/receiver_coverage.py b/ogn/model/receiver_coverage.py
index 88e2611..9c41425 100644
--- a/ogn/model/receiver_coverage.py
+++ b/ogn/model/receiver_coverage.py
@@ -1,26 +1,23 @@
-from sqlalchemy import Column, String, Integer, SmallInteger, Float, Date, ForeignKey, Index
-from sqlalchemy.orm import relationship, backref
-
 from ogn import db
 
 
 class ReceiverCoverage(db.Model):
     __tablename__ = "receiver_coverages"
 
-    location_mgrs_short = Column(String(9), primary_key=True)
-    date = Column(Date, primary_key=True)
+    location_mgrs_short = db.Column(db.String(9), primary_key=True)
+    date = db.Column(db.Date, primary_key=True)
 
-    max_signal_quality = Column(Float)
-    max_altitude = Column(Float(precision=2))
-    min_altitude = Column(Float(precision=2))
-    aircraft_beacon_count = Column(Integer)
+    max_signal_quality = db.Column(db.Float)
+    max_altitude = db.Column(db.Float(precision=2))
+    min_altitude = db.Column(db.Float(precision=2))
+    aircraft_beacon_count = db.Column(db.Integer)
 
-    device_count = Column(SmallInteger)
+    device_count = db.Column(db.SmallInteger)
 
     # Relations
-    receiver_id = Column(Integer, ForeignKey('receivers.id', ondelete='SET NULL'), primary_key=True)
-    receiver = relationship('Receiver', foreign_keys=[receiver_id], backref=backref('receiver_coverages', order_by='ReceiverCoverage.date.asc()'))
+    receiver_id = db.Column(db.Integer, db.ForeignKey('receivers.id', ondelete='SET NULL'), primary_key=True)
+    receiver = db.relationship('Receiver', foreign_keys=[receiver_id], backref=db.backref('receiver_coverages', order_by='ReceiverCoverage.date.asc()'))
 
 
-Index('ix_receiver_coverages_date_receiver_id', ReceiverCoverage.date, ReceiverCoverage.receiver_id)
-Index('ix_receiver_coverages_receiver_id_date', ReceiverCoverage.receiver_id, ReceiverCoverage.date)
+db.Index('ix_receiver_coverages_date_receiver_id', ReceiverCoverage.date, ReceiverCoverage.receiver_id)
+db.Index('ix_receiver_coverages_receiver_id_date', ReceiverCoverage.receiver_id, ReceiverCoverage.date)
diff --git a/ogn/model/receiver_stats.py b/ogn/model/receiver_stats.py
index 1e9f224..9d733fb 100644
--- a/ogn/model/receiver_stats.py
+++ b/ogn/model/receiver_stats.py
@@ -1,5 +1,3 @@
-from sqlalchemy import Column, Integer, SmallInteger, Date, Float, ForeignKey, DateTime, String, Index
-from sqlalchemy.orm import relationship, backref
 from geoalchemy2.types import Geometry
 
 from ogn import db
@@ -8,36 +6,36 @@ from ogn import db
 class ReceiverStats(db.Model):
     __tablename__ = "receiver_stats"
 
-    id = Column(Integer, primary_key=True)
+    id = db.Column(db.Integer, primary_key=True)
 
-    date = Column(Date)
+    date = db.Column(db.Date)
 
     # Static data
-    firstseen = Column(DateTime, index=True)
-    lastseen = Column(DateTime, index=True)
-    location_wkt = Column('location', Geometry('POINT', srid=4326))
-    altitude = Column(Float(precision=2))
-    version = Column(String)
-    platform = Column(String)
+    firstseen = db.Column(db.DateTime, index=True)
+    lastseen = db.Column(db.DateTime, index=True)
+    location_wkt = db.Column('location', Geometry('POINT', srid=4326))
+    altitude = db.Column(db.Float(precision=2))
+    version = db.Column(db.String)
+    platform = db.Column(db.String)
 
     # Statistic data
-    aircraft_beacon_count = Column(Integer)
-    aircraft_count = Column(SmallInteger)
-    max_distance = Column(Float)
-    quality = Column(Float(precision=2))
+    aircraft_beacon_count = db.Column(db.Integer)
+    aircraft_count = db.Column(db.SmallInteger)
+    max_distance = db.Column(db.Float)
+    quality = db.Column(db.Float(precision=2))
 
     # Relation statistic data
-    quality_offset = Column(Float(precision=2))
+    quality_offset = db.Column(db.Float(precision=2))
 
     # Ranking data
-    aircraft_beacon_count_ranking = Column(SmallInteger)
-    aircraft_count_ranking = Column(SmallInteger)
-    max_distance_ranking = Column(SmallInteger)
-    quality_ranking = Column(Integer)
+    aircraft_beacon_count_ranking = db.Column(db.SmallInteger)
+    aircraft_count_ranking = db.Column(db.SmallInteger)
+    max_distance_ranking = db.Column(db.SmallInteger)
+    quality_ranking = db.Column(db.Integer)
 
     # Relations
-    receiver_id = Column(Integer, ForeignKey('receivers.id', ondelete='SET NULL'), index=True)
-    receiver = relationship('Receiver', foreign_keys=[receiver_id], backref=backref('stats', order_by='ReceiverStats.date.asc()'))
+    receiver_id = db.Column(db.Integer, db.ForeignKey('receivers.id', ondelete='SET NULL'), index=True)
+    receiver = db.relationship('Receiver', foreign_keys=[receiver_id], backref=db.backref('stats', order_by='ReceiverStats.date.asc()'))
 
 
-Index('ix_receiver_stats_date_receiver_id', ReceiverStats.date, ReceiverStats.receiver_id)
+db.Index('ix_receiver_stats_date_receiver_id', ReceiverStats.date, ReceiverStats.receiver_id)
diff --git a/ogn/model/relation_stats.py b/ogn/model/relation_stats.py
index cb5c9a9..b041fb4 100644
--- a/ogn/model/relation_stats.py
+++ b/ogn/model/relation_stats.py
@@ -1,25 +1,22 @@
-from sqlalchemy import Column, Integer, Date, Float, ForeignKey, Index
-from sqlalchemy.orm import relationship
-
 from ogn import db
 
 
 class RelationStats(db.Model):
     __tablename__ = "relation_stats"
 
-    id = Column(Integer, primary_key=True)
+    id = db.Column(db.Integer, primary_key=True)
 
-    date = Column(Date)
+    date = db.Column(db.Date)
 
     # Statistic data
-    quality = Column(Float(precision=2))
-    beacon_count = Column(Integer)
+    quality = db.Column(db.Float(precision=2))
+    beacon_count = db.Column(db.Integer)
 
     # Relations
-    device_id = Column(Integer, ForeignKey('devices.id', ondelete='SET NULL'), index=True)
-    device = relationship('Device', foreign_keys=[device_id], backref='relation_stats')
-    receiver_id = Column(Integer, ForeignKey('receivers.id', ondelete='SET NULL'), index=True)
-    receiver = relationship('Receiver', foreign_keys=[receiver_id], backref='relation_stats')
+    device_id = db.Column(db.Integer, db.ForeignKey('devices.id', ondelete='SET NULL'), index=True)
+    device = db.relationship('Device', foreign_keys=[device_id], backref='relation_stats')
+    receiver_id = db.Column(db.Integer, db.ForeignKey('receivers.id', ondelete='SET NULL'), index=True)
+    receiver = db.relationship('Receiver', foreign_keys=[receiver_id], backref='relation_stats')
 
     def __repr__(self):
         return "<RelationStats: %s,%s,%s>" % (
@@ -28,5 +25,5 @@ class RelationStats(db.Model):
             self.beacon_count)
 
 
-Index('ix_relation_stats_date_device_id', RelationStats.date, RelationStats.device_id, RelationStats.receiver_id)
-Index('ix_relation_stats_date_receiver_id', RelationStats.date, RelationStats.receiver_id, RelationStats.device_id)
+db.Index('ix_relation_stats_date_device_id', RelationStats.date, RelationStats.device_id, RelationStats.receiver_id)
+db.Index('ix_relation_stats_date_receiver_id', RelationStats.date, RelationStats.receiver_id, RelationStats.device_id)
diff --git a/ogn/model/takeoff_landing.py b/ogn/model/takeoff_landing.py
index 1c68cd5..18da439 100644
--- a/ogn/model/takeoff_landing.py
+++ b/ogn/model/takeoff_landing.py
@@ -1,19 +1,16 @@
-from sqlalchemy import Boolean, Column, Integer, SmallInteger, DateTime, ForeignKey
-from sqlalchemy.orm import relationship
-
 from ogn import db
 
 
 class TakeoffLanding(db.Model):
     __tablename__ = 'takeoff_landings'
 
-    device_id = Column(Integer, ForeignKey('devices.id', ondelete='SET NULL'), primary_key=True)
-    airport_id = Column(Integer, ForeignKey('airports.id', ondelete='SET NULL'), primary_key=True)
-    timestamp = Column(DateTime, primary_key=True)
+    device_id = db.Column(db.Integer, db.ForeignKey('devices.id', ondelete='SET NULL'), primary_key=True)
+    airport_id = db.Column(db.Integer, db.ForeignKey('airports.id', ondelete='SET NULL'), primary_key=True)
+    timestamp = db.Column(db.DateTime, primary_key=True)
 
-    is_takeoff = Column(Boolean)
-    track = Column(SmallInteger)
+    is_takeoff = db.Column(db.Boolean)
+    track = db.Column(db.SmallInteger)
 
     # Relations
-    airport = relationship('Airport', foreign_keys=[airport_id], backref='takeoff_landings')
-    device = relationship('Device', foreign_keys=[device_id], backref='takeoff_landings', order_by='TakeoffLanding.timestamp')
+    airport = db.relationship('Airport', foreign_keys=[airport_id], backref='takeoff_landings')
+    device = db.relationship('Device', foreign_keys=[device_id], backref='takeoff_landings', order_by='TakeoffLanding.timestamp')