> For the complete documentation index, see [llms.txt](https://navixy.com/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://navixy.com/docs/analytics/pt-br/example-queries/leasing.md). # Arrendamento Modelos de consulta SQL para análises bancárias e de leasing, cobrindo ciclo de vida do Ativo, conformidade contratual, Agendamento de Manutenção e Monitor de limite de uso {% hint style="warning" %} Ativar **IoT Query** antes de utilizar os dados para criar análises abrangentes. Se você ainda não o tiver, entre em contato conosco para obter detalhes de ativação - {% endhint %} As empresas de leasing (especialmente bancos e provedores de leasing de frota) mantêm a propriedade do veículo ou equipamento enquanto o cliente apenas aluga seu uso, de modo que absorvem o risco relacionado ao Ativo ao longo de todo o contrato.  Para proteger o valor residual, impor limites contratuais (Quilometragem, geografia, Manutenção) e simplificar obrigações de serviço completo, eles contam com Navixy. Dados GPS em tempo real, diagnósticos baseados em sensores e análises comportamentais permitem verificar as condições de uso, automatizar o Agendamento de serviços, detectar problemas mecânicos cedo, calcular multas ou taxas de quilometragem excedente e, quando necessário, imobilizar ou recuperar o Ativo — tudo isso protege seu investimento, reduz o custo operacional e aumenta a transparência para o cliente ao longo de todo o ciclo de vida do leasing. Navixy **IoT Query** ajudará a organizar qualquer tipo de análise em todas as etapas do contrato de leasing. Um contrato de leasing passa por várias fases previsíveis: Integração e configuração do Ativo → Fase operacional → Supervisão de risco e conformidade As seguintes receitas SQL no seu livro monitoram em conjunto cada marco crítico ao longo desse ciclo de vida: | Fase do ciclo de vida | Objetivos e marcos | Casos de uso / receitas abordados | | -------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | Integração & configuração do Ativo | • Cadastre o veículo, ative o Seguro e as credenciais do Motorista. • Importe os Ativos para o portal do cliente com a visibilidade correta. | Alertas de vencimento de cadastro/Seguro – datas de referência registradas. Vencimento da carteira de Motorista – valida os Motoristas antes da liberação. | | Planejamento de Manutenção preventiva | • Estabeleça cronogramas de serviço recorrentes, baseados em Quilometragem e no tempo. • Garanta trocas sazonais de pneus. | Inspeções de rotina por intervalo – Tarefas acionadas pelo calendário. Serviço por limite de Quilometragem – regras de manutenção leve/pesada acionadas por km. Monitoramento de horas do motor – serviço acionado por hora para máquinas. | | Limites de uso vinculados ao contrato | • Aplique franquias de Quilometragem e limites financeiros. • Detecte o uso excessivo cedo para evitar surpresas no fim do contrato. | Limite de Quilometragem e penalidades – controle anual / do total de quilômetros do contrato. | | Comportamento em tempo real de Motoristas e Ativos | • Proteja o valor do Ativo; oriente os Motoristas. • Identifique o uso indevido que invalida a cobertura “full-service”. | Frenagens bruscas. Acelerações bruscas. Curvas/contornos bruscos. | | Supervisão de risco e conformidade | • Mantenha os Ativos dentro de limites geográficos e contratuais. • Preserve o direito de desativar ou recuperar. | Saída de geocerca (fronteira do país) – alerta instantâneo em caso de violação do território. Ignição e detecção de marcha lenta – rastreamento de desperdício de Combustível / uso indevido. | ### Modelo de painel Embora as receitas SQL abaixo ofereçam controle completo sobre as análises de leasing, você pode começar mais rápido com um painel pronto que visualiza métricas críticas ao longo do ciclo de vida do leasing. O modelo elimina a necessidade de criar consultas e visualizações do zero. Importe-o, ajuste os parâmetros e comece a monitorar a conformidade, o risco e a proteção do Ativo imediatamente. O modelo aborda os principais fluxos de trabalho de leasing: rastreamento do vencimento do registro e do Seguro, monitoramento da habilitação do Motorista, detecção de Frenagem brusca e aceleração com classificações de severidade, análise do tempo em marcha lenta e monitoramento da atividade do dispositivo.
Importe a configuração para [Dashboard Studio](https://marketplace.navixy.com/shop/dashboard-studio/), ajuste os limites para seus contratos (limites de Quilometragem, níveis de severidade do comportamento, parâmetros de detecção de marcha lenta) e implante um espaço de trabalho completo de monitoramento. Isso funciona bem quando as equipes precisam de painéis operacionais para a supervisão diária da conformidade e do risco, sem escrever SQL. **Pré-requisitos:** * IoT Query habilitado no seu ambiente * Dashboard Studio instalado e acessível * Pelo menos 72 horas de dados de Monitor * Tabelas padrão do esquema preenchidas: `tracking_data_core`, `estados`, `objetos`, `Veículos`, `funcionários` **Configuração após a importação:** Após importar o modelo, adapte-o aos seus contratos de leasing específicos e aos limites operacionais: 1. Revise o intervalo padrão de 72 horas e ajuste se a disponibilidade dos seus dados for diferente. 2. Defina os limites de severidade para os eventos de Condução nos parâmetros da consulta (padrão: 60+ km/h/s para avisos, 80+ km/h/s para Alertas críticos). 3. Configure os parâmetros de detecção de marcha lenta (padrão: velocidade abaixo de 5 km/h, duração mínima de 5 minutos). 4. Atualize os rótulos das zonas de Geocerca na consulta de travessia de fronteira se estiver monitorando restrições territoriais. 5. Use o seletor global de período para analisar períodos históricos ou focar na atividade recente. **JSON do modelo:** {% file src="/files/9d9f79b8dc0ef5e7c6b61f770cd7aa121ea4561b" %} {% code lineNumbers="true" expandable="true" %} ```json { "id": null, "uid": "hello-world", "Etiquetas": [ "exemplo", "getting-started" ], "time": { "to": "now", "from": "now-72h" }, "links": [], "style": "dark", "title": "Painel de leasing", "panels": [ { "id": 10, "type": "text", "title": "Ignição e detecção de marcha lenta", "gridPos": { "h": 4, "w": 24, "x": 0, "y": 158 }, "options": { "mode": "markdown", "content": " " }, "x-navixy": { "sql": { "statement": "" }, "dataset": { "shape": "table", "columns": {} } } }, { "id": 11, "type": "piechart", "title": "Motoristas com as datas de vencimento mais próximas", "gridPos": { "h": 12, "w": 12, "x": 12, "y": 0 }, "options": { "pieType": "donut" }, "x-navixy": { "sql": { "params": {}, "statement": "SELECT \r\n CASE \r\n WHEN (DATE(e.driver_license_valid_till) - CURRENT_DATE)::INTEGER < 0 THEN 'Expired'\r\n ELSE 'Others'\r\n END AS category,\r\n COUNT(*) AS value\r\nFROM raw_business_data.employees e\r\nWHERE e.driver_license_valid_till IS NOT NULL\r\nGROUP BY category\r\nORDER BY category" }, "verify": { "max_rows": 1000 }, "dataset": { "shape": "pie", "columns": { "value": { "type": "integer" }, "category": { "type": "string" } } } } }, { "id": 12, "type": "piechart", "title": "Veículos com as datas de vencimento mais próximas", "gridPos": { "h": 12, "w": 12, "x": 0, "y": 0 }, "options": { "pieType": "donut" }, "x-navixy": { "sql": { "params": {}, "statement": "WITH expiry_data AS (\r\n SELECT \r\n CASE \r\n WHEN v.free_insurance_valid_till_date IS NOT NULL\r\n AND (v.liability_insurance_valid_till IS NULL \r\n OR v.free_insurance_valid_till_date <= v.liability_insurance_valid_till)\r\n THEN v.free_insurance_valid_till_date\r\n WHEN v.liability_insurance_valid_till IS NOT NULL\r\n THEN v.liability_insurance_valid_till\r\n ELSE NULL\r\n END AS nearest_expiry_date\r\n FROM raw_business_data.vehicles v\r\n),\r\ncategorized_data AS (\r\n SELECT \r\n CASE \r\n WHEN (DATE(nearest_expiry_date) - CURRENT_DATE)::INTEGER < 0 THEN 'Expired'\r\n WHEN (DATE(nearest_expiry_date) - CURRENT_DATE)::INTEGER >= 0 \r\n AND (DATE(nearest_expiry_date) - CURRENT_DATE)::INTEGER < 30 THEN 'Expires within 30 days'\r\n ELSE 'Others'\r\n END AS category\r\n FROM expiry_data\r\n WHERE nearest_expiry_date IS NOT NULL\r\n)\r\nSELECT \r\n category,\r\n COUNT(*) AS value\r\nFROM categorized_data\r\nGROUP BY category\r\nORDER BY \r\n CASE category\r\n WHEN 'Expired' THEN 1\r\n WHEN 'Expires within 30 days' THEN 2\r\n WHEN 'Others' THEN 3\r\n END" }, "verify": { "max_rows": 1000 }, "dataset": { "shape": "pie", "columns": { "value": { "type": "integer" }, "category": { "type": "string" } } } } }, { "id": 13, "type": "barchart", "title": "Eventos de Frenagem brusca", "gridPos": { "h": 11, "w": 24, "x": 0, "y": 12 }, "options": { "textMode": "auto" }, "x-navixy": { "sql": { "params": {}, "statement": "WITH spd AS (\r\n SELECT\r\n device_id,\r\n device_time,\r\n speed/100.0 AS kmh,\r\n LAG(speed/100.0) OVER (PARTITION BY device_id ORDER BY device_time) AS prev_kmh,\r\n EXTRACT(EPOCH FROM (device_time - LAG(device_time) OVER (PARTITION BY device_id ORDER BY device_time))) AS dt_sec\r\n FROM\r\n raw_telematics_data.tracking_data_core\r\n WHERE 1=1\r\n ),\r\n decels AS (\r\n SELECT\r\n device_id,\r\n device_time,\r\n (prev_kmh - kmh) / NULLIF(dt_sec, 0) AS decel_kmh_per_sec\r\n FROM\r\n spd\r\n WHERE\r\n prev_kmh IS NOT NULL\r\n ),\r\n events_with_severity AS (\r\n SELECT \r\n DATE(d.device_time) AS category,\r\n CASE \r\n WHEN d.decel_kmh_per_sec >= 80 THEN 'Critical'\r\n WHEN d.decel_kmh_per_sec >= 60 THEN 'Warning'\r\n ELSE 'Normal'\r\n END AS series\r\n FROM decels d\r\n WHERE d.decel_kmh_per_sec >= 60\r\n )\r\n SELECT \r\n category,\r\n COUNT(*) AS value,\r\n series\r\n FROM events_with_severity\r\n GROUP BY category, series\r\n ORDER BY series" }, "verify": { "max_rows": 1000 }, "dataset": { "shape": "category_value", "columns": { "value": { "type": "integer" }, "series": { "type": "string" }, "category": { "type": "date" } } }, "visualização": { "sortOrder": "none", "colorPalette": "vibrante" } } }, { "id": 14, "type": "barchart", "title": "Eventos de Aceleração brusca", "gridPos": { "h": 17, "w": 24, "x": 0, "y": 41 }, "options": { "orientation": "vertical" }, "x-navixy": { "sql": { "params": {}, "statement": "WITH spd AS (\r\n SELECT\r\n device_id,\r\n device_time,\r\n speed/100.0 AS kmh,\r\n LAG(speed/100.0) OVER (PARTITION BY device_id ORDER BY device_time) AS prev_kmh,\r\n EXTRACT(EPOCH FROM (device_time - LAG(device_time) OVER (PARTITION BY device_id ORDER BY device_time))) AS dt_sec\r\n FROM\r\n raw_telematics_data.tracking_data_core\r\n ),\r\n accels AS (\r\n SELECT\r\n device_id,\r\n device_time,\r\n (kmh - prev_kmh) / NULLIF(dt_sec, 0) AS accel_kmh_per_sec\r\n FROM\r\n spd\r\n WHERE\r\n prev_kmh IS NOT NULL\r\n ),\r\n events_with_severity AS (\r\n SELECT \r\n DATE(a.device_time) AS category,\r\n CASE \r\n WHEN a.accel_kmh_per_sec >= 80 THEN 'Critical'\r\n WHEN a.accel_kmh_per_sec >= 60 THEN 'Warning'\r\n ELSE 'Normal'\r\n END AS series\r\n FROM accels a\r\n WHERE a.accel_kmh_per_sec >= 60\r\n )\r\n SELECT \r\n category,\r\n COUNT(*) AS value,\r\n series\r\n FROM events_with_severity\r\n GROUP BY category, series\r\n ORDER BY series" }, "verify": { "max_rows": 1000 }, "dataset": { "shape": "category_value", "columns": { "value": { "type": "integer" }, "series": { "type": "string" }, "category": { "type": "date" } } }, "visualização": { "colorPalette": "vibrante" } } }, { "id": 15, "type": "barchart", "title": "Viradas bruscas / curvas", "gridPos": { "h": 13, "w": 24, "x": 0, "y": 23 }, "options": { "orientation": "vertical" }, "x-navixy": { "sql": { "params": {}, "statement": "WITH pts AS (\r\n SELECT\r\n device_id,\r\n device_time,\r\n latitude/1e7::numeric AS lat,\r\n longitude/1e7::numeric AS lon,\r\n LAG(latitude/1e7::numeric) OVER (PARTITION BY device_id ORDER BY device_time) AS prev_lat,\r\n LAG(longitude/1e7::numeric) OVER (PARTITION BY device_id ORDER BY device_time) AS prev_lon,\r\n speed/100.0 AS kmh,\r\n LAG(speed/100.0) OVER (PARTITION BY device_id ORDER BY device_time) AS prev_kmh\r\n FROM\r\n raw_telematics_data.tracking_data_core\r\n ),\r\n bearing AS (\r\n SELECT *,\r\n atan2(\r\n sin(radians(lon-prev_lon))*cos(radians(lat)),\r\n cos(radians(prev_lat))*sin(radians(lat)) -\r\n sin(radians(prev_lat))*cos(radians(lat))*cos(radians(lon-prev_lon))\r\n ) * 180/pi() AS heading_change\r\n FROM pts\r\n WHERE prev_lat IS NOT NULL AND prev_lon IS NOT NULL\r\n ),\r\n events_with_severity AS (\r\n SELECT \r\n DATE(b.device_time) AS category,\r\n CASE \r\n WHEN ABS(b.heading_change) >= 50 AND b.kmh >= 30 THEN 'Critical'\r\n WHEN ABS(b.heading_change) >= 30 AND b.kmh >= 30 THEN 'Warning'\r\n ELSE 'Normal'\r\n END AS series\r\n FROM bearing b\r\n )\r\n SELECT \r\n category,\r\n COUNT(*) AS value,\r\n series\r\n FROM events_with_severity\r\n GROUP BY category, series\r\n ORDER BY category, series" }, "verify": { "max_rows": 1000 }, "dataset": { "shape": "category_value", "columns": { "value": { "type": "integer" }, "series": { "type": "string" }, "category": { "type": "date" } } }, "visualização": { "stacking": "percent", "colorPalette": "classic" } } }, { "id": 16, "type": "stat", "title": "Total Idle Events", "gridPos": { "h": 5, "w": 8, "x": 0, "y": 36 }, "options": { "textMode": "auto" }, "x-navixy": { "sql": { "params": {}, "statement": "WITH ign AS (\r\n SELECT device_id,\r\n device_time,\r\n value::int AS ign_on\r\n FROM raw_telematics_data.states\r\n WHERE state_name = 'ignition'\r\n ),\r\n spd AS (\r\n SELECT device_id, device_time, speed/100.0 AS kmh\r\n FROM raw_telematics_data.tracking_data_core\r\n ),\r\n merged AS (\r\n SELECT i.device_id,\r\n i.device_time,\r\n i.ign_on,\r\n s.kmh,\r\n LEAD(i.device_time) OVER (PARTITION BY i.device_id ORDER BY i.device_time) AS next_time\r\n FROM ign i\r\n LEFT JOIN spd s ON s.device_id = i.device_id AND s.device_time = i.device_time\r\n )\r\n SELECT COUNT(*) AS value\r\n FROM merged m\r\n WHERE m.ign_on = 1 \r\n AND (m.kmh IS NULL OR m.kmh < 5) \r\n AND m.next_time IS NOT NULL\r\n AND EXTRACT(EPOCH FROM (m.next_time - m.device_time))/60 >= 5" }, "verify": { "max_rows": 1000 }, "dataset": { "shape": "kpi", "columns": {} } } }, { "id": 9, "type": "timeseries", "title": "Mensagens ao longo do tempo", "gridPos": { "h": 13, "w": 24, "x": 0, "y": 83 }, "options": { "legend": { "calcs": [], "placement": "bottom", "showLegend": true, "displayMode": "list" }, "tooltip": { "mode": "single", "sort": "none" } }, "targets": [], "x-navixy": { "sql": { "params": {}, "statement": "WITH bounds AS (\nSELECT date_trunc('hour', NOW() - INTERVAL '24 hours') AS start_ts, date_trunc('hour', NOW()) AS end_ts ), hours AS (\nSELECT generate_series( (\nSELECT start_ts\nFROM bounds), (\nSELECT end_ts\nFROM bounds), INTERVAL '1 hour' ) AS bucket ), counts AS (\nSELECT date_trunc('hour', t.device_time) AS bucket, COUNT(*) AS messages, COUNT(DISTINCT t.device_id) AS unique_devices\nFROM raw_telematics_data.tracking_data_core t --\n JOIN raw_business_data.objects o\n ON o.device_id = t.device_id --\n AND o.client_id = 398286 -- uncomment & set if you want a specific client\nWHERE t.device_time >= (\nSELECT start_ts\nFROM bounds)\n AND t.device_time < (\nSELECT end_ts\nFROM bounds) + INTERVAL '1 hour'\nGROUP BY 1 )\nSELECT h.bucket AS time, COALESCE(c.messages, 0) AS messages, COALESCE(c.unique_devices, 0) AS unique_devices\nFROM hours h LEFT\n JOIN counts c USING (bucket)\nORDER BY time;" }, "verify": { "max_rows": 1000 }, "dataset": { "shape": "time_value", "columns": {} }, "visualização": { "lineStyle": "solid", "colorPalette": "modern", "interpolation": "smooth", "legendPosition": "top" } }, "datasource": null, "fieldConfig": { "defaults": { "unit": "short", "color": { "mode": "palette-classic" }, "custom": { "stacking": { "mode": "none", "grupo": "A" }, "drawStyle": "line", "lineWidth": 1, "spanNulls": false, "showPoints": "auto", "fillOpacity": 10, "gradientMode": "none", "axisPlacement": "auto", "lineInterpolation": "linear" }, "mappings": [], "thresholds": { "mode": "absolute", "steps": [ { "color": "green", "value": null } ] } }, "overrides": [] } }, { "id": 1, "type": "kpi", "title": "Contagem de amostras", "gridPos": { "h": 5, "w": 6, "x": 18, "y": 128 }, "options": { "textMode": "auto", "colorMode": "value", "graphMode": "none", "justifyMode": "auto", "orientation": "auto" }, "targets": [], "x-navixy": { "sql": { "params": { "tenant_id": { "type": "uuid" } }, "statement": "SELECT *\nFROM raw_telematics_data.tracking_data_core LIMIT 10;" }, "verify": { "max_rows": 1 }, "dataset": { "shape": "kpi", "columns": { "value": { "type": "number" } } } }, "datasource": null, "description": "", "fieldConfig": { "defaults": { "unit": "short", "color": { "mode": "thresholds" }, "thresholds": { "mode": "absolute", "steps": [ { "color": "green", "value": null } ] } }, "overrides": [] } }, { "id": 2, "type": "barchart", "title": "Dados de exemplo por categoria", "gridPos": { "h": 15, "w": 18, "x": 0, "y": 130 }, "options": { "valueMode": "cor", "displayMode": "gradient", "orientation": "horizontal", "showUnfilled": true }, "targets": [], "x-navixy": { "sql": { "params": {}, "statement": "SELECT o.object_label, COUNT(*) AS msgs_24h\nFROM raw_telematics_data.tracking_data_core AS t\n JOIN raw_business_data.objects AS o\n ON o.device_id = t.device_id\nWHERE t.device_time >= NOW() - INTERVAL '24 hours'\nGROUP BY o.client_id, o.object_label, t.device_id\nORDER BY msgs_24h DESC LIMIT 20;" }, "verify": { "max_rows": 10 }, "dataset": { "shape": "category_value", "columns": {} }, "visualização": { "orientation": "vertical" } }, "datasource": null, "fieldConfig": { "defaults": { "unit": "short", "color": { "mode": "palette-classic" }, "custom": { "hideFrom": { "viz": false, "legend": false, "tooltip": false } }, "mappings": [], "thresholds": { "mode": "absolute", "steps": [ { "color": "green", "value": null } ] } }, "overrides": [] } }, { "id": 3, "type": "table", "title": "Mensagens por dia", "gridPos": { "h": 9, "w": 12, "x": 4, "y": 148 }, "options": { "sortBy": [], "showHeader": true }, "targets": [], "x-navixy": { "sql": { "params": { "__to": null, "__from": null }, "statement": "SELECT TO_CHAR(date_trunc('day', t.device_time), 'Mon DD, YYYY') AS \"Date\", \n COUNT(*) AS \"Mensagens\"\nFROM raw_telematics_data.tracking_data_core AS t\nWHERE t.device_time >= ${__from}\n AND t.device_time < ${__to}\nGROUP BY 1\nORDER BY 1;" }, "verify": { "max_rows": 10 }, "dataset": { "shape": "table", "columns": {} }, "visualização": { "pageSize": 5 } }, "datasource": null, "fieldConfig": { "defaults": { "custom": { "align": "auto", "displayMode": "auto" }, "mappings": [], "thresholds": { "mode": "absolute", "steps": [ { "color": "green", "value": null } ] } }, "overrides": [] } }, { "id": 6, "type": "kpi", "title": "Tempo total em marcha lenta", "gridPos": { "h": 5, "w": 8, "x": 8, "y": 36 }, "options": { "textMode": "auto" }, "x-navixy": { "sql": { "params": {}, "statement": "WITH ign AS (\n SELECT device_id,\n device_time,\n value::int AS ign_on\n FROM raw_telematics_data.states\n WHERE state_name = 'ignition'\n ),\n spd AS (\n SELECT device_id, device_time, speed/100 AS kmh\n FROM raw_telematics_data.tracking_data_core\n ),\n merged AS (\n SELECT i.device_id,\n i.device_time,\n i.ign_on,\n s.kmh,\n LEAD(i.device_time) OVER (PARTITION BY i.device_id ORDER BY i.device_time) AS next_time\n FROM ign i\n LEFT JOIN spd s ON s.device_id = i.device_id AND s.device_time = i.device_time\n )\n SELECT round(COALESCE(SUM(EXTRACT(EPOCH FROM (m.next_time - m.device_time))/60), 0), 0) AS value\n FROM merged m\n WHERE m.ign_on = 1 \n AND (m.kmh IS NULL OR m.kmh < 5) \n AND m.next_time IS NOT NULL\n AND EXTRACT(EPOCH FROM (m.next_time - m.device_time))/60 >= 5" }, "verify": { "max_rows": 1000 }, "dataset": { "shape": "kpi", "columns": { "value": { "type": "number" } } } } }, { "id": 7, "type": "piechart", "title": "Principais dispositivos ativos nas últimas 24h", "gridPos": { "h": 9, "w": 12, "x": 0, "y": 121 }, "options": { "pieType": "donut" }, "x-navixy": { "sql": { "params": {}, "statement": "SELECT o.object_label, COUNT(*) AS msgs_24h\nFROM raw_telematics_data.tracking_data_core AS t\n JOIN raw_business_data.objects AS o\n ON o.device_id = t.device_id\nWHERE t.device_time >= NOW() - INTERVAL '24 hours'\nGROUP BY o.client_id, o.object_label, t.device_id\nORDER BY msgs_24h DESC LIMIT 20;" }, "verify": { "max_rows": 1000 }, "dataset": { "shape": "pie", "columns": {} } } }, { "id": 8, "type": "table", "title": "Movimentos recentes do veículo", "gridPos": { "h": 25, "w": 24, "x": 0, "y": 96 }, "options": { "showHeader": true }, "x-navixy": { "sql": { "params": {}, "statement": "SELECT\n to_char(t.device_time, 'YYYY-MM-DD HH24:MI:SS TZ') AS \"Timestamp\",\n t.device_id AS \"Device ID\",\n t.speed AS \"Speed\",\n round(t.latitude::numeric / 10000000, 6) AS \"Latitude (°)\",\n round(t.longitude::numeric / 10000000, 6) AS \"Longitude (°)\"\nFROM raw_telematics_data.tracking_data_core t\nWHERE t.device_time >= NOW() - INTERVAL '3 days'\n AND t.speed > 0\nORDER BY t.device_time DESC;" }, "verify": { "max_rows": 3 }, "dataset": { "shape": "table", "columns": { "Velocidade": { "type": "integer" }, "ID do dispositivo": { "type": "integer" }, "Carimbo de data/hora": { "type": "string" }, "Latitude (°)": { "type": "number" }, "Longitude (°)": { "type": "number" } } }, "visualização": { "pageSize": 25, "sortable": true, "showHeader": true, "showTotals": false, "rowHighlighting": "hover" } } }, { "id": 19, "type": "stat", "title": "Duração média de marcha lenta", "gridPos": { "h": 5, "w": 8, "x": 16, "y": 36 }, "options": { "textMode": "auto" }, "x-navixy": { "sql": { "params": {}, "statement": "WITH ign AS (\r\n SELECT device_id,\r\n device_time,\r\n value::int AS ign_on\r\n FROM raw_telematics_data.states\r\n WHERE state_name = 'ignition'\r\n ),\r\n spd AS (\r\n SELECT device_id, device_time, speed/100.0 AS kmh\r\n FROM raw_telematics_data.tracking_data_core\r\n ),\r\n merged AS (\r\n SELECT i.device_id,\r\n i.device_time,\r\n i.ign_on,\r\n s.kmh,\r\n LEAD(i.device_time) OVER (PARTITION BY i.device_id ORDER BY i.device_time) AS next_time\r\n FROM ign i\r\n LEFT JOIN spd s ON s.device_id = i.device_id AND s.device_time = i.device_time\r\n )\r\n SELECT round(COALESCE(AVG(EXTRACT(EPOCH FROM (m.next_time - m.device_time))/60), 0),0) AS value\r\n FROM merged m\r\n WHERE m.ign_on = 1 \r\n AND (m.kmh IS NULL OR m.kmh < 5) \r\n AND m.next_time IS NOT NULL\r\n AND EXTRACT(EPOCH FROM (m.next_time - m.device_time))/60 >= 5" }, "verify": { "max_rows": 1000 }, "dataset": { "shape": "kpi", "columns": {} } } } ], "refresh": "30s", "version": 1, "editable": true, "timezone": "browser", "x-navixy": { "execução": { "dialect": "postgresql", "endpoint": "/api/v1/sql/run", "max_rows": 1000, "read_only": true, "timeout_ms": 5000, "allowed_schemas": [ "demo_data" ] }, "parameters": { "bindings": { "to": "${__to}", "from": "${__from}", "tenant_id": "${var_tenant}" } }, "schemaVersion": "1.0.0" }, "templating": { "list": [ { "name": "var_tenant", "type": "constant", "label": "Locatário", "query": "demo-tenant-id", "current": { "text": "Locatário de demonstração", "value": "demo-tenant-id" }, "options": [ { "text": "Locatário de demonstração", "value": "demo-tenant-id", "selected": true } ] } ], "enable": true }, "timepicker": { "now": true, "enable": true, "hidden": false, "collapse": false, "time_options": [ "5m", "15m", "1h", "6h", "12h", "24h" ], "refresh_intervals": [ "5s", "10s", "30s", "1m", "5m", "15m", "30m", "1h" ] }, "annotations": { "list": [ { "hide": true, "name": "Anotações & Alertas", "type": "dashboard", "enable": true, "target": { "Etiquetas": [], "type": "dashboard", "limit": 100, "matchAny": false }, "builtIn": 1, "iconColor": "rgba(0, 211, 255, 1)", "datasource": { "uid": "-- Dashboard --", "type": "dashboard" } } ] }, "description": "Exemplo simples de painel para começar", "graphTooltip": 1, "schemaVersion": 38 } ``` {% endcode %} Para saber mais sobre o aplicativo de dashboard do IoT Querie, consulte [Dashboard Studio](/docs/analytics/pt-br/dashboard-studio.md). Para obter ajuda com a configuração, entre em contato . ## **Alertas de vencimento de registro / Seguro** Os bancos devem acompanhar os próximos vencimentos de registro e Seguro, porque são responsáveis pelas inspeções técnicas, pelo registro e pelo Seguro. Alertas em tempo hábil evitam multas e a paralisação dos veículos. {% code expandable="true" %} ```sql SELECT v.vehicle_id, v.vehicle_label, v.registration_number, v.free_Seguro_valid_till_date, v.responsabilidade_seguro_válido_até FROM raw_business_data.Veículos v WHERE v.free_insurance_valid_till_date BETWEEN CURRENT_DATE AND CURRENT_DATE + INTERVAL '30 days' OU v.liability_Seguro_valid_till ENTRE CURRENT_DATE E CURRENT_DATE + INTERVAL '30 days'; ``` {% endcode %} ## **Expiração da licença de Motorista** Embora nem sempre seja obrigatório, oferecer alertas proativos de expiração de licença é um serviço de valor agregado. Avisos antecipados permitem que os clientes renovem as licenças antes que elas expirem. Observe que você {% code expandable="true" %} ```sql SELECT e.employee_id, e.first_name || ' ' || e.last_name AS motorista_name, e.driver_license_number, e.driver_license_valid_till FROM raw_business_data.employees e WHERE e.driver_license_valid_till BETWEEN CURRENT_DATE AND CURRENT_DATE + (30 * INTERVAL '1 day'); ``` {% endcode %} ## Saída de geocerca (fronteira do país) Os contratos podem restringir o Movimento do veículo a um território específico (e.g., Serbia). Sair dessa zona deve alertar instantaneamente o banco para que ele possa agir (e.g., contatar o cliente, imobilizar o Ativo). Esta consulta SQL foi projetada para monitorar e identificar quando um dispositivo sai de uma zona geográfica predefinida rotulada "Tallaght Garagem Geofences." O processo começa coletando e ordenando pontos geográficos que definem o limite da zona. Para garantir que o limite forme um polígono válido, o primeiro ponto é anexado ao final da lista, fechando efetivamente a forma. Esse conjunto fechado de pontos é então usado para criar um polígono que representa a zona geográfica, o qual é convertido em um Objeto de geografia para análise espacial. A consulta então recupera dados de Monitor do dispositivo dentro de um intervalo de tempo especificado, convertendo valores brutos de latitude e longitude em pontos geográficos. Ela calcula se cada ponto do dispositivo está dentro ou fora da zona predefinida usando a função ST\_Contains, que verifica o contorno espacial. O parâmetro calculado pos indica 'dentro' se o ponto estiver dentro da zona e 'fora' caso contrário. Por fim, a consulta filtra esses resultados para detectar transições em que um dispositivo se move de dentro da zona para fora, usando uma função de janela para comparar a posição atual com a anterior. Essa lógica ajuda no monitoramento dos movimentos do dispositivo e na detecção de eventos de saída de áreas geográficas específicas. Certifique-se de adicionar o valor correto para o parâmetro: `z.zone_label = 'your_zone_label'.` {% code expandable="true" %} ```sql WITH zone AS ( SELECT z.zone_id, ST_MakePolygon(ST_MakeLine(ARRAY_AGG(ST_MakePoint(g.longitude, g.latitude) ORDER BY g.number)))::geography AS geog FROM raw_business_data.zones z JOIN raw_business_data.geofence_points g ON g.zone_id = z.zone_id WHERE z.zone_label = 'your_zone_label' GROUP BY z.zone_id ), pts AS ( SELECT device_id, device_time, ST_SetSRID(ST_MakePoint(longitude/1e7::numeric, latitude/1e7::numeric), 4326)::geography AS geog DE raw_telematics_data.tracking_data_core WHERE device_time BETWEEN '2025-07-27 00:00:00' AND '2025-07-28 23:59:59' ), states AS ( SELECT p.*, CASE WHEN ST_Contains(z.geog::geometry, p.geog::geometry) THEN 'inside' ELSE 'outside' END AS pos FROM pts p CROSS JOIN zone z ), filtered_states AS ( SELECT device_id, device_time, pos, LAG(pos) OVER (PARTITION BY device_id ORDER BY device_time) AS prev_pos FROM states ) SELECT device_id, device_time, pos FROM filtered_states WHERE prev_pos = 'inside' AND pos = 'outside'; ``` {% endcode %} ## **Inspeções de rotina por intervalo de tempo** Algumas tarefas de manutenção se repetem em intervalos de tempo fixos. O sistema deve sinalizar veículos cuja próxima inspeção/verificação esteja programada para ocorrer dentro de um intervalo definido. {% code expandable="true" %} ```sql WITH t AS ( SELECT vehicle_id, description, start_date, date_repeat_interval, make_interval(days => date_repeat_interval) AS repeat_interval DE raw_business_data.vehicle_service_tasks WHERE date_repeat_interval IS NOT NULL ) SELECT vehicle_id, description, start_date, date_repeat_interval, start_date + repeat_interval * floor( extract(epoch from (current_date::timestamp - start_date)) / extract(epoch from repeat_interval) ) AS last_due, start_date + repeat_interval * ( floor( extract(epoch from (current_date::timestamp - start_date)) / extract(epoch from repeat_interval) ) + 1 ) AS next_due FROM t WHERE ( start_date + repeat_interval * ( floor( extract(epoch from (current_date::timestamp - start_date)) / extract(epoch from repeat_interval) ) + 1 ) ) BETWEEN current_date AND (current_date + interval '30 days'); ``` {% endcode %} ## **Serviço por limite de Quilometragem (Menor/Maior)** As manutenções menores e maiores são acionadas pela Quilometragem desde o último evento de serviço. Quando os quilômetros acumulados excederem o limite, a manutenção apropriada deve ser agendada. Observe o `O campo vst.description deve ter comentários / descrição relevantes para ser usado nos filtros no código SQL abaixo.` {% code expandable="true" %} ```sql SELECT v.vehicle_id, v.vehicle_label, km.km_since_service, vst.Quilometragem_limit FROM raw_business_data.veículos v JOIN LATERAL ( SELECT MAX(vst.completion_date) AS last_service_date FROM raw_business_data.vehicle_service_tasks vst WHERE vst.vehicle_id = v.vehicle_id AND (vst.description ILIKE '%minor%' OR vst.description ILIKE '%major%') AND vst.completion_date IS NOT NULL ) ls ON TRUE JOIN raw_business_data.objects o ON o.object_id = v.vehicle_id JOIN LATERAL ( SELECT SUM(t.trip_distance_meters) / 1000.0 AS km_since_service FROM processed_common_data.trips t WHERE t.device_id = o.device_id E t.Trajeto_start_time > ls.last_service_date ) km ON TRUE JOIN raw_business_data.vehicle_service_tasks vst ON vst.vehicle_id = v.vehicle_id AND vst.completion_date = ls.last_service_date AND (vst.description ILIKE '%minor%' OR vst.description ILIKE '%major%') ``` {% endcode %} ## **Limite de Quilometragem e penalidades** Os contratos de leasing frequentemente limitam a quilometragem (por exemplo, 25.000 km/ano). Se o limite for excedido, aplicam-se cláusulas de penalidade. O sistema deve comparar a quilometragem real ao longo do período do contrato com o limite acordado e calcular as taxas. {% code expandable="true" %} ```sql WITH driven AS ( SELECT o.object_id, DATE_TRUNC('year', t.trip_start_time) AS year, SUM(t.trip_distance_meters) / 1000.0 AS km_year FROM processed_common_data.viagens t JOIN raw_business_data.objects o ON o.device_id = t.device_id WHERE t.trip_start_time >= '2023-01-01'::date AND t.trip_start_time < '2024-01-01'::date AGRUPAR POR o.object_id, DATE_TRUNC('year', t.trip_start_time) ), limits AS ( SELECT object_id, 10000 AS km_limit, 0.5 AS penalty_rate FROM raw_business_data.objects ) SELECT d.object_id, d.year, d.km_year, l.km_limit, GREATEST(d.km_year - l.km_limit, 0) AS km_over, GREATEST(d.km_year - l.km_limit, 0) * l.penalty_rate AS penalty_amount FROM dirigido d JOIN limits l ON d.object_id = l.object_id; ``` {% endcode %} ## **Monitoramento de Horas de motor** Para máquinas e equipamentos agrícolas, as horas de operação — e não a Quilometragem — determinam a Manutenção e a cobrança. Os dados de horas do motor (por exemplo, do CAN-Bus) devem ser monitorados e resumidos. {% code expandable="true" %} ```sql WITH last_service AS ( SELECT vst.vehicle_id, MAX(vst.completion_date) AS last_service_date, MAX(vst.completion_engine_hours) AS last_service_engine_hours FROM raw_business_data.vehicle_service_tasks vst AGRUPAR POR vst.vehicle_id ), engine_hours_since_service AS ( SELECT v.vehicle_id, SUM(t.trip_duration_seconds) / 3600.0 AS engine_hours_since_service FROM raw_business_data.veículos v JOIN raw_business_data.objects o ON o.object_id = v.object_id JOIN processed_common_data.trips t ON t.device_id = o.device_id JOIN last_service ls ON ls.vehicle_id = v.vehicle_id WHERE t.trip_start_time > ls.last_service_date AGRUPAR POR v.vehicle_id ) SELECT v.vehicle_id, v.vehicle_label, ls.last_service_engine_hours, ehs.engine_hours_since_service, (COALESCE(ehs.engine_hours_since_service,0) + COALESCE(ls.last_service_engine_hours,0)) AS current_engine_hours, vst.engine_hours_limit FROM raw_business_data.veículos v JOIN last_service ls ON ls.vehicle_id = v.vehicle_id LEFT JOIN engine_hours_since_service ehs ON ehs.vehicle_id = v.vehicle_id JOIN raw_business_data.vehicle_service_tasks vst ON vst.vehicle_id = v.vehicle_id AND vst.completion_date = ls.last_service_date ``` {% endcode %} ## **Eventos de Frenagem brusca** O comportamento de Condução afeta o desgaste e a conformidade contratual. Detectar Frenagem brusca ajuda o banco a atribuir o desgaste prematuro de freios/pneus ao uso indevido pelo Motorista e, se necessário, repassar os custos. A consulta SQL abaixo primeiro calcula a velocidade em quilômetros por hora e a diferença de tempo entre pontos de dados consecutivos para cada dispositivo. Usando essas informações, ela então calcula a taxa de desaceleração em quilômetros por hora por segundo. Por fim, filtra e retorna os registros em que a taxa de desaceleração é 20 km/h por segundo ou superior, indicando eventos significativos de desaceleração. {% code expandable="true" %} ```sql WITH spd AS ( SELECT device_id, device_time, speed/100.0 AS kmh, LAG(speed/100.0) OVER (PARTITION BY device_id ORDER BY device_time) AS prev_kmh, EXTRACT(EPOCH FROM (device_time - LAG(device_time) OVER (PARTITION BY device_id ORDER BY device_time))) AS dt_sec FROM raw_telematics_data.rastreamento_data_core WHERE device_time BETWEEN '2025-07-24 00:00:00' AND '2025-07-24 23:59:59' ), decels AS ( SELECT device_id, device_time, (prev_kmh - kmh) / NULLIF(dt_sec, 0) AS decel_kmh_per_sec FROM spd WHERE prev_kmh IS NOT NULL ) SELECT * FROM decels WHERE decel_kmh_per_sec >= 20; ``` {% endcode %} ## **Eventos de Aceleração brusca** A aceleração agressiva aumenta o desgaste dos pneus, transmissões, trem de força e coxins do motor. Identificar esses eventos ajuda na orientação e na possível recuperação de custos. A consulta SQL abaixo foi projetada para identificar eventos significativos de aceleração em um conjunto de dados de Monitor. Ela primeiro calcula a velocidade em quilômetros por hora e a diferença de tempo entre pontos de dados consecutivos para cada dispositivo. Usando essas informações, ela então calcula a taxa de aceleração em quilômetros por hora por segundo. Por fim, filtra e retorna registros em que a taxa de aceleração atinge ou excede um limite especificado, indicando eventos significativos de aceleração. {% code expandable="true" %} ```sql WITH spd AS ( SELECT device_id, device_time, speed/100.0 AS kmh, LAG(speed/100.0) OVER (PARTITION BY device_id ORDER BY device_time) AS prev_kmh, EXTRACT(EPOCH FROM (device_time - LAG(device_time) OVER (PARTITION BY device_id ORDER BY device_time))) AS dt_sec FROM raw_telematics_data.rastreamento_data_core WHERE device_time BETWEEN '2025-07-28 00:00:00' AND '2025-07-28 23:59:59' ) SELECT device_id, device_time, (kmh - prev_kmh) / NULLIF(dt_sec, 0) AS accel_kmh_per_sec FROM spd WHERE prev_kmh IS NOT NULL AND (kmh - prev_kmh) / NULLIF(dt_sec, 0) >= 20; ``` {% endcode %} ## **Conversões bruscas / contorno de curvas** Curvas acentuadas combinadas com mudanças bruscas de velocidade indicam Condução arriscada. Monitorar esse comportamento ajuda a detectar o uso inadequado do veículo. Esta consulta SQL foi projetada para identificar mudanças significativas de direção e velocidade a partir de dados de Monitor em um período de tempo especificado. Ela primeiro converte os valores brutos de latitude e longitude em graus decimais e calcula a velocidade em quilômetros por hora. Usando a função LAG, ela recupera os dados anteriores de localização e velocidade de cada dispositivo, permitindo o cálculo das mudanças ao longo do tempo. A consulta então calcula a mudança de rumo em graus usando funções trigonométricas para determinar o azimute entre pontos consecutivos. Ela também calcula a mudança de velocidade entre esses pontos. Por fim, a consulta filtra os resultados para incluir apenas os registros em que a mudança absoluta de rumo seja de 10 graus ou mais e a mudança absoluta de velocidade seja de 5 km/h ou mais, identificando manobras ou eventos significativos nos dados de Monitor. {% code expandable="true" %} ```sql WITH pts AS ( SELECT device_id, device_time, latitude/1e7::numeric AS lat, longitude/1e7::numeric AS lon, LAG(latitude/1e7::numeric) OVER (PARTITION BY device_id ORDER BY device_time) AS prev_lat, LAG(longitude/1e7::numeric) OVER (PARTITION BY device_id ORDER BY device_time) AS prev_lon, speed/100.0 AS kmh, LAG(speed/100.0) OVER (PARTITION BY device_id ORDER BY device_time) AS prev_kmh FROM raw_telematics_data.rastreamento_data_core WHERE device_time BETWEEN '2025-07-28 00:00:00' AND '2025-07-28 23:59:59' ), bearing AS ( SELECT *, atan2( sin(radians(lon-prev_lon))*cos(radians(lat)), cos(radians(prev_lat))*sin(radians(lat)) - sin(radians(prev_lat))*cos(radians(lat))*cos(radians(lon-prev_lon)) ) * 180/pi() AS heading_change, (kmh - prev_kmh) AS delta_speed FROM pts ) SELECT * FROM bearing WHERE abs(heading_change) >= 10 AND abs(delta_speed) >= 5; ``` {% endcode %} ## **Detecção de Ignição e Motor ocioso** Medir o tempo em motor ocioso (Ignição ligada, baixa/nenhuma velocidade) ajuda a reduzir o desperdício de Combustível e identificar uso indevido. Períodos longos de motor ocioso devem ser relatados e gerenciados. {% hint style="info" %} [Dashboard Studio](/docs/analytics/pt-br/dashboard-studio.md) e ferramentas semelhantes não oferecem suporte à substituição de variáveis (`:variable` sintaxe). Substitua todos os parâmetros por valores literais antes de executar esta consulta. Veja o exemplo abaixo para o formato correto. {% endhint %} {% code expandable="true" %} ```sql WITH ign AS ( SELECT device_id, device_time, value::int AS ign_on FROM raw_telematics_data.states WHERE state_name = 'ignition' AND device_time BETWEEN :from_ts::timestamptz AND :to_ts::timestamptz -- Para o Dashboard Studio, substitua :from_ts e :to_ts por timestamps literais: -- TIMESTAMPTZ '2024-01-01 00:00:00+00' AND TIMESTAMPTZ '2024-01-07 00:00:00+00' ), spd AS ( SELECT device_id, device_time, speed / 100.0 AS kmh DE raw_telematics_data.tracking_data_core WHERE device_time BETWEEN :from_ts AND :to_ts -- Para o Dashboard Studio, substitua :from_ts e :to_ts por timestamps literais: -- TIMESTAMPTZ '2024-01-01 00:00:00+00' AND TIMESTAMPTZ '2024-01-07 00:00:00+00' ), merged AS ( SELECT i.device_id, i.device_time, i.ign_on, s.kmh, LEAD(i.device_time) OVER ( PARTITION BY i.device_id ORDER BY i.device_time ) AS next_time FROM ign i LEFT JOIN spd s USING (device_id, device_time) ) SELECT device_id, device_time AS idle_start, next_time AS idle_end, EXTRACT(EPOCH FROM (next_time - device_time)) / 60.0 AS idle_minutes FROM merged WHERE ign_on = 1 AND kmh < :idle_speed -- Para o Dashboard Studio, substitua :idle_speed por um valor numérico, por exemplo, 5 AND next_time IS NOT NULL AND (next_time - device_time) >= (:idle_min::int * INTERVAL '1 minute'); -- Para o Dashboard Studio, substitua :idle_min por um valor numérico, por exemplo, (5 * INTERVAL '1 minute') ``` {% endcode %} --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation by asking a question. Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters: ``` GET https://navixy.com/docs/analytics/pt-br/example-queries/leasing.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.