attempting to split energydata table by asset

#22

database/addAsset.d.ts

@@ -1,3 +1,3 @@
 import sqlite from 'better-sqlite3';
 import type { Asset } from '../types/recordTypes.js';
-export declare function addAsset(asset: Partial<Asset>, sessionUser: EmileUser, connectedEmileDB?: sqlite.Database): number;
+export declare function addAsset(asset: Partial<Asset>, sessionUser: EmileUser, connectedEmileDB?: sqlite.Database): Promise<number>;

database/addAsset.js

@@ -1,6 +1,7 @@
 import sqlite from 'better-sqlite3';
 import { databasePath } from '../helpers/functions.database.js';
-export function addAsset(asset, sessionUser, connectedEmileDB) {
+import { ensureEnergyDataTableExists } from './manageEnergyDataTables.js';
+export async function addAsset(asset, sessionUser, connectedEmileDB) {
     const emileDB = connectedEmileDB === undefined ? sqlite(databasePath) : connectedEmileDB;
     const rightNowMillis = Date.now();
     const result = emileDB
@@ -11,8 +12,10 @@ export function addAsset(asset, sessionUser, connectedEmileDB) {
         recordUpdate_userName, recordUpdate_timeMillis)
         values (?, ?, ?, ?, ?, ?, ?, ?)`)
         .run(asset.assetName, asset.categoryId, (asset.latitude ?? '') === '' ? undefined : asset.latitude, (asset.longitude ?? '') === '' ? undefined : asset.longitude, sessionUser.userName, rightNowMillis, sessionUser.userName, rightNowMillis);
+    const assetId = result.lastInsertRowid;
+    await ensureEnergyDataTableExists(assetId);
     if (connectedEmileDB === undefined) {
         emileDB.close();
     }
-    return result.lastInsertRowid;
+    return assetId;
 }

database/addAsset.ts

@@ -3,11 +3,13 @@ import sqlite from 'better-sqlite3'
 import { databasePath } from '../helpers/functions.database.js'
 import type { Asset } from '../types/recordTypes.js'
 
-export function addAsset(
+import { ensureEnergyDataTableExists } from './manageEnergyDataTables.js'
+
+export async function addAsset(
   asset: Partial<Asset>,
   sessionUser: EmileUser,
   connectedEmileDB?: sqlite.Database
-): number {
+): Promise<number> {
   const emileDB =
     connectedEmileDB === undefined ? sqlite(databasePath) : connectedEmileDB
 
@@ -33,9 +35,13 @@ export function addAsset(
       rightNowMillis
     )
 
+  const assetId = result.lastInsertRowid as number
+
+  await ensureEnergyDataTableExists(assetId)
+
   if (connectedEmileDB === undefined) {
     emileDB.close()
   }
 
-  return result.lastInsertRowid as number
+  return assetId
 }

database/addEnergyData.js

@@ -1,6 +1,7 @@
 import Debug from 'debug';
 import { getConnectionWhenAvailable } from '../helpers/functions.database.js';
 import { delay } from '../helpers/functions.utilities.js';
+import { ensureEnergyDataTableExists } from './manageEnergyDataTables.js';
 const debug = Debug('emile:database:addEnergyData');
 export async function addEnergyData(data, sessionUser, connectedEmileDB) {
     const emileDB = connectedEmileDB === undefined
@@ -10,8 +11,9 @@ export async function addEnergyData(data, sessionUser, connectedEmileDB) {
     while (true) {
         try {
             const rightNowMillis = Date.now();
+            const tableName = await ensureEnergyDataTableExists(data.assetId);
             result = emileDB
-                .prepare(`insert into EnergyData (
+                .prepare(`insert into ${tableName} (
             assetId, dataTypeId, fileId,
             timeSeconds, durationSeconds, dataValue, powerOfTenMultiplier,
             recordCreate_userName, recordCreate_timeMillis,

database/addEnergyData.ts

@@ -5,6 +5,8 @@ import { getConnectionWhenAvailable } from '../helpers/functions.database.js'
 import { delay } from '../helpers/functions.utilities.js'
 import type { EnergyData } from '../types/recordTypes.js'
 
+import { ensureEnergyDataTableExists } from './manageEnergyDataTables.js'
+
 const debug = Debug('emile:database:addEnergyData')
 
 export async function addEnergyData(
@@ -23,9 +25,13 @@ export async function addEnergyData(
     try {
       const rightNowMillis = Date.now()
 
+      const tableName = await ensureEnergyDataTableExists(
+        data.assetId as number
+      )
+
       result = emileDB
         .prepare(
-          `insert into EnergyData (
+          `insert into ${tableName} (
             assetId, dataTypeId, fileId,
             timeSeconds, durationSeconds, dataValue, powerOfTenMultiplier,
             recordCreate_userName, recordCreate_timeMillis,

database/deleteEnergyData.d.ts

@@ -1,2 +1,2 @@
-export declare function deleteEnergyData(dataId: number | string, sessionUser: EmileUser): boolean;
+export declare function deleteEnergyData(assetId: number | string, dataId: number | string, sessionUser: EmileUser): Promise<boolean>;
 export declare function deleteEnergyDataByFileId(fileId: number | string, sessionUser: EmileUser): Promise<boolean>;

database/deleteEnergyData.js

@@ -1,9 +1,10 @@
-import sqlite from 'better-sqlite3';
-import { databasePath, getConnectionWhenAvailable } from '../helpers/functions.database.js';
-export function deleteEnergyData(dataId, sessionUser) {
-    const emileDB = sqlite(databasePath);
+import { getConnectionWhenAvailable } from '../helpers/functions.database.js';
+import { ensureEnergyDataTableExists, reloadEnergyDataTableNames } from './manageEnergyDataTables.js';
+export async function deleteEnergyData(assetId, dataId, sessionUser) {
+    const emileDB = await getConnectionWhenAvailable();
+    const tableName = await ensureEnergyDataTableExists(assetId, emileDB);
     const result = emileDB
-        .prepare(`update EnergyData
+        .prepare(`update ${tableName}
         set recordDelete_userName = ?,
         recordDelete_timeMillis = ?
         where recordDelete_timeMillis is null
@@ -14,13 +15,18 @@ export function deleteEnergyData(dataId, sessionUser) {
 }
 export async function deleteEnergyDataByFileId(fileId, sessionUser) {
     const emileDB = await getConnectionWhenAvailable();
-    const result = emileDB
-        .prepare(`update EnergyData
-        set recordDelete_userName = ?,
-        recordDelete_timeMillis = ?
-        where recordDelete_timeMillis is null
-        and fileId = ?`)
-        .run(sessionUser.userName, Date.now(), fileId);
+    const tableNames = await reloadEnergyDataTableNames(emileDB);
+    let count = 0;
+    for (const tableName of tableNames) {
+        const result = emileDB
+            .prepare(`update ${tableName}
+          set recordDelete_userName = ?,
+          recordDelete_timeMillis = ?
+          where recordDelete_timeMillis is null
+          and fileId = ?`)
+            .run(sessionUser.userName, Date.now(), fileId);
+        count += result.changes;
+    }
     emileDB.close();
-    return result.changes > 0;
+    return count > 0;
 }

database/deleteEnergyData.ts

@@ -1,16 +1,22 @@
-import sqlite from 'better-sqlite3'
+import { getConnectionWhenAvailable } from '../helpers/functions.database.js'
 
-import { databasePath, getConnectionWhenAvailable } from '../helpers/functions.database.js'
+import {
+  ensureEnergyDataTableExists,
+  reloadEnergyDataTableNames
+} from './manageEnergyDataTables.js'
 
-export function deleteEnergyData(
+export async function deleteEnergyData(
+  assetId: number | string,
   dataId: number | string,
   sessionUser: EmileUser
-): boolean {
-  const emileDB = sqlite(databasePath)
+): Promise<boolean> {
+  const emileDB = await getConnectionWhenAvailable()
+
+  const tableName = await ensureEnergyDataTableExists(assetId, emileDB)
 
   const result = emileDB
     .prepare(
-      `update EnergyData
+      `update ${tableName}
         set recordDelete_userName = ?,
         recordDelete_timeMillis = ?
         where recordDelete_timeMillis is null
@@ -29,17 +35,25 @@ export async function deleteEnergyDataByFileId(
 ): Promise<boolean> {
   const emileDB = await getConnectionWhenAvailable()
 
-  const result = emileDB
-    .prepare(
-      `update EnergyData
-        set recordDelete_userName = ?,
-        recordDelete_timeMillis = ?
-        where recordDelete_timeMillis is null
-        and fileId = ?`
-    )
-    .run(sessionUser.userName, Date.now(), fileId)
+  const tableNames = await reloadEnergyDataTableNames(emileDB)
+
+  let count = 0
+
+  for (const tableName of tableNames) {
+    const result = emileDB
+      .prepare(
+        `update ${tableName}
+          set recordDelete_userName = ?,
+          recordDelete_timeMillis = ?
+          where recordDelete_timeMillis is null
+          and fileId = ?`
+      )
+      .run(sessionUser.userName, Date.now(), fileId)
+
+    count += result.changes
+  }
 
   emileDB.close()
 
-  return result.changes > 0
+  return count > 0
 }

database/getEnergyData.js

@@ -2,6 +2,7 @@ import { powerOfTenMultipliers } from '@cityssm/green-button-parser/lookups.js';
 import { dateStringToDate } from '@cityssm/utils-datetime';
 import sqlite from 'better-sqlite3';
 import { databasePath, getConnectionWhenAvailable, getTempTableName } from '../helpers/functions.database.js';
+import { ensureEnergyDataTableExists } from './manageEnergyDataTables.js';
 function userFunction_getPowerOfTenMultiplierName(powerOfTenMultiplier) {
     if (powerOfTenMultiplier === 0) {
         return '';
@@ -61,7 +62,7 @@ export async function getEnergyData(filters, options) {
         filters.startDateString !== filters.endDateString;
     const columnNames = options?.formatForExport ?? false
         ? `d.dataId,
-        c.category, a.assetName, 
+        c.category, a.assetName,
         ts.serviceCategory,
         userFunction_getPowerOfTenMultiplierName(d.powerOfTenMultiplier) as powerOfTenMultiplierName,
         tu.unit,
@@ -103,9 +104,13 @@ export async function getEnergyData(filters, options) {
         d.fileId, f.originalFileName,
         d.timeSeconds, d.durationSeconds, d.endTimeSeconds,
         d.dataValue, d.powerOfTenMultiplier`;
+    const emileDB = await getConnectionWhenAvailable(true);
+    const tableName = (filters.assetId ?? '') === ''
+        ? 'EnergyData'
+        : await ensureEnergyDataTableExists(filters.assetId, emileDB);
     const { sqlParameters, sqlWhereClause } = buildWhereClause(filters);
     let sql = `select ${columnNames}
-    from EnergyData d
+    from ${tableName} d
     left join Assets a
       on d.assetId = a.assetId
     left join AssetCategories c
@@ -131,8 +136,9 @@ export async function getEnergyData(filters, options) {
         sql +=
             " group by d.assetId, d.dataTypeId, substr(datetime(d.timeSeconds, 'unixepoch', 'localtime'), 1, 10), d.powerOfTenMultiplier";
     }
-    const orderBy = ' order by assetId, dataTypeId, timeSeconds';
-    const emileDB = await getConnectionWhenAvailable(true);
+    const orderBy = options?.formatForExport ?? false
+        ? ''
+        : ' order by assetId, dataTypeId, timeSeconds';
     emileDB.function('userFunction_getPowerOfTenMultiplierName', userFunction_getPowerOfTenMultiplierName);
     const tempTableName = getTempTableName();
     emileDB

database/getEnergyData.ts

@@ -15,6 +15,8 @@ import {
 } from '../helpers/functions.database.js'
 import type { EnergyData } from '../types/recordTypes.js'
 
+import { ensureEnergyDataTableExists } from './manageEnergyDataTables.js'
+
 interface GetEnergyDataFilters {
   assetId?: number | string
   categoryId?: number | string
@@ -124,7 +126,7 @@ export async function getEnergyData(
   const columnNames =
     options?.formatForExport ?? false
       ? `d.dataId,
-        c.category, a.assetName, 
+        c.category, a.assetName,
         ts.serviceCategory,
         userFunction_getPowerOfTenMultiplierName(d.powerOfTenMultiplier) as powerOfTenMultiplierName,
         tu.unit,
@@ -167,10 +169,20 @@ export async function getEnergyData(
         d.timeSeconds, d.durationSeconds, d.endTimeSeconds,
         d.dataValue, d.powerOfTenMultiplier`
 
+  const emileDB = await getConnectionWhenAvailable(true)
+
+  const tableName =
+    (filters.assetId ?? '') === ''
+      ? 'EnergyData'
+      : await ensureEnergyDataTableExists(
+          filters.assetId as string | number,
+          emileDB
+        )
+
   const { sqlParameters, sqlWhereClause } = buildWhereClause(filters)
 
   let sql = `select ${columnNames}
-    from EnergyData d
+    from ${tableName} d
     left join Assets a
       on d.assetId = a.assetId
     left join AssetCategories c
@@ -198,9 +210,9 @@ export async function getEnergyData(
       " group by d.assetId, d.dataTypeId, substr(datetime(d.timeSeconds, 'unixepoch', 'localtime'), 1, 10), d.powerOfTenMultiplier"
   }
 
-  const orderBy = ' order by assetId, dataTypeId, timeSeconds'
-
-  const emileDB = await getConnectionWhenAvailable(true)
+  const orderBy = options?.formatForExport ?? false
+    ? ''
+    : ' order by assetId, dataTypeId, timeSeconds'
 
   emileDB.function(
     'userFunction_getPowerOfTenMultiplierName',

database/initializeDatabase.d.ts

@@ -1 +1,2 @@
-export declare function initializeDatabase(): void;
+export declare const recordColumns = " recordCreate_userName varchar(30) not null,\n    recordCreate_timeMillis integer not null,\n    recordUpdate_userName varchar(30) not null,\n    recordUpdate_timeMillis integer not null,\n    recordDelete_userName varchar(30),\n    recordDelete_timeMillis integer";
+export declare function initializeDatabase(): Promise<void>;

database/initializeDatabase.js

@@ -10,14 +10,15 @@ import { addEnergyReadingType } from './addEnergyReadingType.js';
 import { addEnergyServiceCategory } from './addEnergyServiceCategory.js';
 import { addEnergyUnit } from './addEnergyUnit.js';
 import { addUser } from './addUser.js';
+import { refreshEnergyDataTableView } from './manageEnergyDataTables.js';
 const debug = Debug('emile:database:initializeDatabase');
 const initializeDatabaseUser = {
     userName: 'system.initialize',
     canLogin: false,
     canUpdate: true,
     isAdmin: true
 };
-const recordColumns = ` recordCreate_userName varchar(30) not null,
+export const recordColumns = ` recordCreate_userName varchar(30) not null,
     recordCreate_timeMillis integer not null,
     recordUpdate_userName varchar(30) not null,
     recordUpdate_timeMillis integer not null,
@@ -217,7 +218,7 @@ function initializeAssetAliasTypes(emileDB) {
         }, initializeDatabaseUser);
     }
 }
-export function initializeDatabase() {
+export async function initializeDatabase() {
     const emileDB = sqlite(databasePath);
     const row = emileDB
         .prepare(`select name from sqlite_master
@@ -299,25 +300,7 @@ export function initializeDatabase() {
         primary key (groupId, assetId)
       )`)
         .run();
-    emileDB
-        .prepare(`create table if not exists EnergyData (
-        dataId integer primary key autoincrement,
-        assetId integer not null references Assets (assetId),
-        dataTypeId integer not null references EnergyDataTypes (dataTypeId),
-        fileId integer references EnergyDataFiles (fileId),
-        timeSeconds integer not null check (timeSeconds > 0),
-        durationSeconds integer not null check (durationSeconds > 0),
-        endTimeSeconds integer not null generated always as (timeSeconds + durationSeconds) virtual,
-        dataValue decimal(10, 2) not null,
-        powerOfTenMultiplier integer not null default 0,
-        ${recordColumns}
-      )`)
-        .run();
-    emileDB
-        .prepare(`create index if not exists idx_EnergyData on EnergyData
-        (assetId, dataTypeId, timeSeconds)
-        where recordDelete_timeMillis is null`)
-        .run();
+    await refreshEnergyDataTableView(emileDB);
     emileDB
         .prepare(`create table if not exists Users (
         userName varchar(30) primary key,