wzy-warehouse
562 lines
17 KiB
Python
562 lines
17 KiB
Python
"""
|
|
数据库查询模块
|
|
负责从 xian_risk_factors、xian_meteorology 等表获取数据
|
|
"""
|
|
import math
|
|
from typing import Optional, List, Dict, Any
|
|
from datetime import datetime
|
|
from app.utils.db_helper import db_helper
|
|
from app.config.paths import get_logger
|
|
|
|
logger = get_logger("dbn")
|
|
|
|
|
|
class DbnRepository:
|
|
"""数据库查询类 - 所有DBN相关查询统一管理"""
|
|
|
|
# ==================== 风险因子查询 ====================
|
|
|
|
@staticmethod
|
|
def get_all_points(region_code: Optional[str] = None) -> List[Dict[str, Any]]:
|
|
"""
|
|
获取所有隐患点和风险点（从 xian_risk_factors 表）
|
|
|
|
Args:
|
|
region_code: 行政区划代码（如 '610104'），可选，匹配隐患点.county_code 和风险点.unit_code
|
|
|
|
Returns:
|
|
点列表，每个元素包含：id, source_id, source_type, lon, lat, static_factors
|
|
"""
|
|
if region_code:
|
|
# 通过源表的行政区划代码筛选
|
|
sql = """
|
|
SELECT rf.id, rf.source_id, rf.source_type, rf.lon, rf.lat, rf.static_factors
|
|
FROM xian_risk_factors rf
|
|
WHERE rf.is_delete = 0
|
|
AND (
|
|
(rf.source_type = 1 AND rf.source_id IN (
|
|
SELECT id FROM xian_hidden_danger_spots WHERE county_id = %s AND is_delete = 0
|
|
))
|
|
OR
|
|
(rf.source_type = 2 AND rf.source_id IN (
|
|
SELECT id FROM xian_risk_spots WHERE unit_code = %s AND is_delete = 0
|
|
))
|
|
)
|
|
"""
|
|
params = (region_code, region_code)
|
|
else:
|
|
sql = """
|
|
SELECT id, source_id, source_type, lon, lat, static_factors
|
|
FROM xian_risk_factors
|
|
WHERE is_delete = 0
|
|
"""
|
|
params = None
|
|
|
|
results = db_helper.execute_query(sql, params)
|
|
|
|
points = []
|
|
for row in results:
|
|
points.append({
|
|
'id': row['id'],
|
|
'source_id': row['source_id'],
|
|
'source_type': row['source_type'],
|
|
'lon': float(row['lon']) if row['lon'] else None,
|
|
'lat': float(row['lat']) if row['lat'] else None,
|
|
'static_factors': row.get('static_factors') or {}
|
|
})
|
|
|
|
return points
|
|
|
|
@staticmethod
|
|
def get_point_by_id(point_id: int) -> Optional[Dict[str, Any]]:
|
|
"""
|
|
根据ID获取单个点信息
|
|
|
|
Args:
|
|
point_id: xian_risk_factors 表的 ID
|
|
|
|
Returns:
|
|
点信息
|
|
"""
|
|
sql = """
|
|
SELECT
|
|
rf.id,
|
|
rf.source_id,
|
|
rf.source_type,
|
|
rf.lon,
|
|
rf.lat,
|
|
rf.static_factors
|
|
FROM xian_risk_factors rf
|
|
WHERE rf.id = %s AND rf.is_delete = 0
|
|
"""
|
|
result = db_helper.execute_query_one(sql, (point_id,))
|
|
|
|
if not result:
|
|
return None
|
|
|
|
return {
|
|
'id': result['id'],
|
|
'source_id': result['source_id'],
|
|
'source_type': result['source_type'],
|
|
'lon': float(result['lon']) if result['lon'] else None,
|
|
'lat': float(result['lat']) if result['lat'] else None,
|
|
'static_factors': result.get('static_factors') or {}
|
|
}
|
|
|
|
@staticmethod
|
|
def get_points_by_ids(point_ids: List[int]) -> List[Dict[str, Any]]:
|
|
"""
|
|
批量获取点信息
|
|
|
|
Args:
|
|
point_ids: 点ID列表
|
|
|
|
Returns:
|
|
点信息列表
|
|
"""
|
|
if not point_ids:
|
|
return []
|
|
|
|
placeholders = ','.join(['%s'] * len(point_ids))
|
|
sql = f"""
|
|
SELECT
|
|
rf.id,
|
|
rf.source_id,
|
|
rf.source_type,
|
|
rf.lon,
|
|
rf.lat,
|
|
rf.static_factors
|
|
FROM xian_risk_factors rf
|
|
WHERE rf.id IN ({placeholders}) AND rf.is_delete = 0
|
|
"""
|
|
results = db_helper.execute_query(sql, tuple(point_ids))
|
|
|
|
return [{
|
|
'id': row['id'],
|
|
'source_id': row['source_id'],
|
|
'source_type': row['source_type'],
|
|
'lon': float(row['lon']) if row['lon'] else None,
|
|
'lat': float(row['lat']) if row['lat'] else None,
|
|
'static_factors': row.get('static_factors') or {}
|
|
} for row in results]
|
|
|
|
@staticmethod
|
|
def get_static_factors(point_id: int) -> Dict[str, Any]:
|
|
"""
|
|
获取点的静态因子数据
|
|
|
|
Args:
|
|
point_id: xian_risk_factors 表的 ID
|
|
|
|
Returns:
|
|
静态因子数据
|
|
"""
|
|
sql = """
|
|
SELECT static_factors
|
|
FROM xian_risk_factors
|
|
WHERE id = %s AND is_delete = 0
|
|
"""
|
|
result = db_helper.execute_query_one(sql, (point_id,))
|
|
|
|
if result and result.get('static_factors'):
|
|
return result['static_factors']
|
|
return {}
|
|
|
|
# ==================== 降雨数据查询 ====================
|
|
|
|
@staticmethod
|
|
def get_nearest_station_rainfall(lon: float, lat: float,
|
|
query_time: Optional[datetime] = None) -> Dict[str, Any]:
|
|
"""
|
|
获取最近雨量站的降雨数据
|
|
|
|
Args:
|
|
lon: 经度
|
|
lat: 纬度
|
|
query_time: 查询时间，若未提供则取当前时间
|
|
|
|
Returns:
|
|
降雨数据
|
|
"""
|
|
if query_time is None:
|
|
query_time = datetime.now()
|
|
|
|
# noinspection SqlNoDataSourceInspection
|
|
sql = """
|
|
WITH station_data AS (
|
|
SELECT
|
|
lon,
|
|
lat,
|
|
SUM(CAST(rainfall_1h AS DOUBLE PRECISION)) as total_rainfall,
|
|
COUNT(*) as record_count
|
|
FROM xian_meteorology
|
|
WHERE datetime BETWEEN
|
|
CAST(EXTRACT(EPOCH FROM (%s::timestamp - INTERVAL '24 hours')) AS BIGINT)
|
|
AND CAST(EXTRACT(EPOCH FROM %s::timestamp) AS BIGINT)
|
|
AND rainfall_1h IS NOT NULL
|
|
AND CAST(rainfall_1h AS DOUBLE PRECISION) > 0
|
|
GROUP BY lon, lat
|
|
)
|
|
SELECT
|
|
lon,
|
|
lat,
|
|
total_rainfall,
|
|
record_count,
|
|
ST_DistanceSphere(
|
|
ST_SetSRID(ST_MakePoint(lon, lat), 4326),
|
|
ST_SetSRID(ST_MakePoint(%s, %s), 4326)
|
|
) as distance
|
|
FROM station_data
|
|
ORDER BY distance
|
|
LIMIT 1
|
|
"""
|
|
result = db_helper.execute_query_one(sql, (query_time, query_time, lon, lat))
|
|
|
|
if result:
|
|
return {
|
|
'rainfall': float(result['total_rainfall']) if result['total_rainfall'] else 0.0,
|
|
'record_count': int(result['record_count']) if result['record_count'] else 0,
|
|
'distance': float(result['distance']) if result['distance'] else 0.0,
|
|
'station_lon': float(result['lon']) if result['lon'] else None,
|
|
'station_lat': float(result['lat']) if result['lat'] else None
|
|
}
|
|
else:
|
|
return {
|
|
'rainfall': 0.0,
|
|
'record_count': 0,
|
|
'distance': 0.0,
|
|
'station_lon': None,
|
|
'station_lat': None
|
|
}
|
|
|
|
@staticmethod
|
|
def get_rainfall_data_with_duration(lon: float, lat: float,
|
|
query_time: Optional[datetime] = None) -> Dict[str, Any]:
|
|
"""
|
|
获取降雨数据，包括累计降雨量和持续时间
|
|
|
|
Args:
|
|
lon: 经度
|
|
lat: 纬度
|
|
query_time: 查询时间，若未提供则取当前时间
|
|
|
|
Returns:
|
|
降雨数据：{accum_rain, duration_hours, rain_intensity}
|
|
"""
|
|
if query_time is None:
|
|
query_time = datetime.now()
|
|
|
|
# 查找最近的雨量站
|
|
# noinspection SqlNoDataSourceInspection
|
|
sql = """
|
|
SELECT lon, lat, dist
|
|
FROM (
|
|
SELECT DISTINCT lon, lat,
|
|
ST_DistanceSphere(
|
|
ST_SetSRID(ST_MakePoint(lon, lat), 4326),
|
|
ST_SetSRID(ST_MakePoint(%s, %s), 4326)
|
|
) as dist
|
|
FROM xian_meteorology
|
|
) t
|
|
WHERE dist < 50000
|
|
ORDER BY dist
|
|
LIMIT 1
|
|
"""
|
|
station = db_helper.execute_query_one(sql, (lon, lat))
|
|
|
|
if not station:
|
|
return {'accum_rain': 0.0, 'duration_hours': 0, 'rain_intensity': 0.0}
|
|
|
|
station_lon = station['lon']
|
|
station_lat = station['lat']
|
|
|
|
# 查询该站点的降雨时序数据
|
|
# noinspection SqlNoDataSourceInspection
|
|
sql = """
|
|
SELECT
|
|
datetime,
|
|
CAST(rainfall_1h AS DOUBLE PRECISION) as rainfall
|
|
FROM xian_meteorology
|
|
WHERE lon = %s AND lat = %s
|
|
AND datetime BETWEEN
|
|
CAST(EXTRACT(EPOCH FROM (%s::timestamp - INTERVAL '72 hours')) AS BIGINT)
|
|
AND CAST(EXTRACT(EPOCH FROM %s::timestamp) AS BIGINT)
|
|
ORDER BY datetime DESC
|
|
"""
|
|
results = db_helper.execute_query(sql, (station_lon, station_lat, query_time, query_time))
|
|
|
|
if not results:
|
|
return {'accum_rain': 0.0, 'duration_hours': 0, 'rain_intensity': 0.0}
|
|
|
|
# 计算累计降雨量和持续时间
|
|
accum_rain = 0.0
|
|
duration_hours = 0
|
|
consecutive_no_rain = 0
|
|
|
|
for row in results:
|
|
rainfall = float(row['rainfall']) if row['rainfall'] else 0.0
|
|
if rainfall > 0:
|
|
accum_rain += rainfall
|
|
duration_hours += 1
|
|
consecutive_no_rain = 0
|
|
else:
|
|
consecutive_no_rain += 1
|
|
if consecutive_no_rain >= 3:
|
|
break
|
|
if accum_rain > 0:
|
|
duration_hours += 1
|
|
|
|
rain_intensity = accum_rain / duration_hours if duration_hours > 0 else 0.0
|
|
|
|
return {
|
|
'accum_rain': accum_rain,
|
|
'duration_hours': duration_hours,
|
|
'rain_intensity': rain_intensity
|
|
}
|
|
|
|
# ==================== 空间查询 ====================
|
|
|
|
@staticmethod
|
|
def get_nearest_station(lon: float, lat: float,
|
|
station_type: str = 'meteorology') -> Optional[Dict[str, Any]]:
|
|
"""
|
|
获取最近的气象站点
|
|
|
|
Args:
|
|
lon: 经度
|
|
lat: 纬度
|
|
station_type: 站点类型
|
|
|
|
Returns:
|
|
最近站点信息
|
|
"""
|
|
sql = """
|
|
SELECT DISTINCT ON (lon, lat)
|
|
lon,
|
|
lat,
|
|
ST_DistanceSphere(
|
|
ST_SetSRID(ST_MakePoint(lon, lat), 4326),
|
|
ST_SetSRID(ST_MakePoint(%s, %s), 4326)
|
|
) as distance
|
|
FROM xian_meteorology
|
|
WHERE is_delete = 0
|
|
ORDER BY lon, lat, distance
|
|
LIMIT 1
|
|
"""
|
|
|
|
result = db_helper.execute_query_one(sql, (lon, lat))
|
|
|
|
if result:
|
|
return {
|
|
'lon': float(result['lon']),
|
|
'lat': float(result['lat']),
|
|
'distance': float(result['distance'])
|
|
}
|
|
return None
|
|
|
|
@staticmethod
|
|
def get_distance_to_river(lon: float, lat: float) -> float:
|
|
"""
|
|
计算点到最近河流的距离
|
|
|
|
Args:
|
|
lon: 经度
|
|
lat: 纬度
|
|
|
|
Returns:
|
|
距离（米）
|
|
"""
|
|
sql = """
|
|
SELECT
|
|
MIN(ST_DistanceSphere(
|
|
ST_SetSRID(ST_MakePoint(%s, %s), 4326),
|
|
geom
|
|
)) as min_distance
|
|
FROM xian_rivers
|
|
WHERE is_delete = 0
|
|
"""
|
|
|
|
result = db_helper.execute_query_one(sql, (lon, lat))
|
|
|
|
if result and result['min_distance']:
|
|
return float(result['min_distance'])
|
|
return 0.0
|
|
|
|
@staticmethod
|
|
def get_distance_to_fault(lon: float, lat: float) -> float:
|
|
"""
|
|
计算点到最近断裂带的距离
|
|
|
|
Args:
|
|
lon: 经度
|
|
lat: 纬度
|
|
|
|
Returns:
|
|
距离（米）
|
|
"""
|
|
sql = """
|
|
SELECT
|
|
MIN(ST_DistanceSphere(
|
|
ST_SetSRID(ST_MakePoint(%s, %s), 4326),
|
|
geom
|
|
)) as min_distance
|
|
FROM xian_fault_lines
|
|
WHERE is_delete = 0
|
|
"""
|
|
|
|
result = db_helper.execute_query_one(sql, (lon, lat))
|
|
|
|
if result and result['min_distance']:
|
|
return float(result['min_distance'])
|
|
return 0.0
|
|
|
|
@staticmethod
|
|
def get_pipe_density(lon: float, lat: float, buffer_radius: float = 500.0) -> float:
|
|
"""
|
|
计算点周围缓冲区内的管网密度
|
|
|
|
Args:
|
|
lon: 经度
|
|
lat: 纬度
|
|
buffer_radius: 缓冲区半径（米）
|
|
|
|
Returns:
|
|
管网密度（m/m²）
|
|
"""
|
|
sql = """
|
|
SELECT
|
|
COALESCE(SUM(ST_Length(wp.geom::geography)), 0) as total_length
|
|
FROM xian_water_pipe wp
|
|
WHERE wp.is_delete = 0
|
|
AND ST_DWithin(
|
|
ST_SetSRID(ST_MakePoint(%s, %s), 4326)::geography,
|
|
wp.geom::geography,
|
|
%s
|
|
)
|
|
"""
|
|
|
|
result = db_helper.execute_query_one(sql, (lon, lat, buffer_radius))
|
|
|
|
if result and result['total_length']:
|
|
total_length = float(result['total_length'])
|
|
buffer_area = math.pi * buffer_radius ** 2
|
|
density = total_length / buffer_area
|
|
return density
|
|
return 0.0
|
|
|
|
@staticmethod
|
|
def get_river_density(lon: float, lat: float, buffer_radius: float = 1000.0) -> float:
|
|
"""
|
|
计算点周围缓冲区内的河流密度
|
|
|
|
Args:
|
|
lon: 经度
|
|
lat: 纬度
|
|
buffer_radius: 缓冲区半径（米）
|
|
|
|
Returns:
|
|
河流密度（m/m²）
|
|
"""
|
|
sql = """
|
|
SELECT
|
|
COALESCE(SUM(ST_Length(r.geom::geography)), 0) as total_length
|
|
FROM xian_rivers r
|
|
WHERE r.is_delete = 0
|
|
AND ST_DWithin(
|
|
ST_SetSRID(ST_MakePoint(%s, %s), 4326)::geography,
|
|
r.geom::geography,
|
|
%s
|
|
)
|
|
"""
|
|
|
|
result = db_helper.execute_query_one(sql, (lon, lat, buffer_radius))
|
|
|
|
if result and result['total_length']:
|
|
total_length = float(result['total_length'])
|
|
buffer_area = math.pi * buffer_radius ** 2
|
|
density = total_length / buffer_area
|
|
return density
|
|
return 0.0
|
|
|
|
@staticmethod
|
|
def get_point_elevation(lon: float, lat: float) -> Optional[float]:
|
|
"""
|
|
获取点的高程值
|
|
|
|
Args:
|
|
lon: 经度
|
|
lat: 纬度
|
|
|
|
Returns:
|
|
高程值（米）
|
|
"""
|
|
sql = """
|
|
SELECT
|
|
ST_Value(rast, ST_SetSRID(ST_MakePoint(%s, %s), 4326)) as elevation
|
|
FROM xian_dem
|
|
WHERE ST_Intersects(rast, ST_SetSRID(ST_MakePoint(%s, %s), 4326))
|
|
LIMIT 1
|
|
"""
|
|
|
|
result = db_helper.execute_query_one(sql, (lon, lat, lon, lat))
|
|
|
|
if result and result['elevation']:
|
|
return float(result['elevation'])
|
|
return None
|
|
|
|
@staticmethod
|
|
def get_point_slope(lon: float, lat: float) -> Optional[float]:
|
|
"""
|
|
获取点的坡度值
|
|
|
|
Args:
|
|
lon: 经度
|
|
lat: 纬度
|
|
|
|
Returns:
|
|
坡度值（度）
|
|
"""
|
|
sql = """
|
|
SELECT
|
|
ST_Value(rast, ST_SetSRID(ST_MakePoint(%s, %s), 4326)) as slope
|
|
FROM xian_slope
|
|
WHERE ST_Intersects(rast, ST_SetSRID(ST_MakePoint(%s, %s), 4326))
|
|
LIMIT 1
|
|
"""
|
|
|
|
result = db_helper.execute_query_one(sql, (lon, lat, lon, lat))
|
|
|
|
if result and result['slope']:
|
|
return float(result['slope'])
|
|
return None
|
|
|
|
@staticmethod
|
|
def get_point_aspect(lon: float, lat: float) -> Optional[float]:
|
|
"""
|
|
获取点的坡向值
|
|
|
|
Args:
|
|
lon: 经度
|
|
lat: 纬度
|
|
|
|
Returns:
|
|
坡向值（度）
|
|
"""
|
|
sql = """
|
|
SELECT
|
|
ST_Value(rast, ST_SetSRID(ST_MakePoint(%s, %s), 4326)) as aspect
|
|
FROM xian_aspect
|
|
WHERE ST_Intersects(rast, ST_SetSRID(ST_MakePoint(%s, %s), 4326))
|
|
LIMIT 1
|
|
"""
|
|
|
|
result = db_helper.execute_query_one(sql, (lon, lat, lon, lat))
|
|
|
|
if result and result['aspect']:
|
|
return float(result['aspect'])
|
|
return None
|
|
|
|
|
|
# 创建全局实例
|
|
dbn_repository = DbnRepository()
|