fix(core): update

ts/smartclickhouse.classes.smartclickhouse.ts

@@ -7,8 +7,6 @@ export interface IClickhouseConstructorOptions {
   password?: string;
 }
 
-
-
 export class SmartClickHouseDb {
   public options: IClickhouseConstructorOptions;
   public clickhouseClient: plugins.clickhouse.ClickHouseClient;
@@ -20,24 +18,25 @@ export class SmartClickHouseDb {
   /**
    * starts the connection to the Clickhouse db
    */
-  public async start() {
-    console.log(`Connecting to default database first.`)
+  public async start(dropOld = false) {
+    console.log(`Connecting to default database first.`);
     const defaultClient = new plugins.clickhouse.ClickHouseClient({
       ...this.options,
-      database: 'default'
+      database: 'default',
     });
     console.log(`Create database ${this.options.database}, if it does not exist...`);
+    if (dropOld) {
+      await defaultClient.queryPromise(`DROP DATABASE IF EXISTS ${this.options.database}`);
+    }
     await defaultClient.queryPromise(`CREATE DATABASE IF NOT EXISTS ${this.options.database}`);
 
-    console.log(`Ensured database. Now connecting to wanted database: ${this.options.database}`)
+    console.log(`Ensured database. Now connecting to wanted database: ${this.options.database}`);
     this.clickhouseClient = new plugins.clickhouse.ClickHouseClient({
       ...this.options,
-
     });
     console.log(`trying to ping database...`);
     const result = await this.clickhouseClient.ping();
     console.log(`Ping successfull?: ${result}`);
-    
   }
 
   /**
@@ -45,5 +44,6 @@ export class SmartClickHouseDb {
    */
   public async getTable(tableName: string) {
     const newTable = TimeDataTable.getTable(this, tableName);
+    return newTable;
   }
-}
+}

ts/smartclickhouse.classes.timedatatable.ts

@@ -1,15 +1,52 @@
 import * as plugins from './smartclickhouse.plugins';
 import { SmartClickHouseDb } from './smartclickhouse.classes.smartclickhouse';
 
+export type TClickhouseColumnDataType = 'String' | "DateTime64(3, 'Europe/Berlin')" | 'Float64';
+export interface IColumnInfo {
+  database: string;
+  table: string;
+  name: string;
+  type: TClickhouseColumnDataType;
+  position: string;
+  default_kind: string;
+  default_expression: string;
+  data_compressed_bytes: string;
+  data_uncompressed_bytes: string;
+  marks_bytes: string;
+  comment: string;
+  is_in_partition_key: 0 | 1;
+  is_in_sorting_key: 0 | 1;
+  is_in_primary_key: 0 | 1;
+  is_in_sampling_key: 0 | 1;
+  compression_codec: string;
+  character_octet_length: null;
+  numeric_precision: null;
+  numeric_precision_radix: null;
+  numeric_scale: null;
+  datetime_precision: '3';
+}
+
 export class TimeDataTable {
-  public static async getTable (smartClickHouseDbRefArg: SmartClickHouseDb, tableNameArg: string) {
+  public static async getTable(smartClickHouseDbRefArg: SmartClickHouseDb, tableNameArg: string) {
     const newTable = new TimeDataTable(smartClickHouseDbRefArg, tableNameArg);
 
     // create table in clickhouse
-    await smartClickHouseDbRefArg.clickhouseClient.queryPromise(`CREATE TABLE IF NOT EXISTS ${newTable.tableName} (
+    await smartClickHouseDbRefArg.clickhouseClient
+      .queryPromise(`CREATE TABLE IF NOT EXISTS ${newTable.tableName} (
       timestamp DateTime64(3, 'Europe/Berlin'),
       message String
     ) ENGINE=MergeTree() ORDER BY timestamp`);
+
+    await newTable.updateColumns();
+    console.log(`=======================`)
+    console.log(
+      `table with name "${newTable.tableName}" in databse ${newTable.smartClickHouseDbRef.options.database} has the following columns:`
+    );
+    for (const column of newTable.columns) {
+      console.log(`>> ${column.name}: ${column.type}`);
+    }
+    console.log('^^^^^^^^^^^^^^\n');
+
     return newTable;
   }
 
@@ -22,8 +59,71 @@ export class TimeDataTable {
     this.tableName = tableNameArg;
   }
 
+  public columns: IColumnInfo[] = [];
+  public seenPaths: { pathName: string; type: TClickhouseColumnDataType }[] = [];
+
+  /**
+   * updates the columns
+   */
+  public async updateColumns() {
+    this.columns = await this.smartClickHouseDbRef.clickhouseClient.queryPromise(`
+      SELECT * FROM system.columns
+      WHERE database LIKE '${this.smartClickHouseDbRef.options.database}'
+      AND table LIKE '${this.tableName}'
+    `);
+    return this.columns;
+  }
+
   /**
    * stores a json and tries to map it to the nested syntax
    */
-  public async storeJson () {}
-}
+  public async addData(dataArg: any) {
+    // the storageJson
+    let storageJson: { [key: string]: any } = {};
+    
+    // helper stuff
+    const typeConversion: {[key: string]: TClickhouseColumnDataType} = {
+      string: 'String',
+      number: 'Float64',
+    };
+    const getClickhouseTypeForValue = (valueArg: any) => {
+      return typeConversion[(typeof valueArg) as string];
+    }
+    const checkPath = async (pathArg: string, typeArg: TClickhouseColumnDataType) => {
+      let columnFound = false;
+      for (const column of this.columns) {
+        if (pathArg === column.name) {
+          columnFound = true;
+          break;
+        }
+      }
+      if (!columnFound) {
+        await this.smartClickHouseDbRef.clickhouseClient.queryPromise(`
+          ALTER TABLE ${this.tableName} ADD COLUMN ${pathArg} ${typeArg} FIRST
+        `);
+        await this.updateColumns();
+      }
+    };
+
+    // key checking
+    const flatDataArg = plugins.smartobject.toFlatObject(dataArg);
+    for (const key of Object.keys(flatDataArg)) {
+      const value = flatDataArg[key];
+      if (key === 'timestamp' && typeof value !== 'number') {
+        throw new Error('timestamp must be of type number');
+      } else if (key === 'timestamp') {
+        storageJson.timestamp = flatDataArg[key];
+        continue;
+      }
+      // lets deal with the rest
+      const clickhouseType = getClickhouseTypeForValue(value);
+      await checkPath(key, clickhouseType);
+      storageJson[key] = value;
+    }
+
+    const result = await this.smartClickHouseDbRef.clickhouseClient.insertPromise(this.tableName, [
+      storageJson,
+    ]);
+    return result;
+  }
+}

ts/smartclickhouse.plugins.ts

@@ -1,5 +1,11 @@
-import * as clickhouse from '@depyronick/clickhouse-client';
+// @pushrocks scope
+import * as smartobject from '@pushrocks/smartobject';
 
 export {
-  clickhouse
+  smartobject
 }
+
+// thirdparty
+import * as clickhouse from '@depyronick/clickhouse-client';
+
+export { clickhouse };