From 8fe1b23515d85cbaf6ffe0f7dc2668b2c3fc5dc6 Mon Sep 17 00:00:00 2001 From: Nael Shiab Date: Fri, 9 Aug 2024 08:46:39 -0400 Subject: [PATCH] Updating doc --- docs/classes/SimpleDB.html | 46 +++--- docs/classes/SimpleTable.html | 269 ++++++++++++++++--------------- docs/classes/SimpleWebDB.html | 44 ++--- docs/classes/SimpleWebTable.html | 254 ++++++++++++++--------------- docs/hierarchy.html | 2 +- docs/index.html | 4 +- docs/modules.html | 4 +- 7 files changed, 312 insertions(+), 311 deletions(-) diff --git a/docs/classes/SimpleDB.html b/docs/classes/SimpleDB.html index 9c9d29e4..63e2e798 100644 --- a/docs/classes/SimpleDB.html +++ b/docs/classes/SimpleDB.html @@ -1,4 +1,4 @@ -SimpleDB | Simple-data-analysis - v3.6.2

Class SimpleDB

SimpleDB is a class that provides a simplified interface for working with DuckDB, a high-performance, in-memory analytical database. This class is meant to be used with NodeJS and similar runtimes. For web browsers, use SimpleWebDB.

+SimpleDB | Simple-data-analysis - v3.6.3

Class SimpleDB

SimpleDB is a class that provides a simplified interface for working with DuckDB, a high-performance, in-memory analytical database. This class is meant to be used with NodeJS and similar runtimes. For web browsers, use SimpleWebDB.

With very expensive computations, it might create a .tmp folder, so make sure to add .tmp to your gitignore.

Here's how to instantiate a SimpleDB instance and then a SimpleTable.

Example: Basic usage

// Instantiating the database.
const sdb = new SimpleDB()

// Creating a new table.
const employees = sdb.newTable("employees")

// You can now invoke methods on the table.
await employees.loadData("./employees.csv")
await employees.logTable()

// To free up memory.
await sdb.done()
@@ -7,7 +7,7 @@
 
Example: Instanciating with options
// Creating a database with options. Debug information will be logged each time a method is invoked. The first 20 rows of tables will be logged (default is 10).
const sdb = new SimpleWebDB({ debug: true, nbRowsToLog: 20 })
 

 
-

Hierarchy (view full)

Properties

bigIntToInt +

Hierarchy (view full)

Properties

bigIntToInt cacheSourcesUsed connection db @@ -29,19 +29,19 @@

removeTables

Internal

start

Properties

bigIntToInt

bigIntToInt: undefined | boolean

A flag for SimpleDB. Default is true. When data is retrieved from the database as an array of objects, BIGINT values are automatically converted to integers, which are easier to work with in JavaScript. If you want actual bigint values, set this option to false.

-

cacheSourcesUsed

cacheSourcesUsed: string[]

An object keeping track of the data used in cache.

-

connection

connection: AsyncDuckDBConnection | Connection

A connection to a DuckDB database.

-

db

db: AsyncDuckDB | Database

A DuckDB database.

-

debug

debug: boolean

A flag indicating whether debugging information should be logged. Defaults to false.

-

defaultTableName

defaultTableName: boolean

A flag to know if the name of the table has been attributed by default.

-

durationStart

durationStart: undefined | number

A timestamp used to track the total duration logged in done().

-

nbCharactersToLog

nbCharactersToLog: undefined | number

The number of characters to log for text cells. By default, the whole text is logged.

-

nbRowsToLog

nbRowsToLog: number

The number of rows to log. Defaults to 10.

-

runQuery

runQuery: ((query: string, connection: AsyncDuckDBConnection | Connection, returnDataFromQuery: boolean, options: {
    bigIntToInt?: boolean;
    debug: boolean;
    method: null | string;
    parameters: null | {
        [key: string]: unknown;
    };
}) => Promise<null | {
    [key: string]:
        | number
        | string
        | Date
        | boolean
        | null;
}[]>)

For internal use only. If you want to run a SQL query, use the customQuery method.

-

tableIncrement

tableIncrement: number

A number used when creating new tables.

-

worker

worker: null | Worker

A worker to make DuckDB WASM work.

-

Other

cacheVerbose

cacheVerbose: boolean

A flag to log messages relative to the cache. Defaults to false.

-

DB methods

customQuery

  • customQuery(query, options?): Promise<null | {
        [key: string]:
            | string
            | number
            | boolean
            | Date
            | null;
    }[]>

  • Executes a custom SQL query, providing flexibility for advanced users.

    +

cacheSourcesUsed

cacheSourcesUsed: string[]

An object keeping track of the data used in cache.

+

connection

connection: AsyncDuckDBConnection | Connection

A connection to a DuckDB database.

+

db

db: AsyncDuckDB | Database

A DuckDB database.

+

debug

debug: boolean

A flag indicating whether debugging information should be logged. Defaults to false.

+

defaultTableName

defaultTableName: boolean

A flag to know if the name of the table has been attributed by default.

+

durationStart

durationStart: undefined | number

A timestamp used to track the total duration logged in done().

+

nbCharactersToLog

nbCharactersToLog: undefined | number

The number of characters to log for text cells. By default, the whole text is logged.

+

nbRowsToLog

nbRowsToLog: number

The number of rows to log. Defaults to 10.

+

runQuery

runQuery: ((query: string, connection: AsyncDuckDBConnection | Connection, returnDataFromQuery: boolean, options: {
    bigIntToInt?: boolean;
    debug: boolean;
    method: null | string;
    parameters: null | {
        [key: string]: unknown;
    };
}) => Promise<null | {
    [key: string]:
        | number
        | string
        | Date
        | boolean
        | null;
}[]>)

For internal use only. If you want to run a SQL query, use the customQuery method.

+

tableIncrement

tableIncrement: number

A number used when creating new tables.

+

worker

worker: null | Worker

A worker to make DuckDB WASM work.

+

Other

cacheVerbose

cacheVerbose: boolean

A flag to log messages relative to the cache. Defaults to false.

+

DB methods

customQuery

done

done

  • done(): Promise<void>

  • Frees up memory by closing down the database and cleans up cache so it doesn't grow in size indefinitely.

    Returns Promise<void>

    Example: Basic usage

    await sdb.done();
    -

getExtensions

  • getExtensions(): Promise<{
        [key: string]:
            | string
            | number
            | boolean
            | Date
            | null;
    }[]>

  • Returns the DuckDB extensions.

    +

getExtensions

  • getExtensions(): Promise<{
        [key: string]:
            | string
            | number
            | boolean
            | Date
            | null;
    }[]>

  • Returns the DuckDB extensions.

    const extensions = await sdb.getExtensions()
    -

    Returns Promise<{
        [key: string]:
            | string
            | number
            | boolean
            | Date
            | null;
    }[]>

getTables

  • getTables(): Promise<string[]>

  • Returns the list of tables.

    +

    Returns Promise<{
        [key: string]:
            | string
            | number
            | boolean
            | Date
            | null;
    }[]>

getTables

hasTable

hasTable

  • hasTable(table): Promise<boolean>

  • Returns true if a specified table exists and false if not.

    Parameters

    • table: string

      The name of the table to check for existence.

    Returns Promise<boolean>

    Example: Basic usage

    const hasEmployees = await sdb.hasTable("employees")
    -

newTable

newTable

  • newTable(name?, projections?): SimpleTable

  • Creates a table in the DB.

    Parameters

    • Optionalname: string

      The name of the new table.

    • Optionalprojections: {
          [key: string]: string;
      }

      The projections of the geospatial data, if any.

      • [key: string]: string

    Returns SimpleTable

    Example: Basic usage

    // This returns a new SimpleTable
    const employees = sdb.newTable()
@@ -75,7 +75,7 @@ 
    Example: With a specific name
    // By default, tables will be named table1, table2, etc.
    // But you can also give them specific names.
    const employees = sdb.newTable("employees")
 
    
 
-

removeTables

  • removeTables(tables): Promise<void>

  • Remove a table or multiple tables from the database. Invoking methods on the tables will throw and error.

    +

removeTables

  • removeTables(tables): Promise<void>

  • Remove a table or multiple tables from the database. Invoking methods on the tables will throw and error.

    Parameters

    Returns Promise<void>

    Example: Basic usage

    await table.removeTables(tableA)
    @@ -83,5 +83,5 @@

    Example: Multiple tables

    await table.removeTables([tableA, tableB])
    -

Internal

start

Settings

Member Visibility

On This Page

Properties
Other
DB methods
Internal
+

Internal

start

Settings

Member Visibility

On This Page

Properties
Other
DB methods
Internal
diff --git a/docs/classes/SimpleTable.html b/docs/classes/SimpleTable.html index 465523b1..f12183ac 100644 --- a/docs/classes/SimpleTable.html +++ b/docs/classes/SimpleTable.html @@ -1,11 +1,11 @@ -SimpleTable | Simple-data-analysis - v3.6.2

Class SimpleTable

SimpleTable is a class representing a table in a SimpleDB. It can handle tabular and geospatial data. To create one, it's best to instantiate a SimpleDB first.

+SimpleTable | Simple-data-analysis - v3.6.3

Class SimpleTable

SimpleTable is a class representing a table in a SimpleDB. It can handle tabular and geospatial data. To create one, it's best to instantiate a SimpleDB first.

Example: Basic usage

// Creating a database first.
const sdb = new SimpleDB()

// Making a new table. This returns a SimpleTable.
const employees = sdb.newTable()

// You can now invoke methods on the table.
await employees.loadData("./employees.csv")
await employees.logTable()

// Removing the DB to free up memory.
await sdb.done()

Example: Geospatial data

// To load geospatial data, use .loadGeoData instead of .loadData
const boundaries = sdb.newTable()
await boundaries.loadGeoData("./boundaries.geojson")
-

Hierarchy (view full)

Properties

bigIntToInt +

Hierarchy (view full)

Properties

bigIntToInt connection db debug @@ -137,19 +137,19 @@

renameTable setTypes

Properties

bigIntToInt

bigIntToInt: undefined | boolean

A flag for SimpleDB. Default is true. When data is retrieved from the database as an array of objects, BIGINT values are automatically converted to integers, which are easier to work with in JavaScript. If you want actual bigint values, set this option to false.

-

connection

connection: AsyncDuckDBConnection | Connection

A connection to a DuckDB database.

-

db

db: AsyncDuckDB | Database

A DuckDB database.

-

debug

debug: boolean

A flag indicating whether debugging information should be logged. Defaults to false.

-

defaultTableName

defaultTableName: boolean

A flag to know if the name of the table has been attributed by default.

-

name

name: string

Name of the table in the database.

-

nbCharactersToLog

nbCharactersToLog: undefined | number

The number of characters to log for text cells. By default, the whole text is logged.

-

nbRowsToLog

nbRowsToLog: number

The number of rows to log. Defaults to 10.

-

projections

projections: {
    [key: string]: string;
}

The projections of the geospatial data, if any.

-

runQuery

runQuery: ((query: string, connection: AsyncDuckDBConnection | Connection, returnDataFromQuery: boolean, options: {
    bigIntToInt?: boolean;
    debug: boolean;
    method: null | string;
    parameters: null | {
        [key: string]: unknown;
    };
}) => Promise<null | {
    [key: string]:
        | number
        | string
        | Date
        | boolean
        | null;
}[]>)

For internal use only. If you want to run a SQL query, use the customQuery method.

-

sdb

sdb: SimpleDB

The SimpleDB that created this table.

-

tableIncrement

tableIncrement: number

A number used when creating new tables.

-

worker

worker: null | Worker

A worker to make DuckDB WASM work.

-

Analyzing data

bins

connection

connection: AsyncDuckDBConnection | Connection

A connection to a DuckDB database.

+

db

db: AsyncDuckDB | Database

A DuckDB database.

+

debug

debug: boolean

A flag indicating whether debugging information should be logged. Defaults to false.

+

defaultTableName

defaultTableName: boolean

A flag to know if the name of the table has been attributed by default.

+

name

name: string

Name of the table in the database.

+

nbCharactersToLog

nbCharactersToLog: undefined | number

The number of characters to log for text cells. By default, the whole text is logged.

+

nbRowsToLog

nbRowsToLog: number

The number of rows to log. Defaults to 10.

+

projections

projections: {
    [key: string]: string;
}

The projections of the geospatial data, if any.

+

runQuery

runQuery: ((query: string, connection: AsyncDuckDBConnection | Connection, returnDataFromQuery: boolean, options: {
    bigIntToInt?: boolean;
    debug: boolean;
    method: null | string;
    parameters: null | {
        [key: string]: unknown;
    };
}) => Promise<null | {
    [key: string]:
        | number
        | string
        | Date
        | boolean
        | null;
}[]>)

For internal use only. If you want to run a SQL query, use the customQuery method.

+

sdb

sdb: SimpleDB

The SimpleDB that created this table.

+

tableIncrement

tableIncrement: number

A number used when creating new tables.

+

worker

worker: null | Worker

A worker to make DuckDB WASM work.

+

Analyzing data

bins

  • bins(values, interval, newColumn, options?): Promise<void>

  • Assigns bins for specified column values based on an interval size.

    Parameters

    • values: string

      The column containing values from which bins will be computed.

    • interval: number

      The interval size for binning the values.

    • newColumn: string

      The name of the new column where the bins will be stored.

      @@ -161,7 +161,7 @@

      Example: Starting value

      // Same thing, but with the bins starting at a specific value.
      await table.bins("column1", 10, "bins", { startValue: 0 })
      // The bins will follow this pattern: "[0-9]", "[10-19]", "[20-29]", etc.
      -

correlations

correlations

  • correlations(options?): Promise<SimpleTable>

  • Calculates correlations between columns.

    If no x and y columns are specified, the method computes the correlations of all numeric columns combinations. It's important to note that correlation is symmetrical: the correlation of x over y is the same as y over x.

    Parameters

    • options: {
          categories?: string | string[];
          decimals?: number;
          outputTable?: string | boolean;
          x?: string;
          y?: string;
      } = {}

      An optional object with configuration options:

      • Optionalcategories?: string | string[]

        The column or columns that define categories. Correlation calculations will be run for each category.

        @@ -184,7 +184,7 @@

        Example: Returning results in a new table with a specific name in the DB

        // Same but results are stored in tableB.
        const tableB = await table.correlations({ outputTable: "tableB" })
        -

linearRegressions

linearRegressions

  • linearRegressions(options?): Promise<SimpleTable>

  • Performs linear regression analysis. The results include the slope, the y-intercept the R-squared.

    If no x and y columns are specified, the method computes the linear regression analysis of all numeric columns permutations. It's important to note that linear regression analysis is asymmetrical: the linear regression of x over y is not the same as y over x.

    Parameters

    • options: {
          categories?: string | string[];
          decimals?: number;
          outputTable?: string | boolean;
          x?: string;
          y?: string;
      } = {}

      An optional object with configuration options:

      • Optionalcategories?: string | string[]

        The column or columns that define categories. Correlation calculations will be run for each category.

        @@ -206,7 +206,7 @@

        Example: Returning results in a new table with a specific name in the DB

        // Same but stores the results in tableB.
        const tableB = await table.linearRegressions({ outputTable: "tableB" })
        -

normalize

normalize

  • normalize(column, newColumn, options?): Promise<void>

  • Normalizes the values in a column using min-max normalization.

    Parameters

    • column: string

      The name of the column in which values will be normalized.

    • newColumn: string

      The name of the new column where normalized values will be stored.

    • options: {
          categories?: string | string[];
          decimals?: number;
      } = {}

      An optional object with configuration options:

      @@ -221,7 +221,7 @@

      Example: Rounding values

      // Normalizes the values in the column1 with values from column2 as categories. The values are rounded to two decimal places.
      await table.normalize("column1", { categories: "column2", decimals: 2 })
      -

outliersIQR

outliersIQR

  • outliersIQR(column, newColumn, options?): Promise<void>

  • Identifies outliers using the Interquartile Range (IQR) method.

    Parameters

    • column: string

      The name of the column in which outliers will be identified.

    • newColumn: string

      The name of the new column where the bins will be stored.

    • options: {
          categories?: string | string[];
      } = {}

      An optional object with configuration options:

      @@ -232,7 +232,7 @@

      Example: With categories

      // Looks for outliers in column age with values from column gender as categories. Creates a new column outliers with TRUE or FALSE values.
      await table.outliersIQR("age", "outliers", { categories: "gender" })
      -

proportionsHorizontal

proportionsHorizontal

  • proportionsHorizontal(columns, options?): Promise<void>

  • Computes proportions within a row for specified columns.

    For example, let's say this is tableA.

    @@ -362,7 +362,7 @@

    Inherited from SimpleWebTable.proportionsHorizontal

    proportionsVertical

    proportionsVertical

    • proportionsVertical(column, newColumn, options?): Promise<void>

    • Computes proportions over a column's values.

      Parameters

      • column: string

        The column containing values for which proportions will be computed. The proportions are calculated based on the sum of values in the specified column.

      • newColumn: string

        The name of the new column where the proportions will be stored.

      • options: {
            categories?: string | string[];
            decimals?: number;
        } = {}

        An optional object with configuration options:

        @@ -377,7 +377,7 @@

        Example: With specific number of decimals

        // Same thing but rounding to two decimals
        await table.proportionsVertical("column1", "perc", { categories: "column2", decimals: 2 })
        -

    quantiles

    quantiles

    • quantiles(values, nbQuantiles, newColumn, options?): Promise<void>

    • Assigns quantiles for specified column values.

      Parameters

      • values: string

        The column containing values from which quantiles will be assigned.

      • nbQuantiles: number

        The number of quantiles.

      • newColumn: string

        The name of the new column where the assigned quantiles will be stored.

        @@ -389,7 +389,7 @@

        Example: With categories

        // Same thing, except the values in column2 are used as categories.
        await table.quantiles("column1", 10, "quantiles", { categories: "column2" })
        -

    ranks

    ranks

    • ranks(values, newColumn, options?): Promise<void>

    • Assigns ranks in a new column based on specified column values.

      Parameters

      • values: string

        The column containing values to be used for ranking.

      • newColumn: string

        The name of the new column where the ranks will be stored.

      • options: {
            categories?: string | string[];
            noGaps?: boolean;
            order?: "asc" | "desc";
        } = {}

        An optional object with configuration options:

        @@ -402,7 +402,7 @@

        Example: With categories

        // Computing ranks in the new column rank from the column1 values. Using the values from column2 as categories.
        await table.ranks("tableA", "column1", "rank", { categories: "column2" })
        -

    rolling

    • rolling(column, newColumn, summary, preceding, following, options?): Promise<void>

    • Computes rolling aggregations, like a rolling average. For rows without enough preceding or following rows, returns NULL. For this method to work properly, don't forget to sort your data first.

      +

    rolling

    • rolling(column, newColumn, summary, preceding, following, options?): Promise<void>

    • Computes rolling aggregations, like a rolling average. For rows without enough preceding or following rows, returns NULL. For this method to work properly, don't forget to sort your data first.

      Parameters

      • column: string

        The name of the column storing the values to be aggregated

      • newColumn: string

        The name of the new column in which the computed values will be stored

      • summary:
            | "min"
            | "max"
            | "mean"
            | "median"
            | "sum"

        How to aggregate the values

        @@ -420,7 +420,7 @@

        Example: Rounding

        // 7-day rolling average of values in column1 with the 3 preceding and 3 following rows. Using values in column2 as categories and rounding to two decimal places.
        await table.rolling("column1", "rollingAvg", "mean", 3, 3, { categories: "column2", decimals: 2 })
        -

    summarize

    summarize

    • summarize(options?): Promise<SimpleTable>

    • Creates a summary table based on specified values, categories, and summary operations.

      Parameters

      • options: {
            categories?: string | string[];
            decimals?: number;
            outputTable?: string | boolean;
            summaries?:
                | "count"
                | "countUnique"
                | "countNull"
                | "min"
                | "max"
                | "mean"
                | "median"
                | "sum"
                | "skew"
                | "stdDev"
                | "var"
                | (
                    | "count"
                    | "countUnique"
                    | "countNull"
                    | "min"
                    | "max"
                    | "mean"
                    | "median"
                    | "sum"
                    | "skew"
                    | "stdDev"
                    | "var")[];
            toMs?: boolean;
            values?: string | string[];
        } = {}

        An optional object with configuration options:

        • Optionalcategories?: string | string[]

          The column or columns that define categories for the summarization. This can be a single column name or an array of column names.

        • Optionaldecimals?: number

          The number of decimal places to round the summarized values.

          @@ -455,7 +455,7 @@

          Example: Converting timestamps, dates, or times, to milliseconds.

          // You can't summarize numbers and dates at the same time because your values must be of the same type (strings don't count). The option toMs converts timestamps, dates, and times to numbers (milliseconds).
          await tableA.summarize({ values: ["column1", "column2"], toMs: true })
          -

    zScore

    zScore

    • zScore(column, newColumn, options?): Promise<void>

    • Computes the Z-score.

      Parameters

      • column: string

        The name of the column for which Z-Score will be calculated.

      • newColumn: string

        The name of the new column where the bins will be stored.

      • options: {
            categories?: string | string[];
            decimals?: number;
        } = {}

        An optional object with configuration options:

        @@ -470,14 +470,15 @@

        Example: Rounding values

        // Calculates the Z-score for the values in column age with the column gender as categories and puts the results in column sigma. The score is rounded to two decimal places.
        await table.zScore("age", "sigma", { categories: "gender", decimals: 2 })
        -

    Exporting data

    writeData

    Exporting data

    writeData

    • writeData(file, options?): Promise<void>

    • Writes data to a file. If the path doesn't exist, it will be created.

      Parameters

      • file: string

        The path to the file to which data will be written.

        -
      • options: {
            compression?: boolean;
        } = {}

        An optional object with configuration options:

        +
      • options: {
            compression?: boolean;
            dataAsArrays?: boolean;
        } = {}

        An optional object with configuration options:

        • Optionalcompression?: boolean

          A boolean indicating whether to compress the output file. Defaults to false. If true, CSV and JSON files will be compressed with GZIP while PARQUET files will use ZSTD.

          +
        • OptionaldataAsArrays?: boolean

          A boolean for JSON files. If true, JSON files are written as one object with arrays instead of an array of objects. Convenient to reduce the size of JSON files for web projects. You can use the function arraysToData from the journalism library to bring back the data to its original state.

      Returns Promise<void>

      Example: Basic usage

      await table.writeData("output/data.csv");
      -

    writeGeoData

    • writeGeoData(file, options?): Promise<void>

    • Writes geospatial data to a file. If the path doesn't exist, it will be created.

      +

    writeGeoData

    • writeGeoData(file, options?): Promise<void>

    • Writes geospatial data to a file. If the path doesn't exist, it will be created.

      For .geojson files, if the projection is WGS84 or EPSG:4326 ([latitude, longitude] axis order), the coordinates will be flipped to follow the RFC7946 standard ([longitude, latitude] axis order).

      Parameters

      • file: string

        The path to the file to which data will be written.

      • options: {
            precision?: number;
        } = {}

        An optional object with configuration options:

        @@ -488,7 +489,7 @@

    Returns Promise<void>

    Example: Basic usage

    await table.writeGeoata("output/data.geojson");
    -

    Geospatial

    aggregateGeo

    Geospatial

    aggregateGeo

    • aggregateGeo(method, options?): Promise<SimpleTable>

    • Aggregates geometries.

      Parameters

      • method: "union" | "intersection"

        The method to use for the aggregation.

      • options: {
            categories?: string | string[];
            column?: string;
            outputTable?: string | boolean;
        } = {}

        An optional object with configuration options:

        • Optionalcategories?: string | string[]

          The column or columns that define categories for the aggragation. This can be a single column name or an array of column names.

          @@ -509,7 +510,7 @@

          Example: Returning results in a new table with a specific name in the DB

          // Same thing but results a return in tableA
          const tableA = await table.aggregateGeo("union", { categories: "country", outputTable: "tableA" })
          -

    area

    • area(newColumn, options?): Promise<void>

    • Computes the area of geometries in square meters or optionally square kilometers. The input geometry is assumed to be in the EPSG:4326 coordinate system (WGS84), with [latitude, longitude] axis order.

      +

    area

    • area(newColumn, options?): Promise<void>

    • Computes the area of geometries in square meters or optionally square kilometers. The input geometry is assumed to be in the EPSG:4326 coordinate system (WGS84), with [latitude, longitude] axis order.

      Parameters

      • newColumn: string

        The name of the new column storing the computed areas.

      • options: {
            column?: string;
            unit?: "m2" | "km2";
        } = {}

        An optional object with configuration options:

        • Optionalcolumn?: string

          The column storing geometries.

          @@ -523,7 +524,7 @@

          Example: Specific column storing geometries

          // If the table has more than one column storing geometries, you must specify which column should be used.
          await table.area("area", { column: "geom", unit: "km2" })
          -

    buffer

    buffer

    • buffer(newColumn, distance, options?): Promise<void>

    • Computes a buffer around geometries based on a specified distance. The distance is in the SRS unit.

      Parameters

      • newColumn: string

        The name of the new column to store the buffered geometries.

      • distance: number

        The distance for the buffer, in SRS unit.

      • options: {
            column?: string;
        } = {}

        An optional object with configuration options:

        @@ -534,7 +535,7 @@

        Example: Specific column storing geometries

        // If the table has more than one column storing geometries, you must specify which column should be used.
        await table.buffer("buffer", 1, { column: "geom" })
        -

    centroid

    centroid

    • centroid(newColumn, options?): Promise<void>

    • Computes the centroid of geometries. The values are returned in the SRS unit.

      Parameters

      • newColumn: string

        The name of the new column storing the centroids.

      • options: {
            column?: string;
        } = {}

        An optional object with configuration options:

        • Optionalcolumn?: string

          The column storing geometries.

          @@ -544,7 +545,7 @@

          Example: Specific column storing geometries

          // If the table has more than one column storing geometries, you must specify which column should be used.
          await table.centroid("centroid", { column: "geom" })
          -

    distance

    • distance(column1, column2, newColumn, options?): Promise<void>

    • Computes the distance between geometries. By default, it uses the SRS unit. You can pass "spheroid" or "haversine" as options.method to get results in meters or optionally kilometers. If you do use these methods, the input geometries must use the EPSG:4326 coordinate system (WGS84), with [latitude, longitude] axis order.

      +

    distance

    • distance(column1, column2, newColumn, options?): Promise<void>

    • Computes the distance between geometries. By default, it uses the SRS unit. You can pass "spheroid" or "haversine" as options.method to get results in meters or optionally kilometers. If you do use these methods, the input geometries must use the EPSG:4326 coordinate system (WGS84), with [latitude, longitude] axis order.

      Parameters

      • column1: string

        The name of a column storing geometries.

      • column2: string

        The name of a column storing geometries.

      • newColumn: string

        The name of the new column storing the centroids.

        @@ -564,7 +565,7 @@

        Example: Spheroid (meters and optionally kilometers)

        // Same but using an ellipsoidal model of the earth's surface. It's the most accurate but the slowest. By default, the distance is returned in meters and optionally as kilometers. The input geometries must use the EPSG:4326 coordinate system (WGS84), with [latitude, longitude] axis order.
        await table.distance("geomA", "geomB", "distance", { method: "spheroid", unit: "km" })
        -

    fixGeo

    fixGeo

    • fixGeo(column?): Promise<void>

    • Attempts to make an invalid geometry valid without removing any vertices.

      Parameters

      • Optionalcolumn: string

        The name of the column storing the geometries.

      Returns Promise<void>

      Example: Basic usage

      // By default, the method will look for the column storing the geometries.
      await table.fixGeo()
      @@ -572,12 +573,12 @@

      Example: Specific column storing geometries

      // If the table has more than one column storing geometries, you must specify which column should be used.
      await table.fixGeo("geom")
      -

    flipCoordinates

    • flipCoordinates(column?): Promise<void>

    • Flips the coordinates of geometries. To use as a last resort. This messes up with the projections stored in table.projection.

      +

    flipCoordinates

    • flipCoordinates(column?): Promise<void>

    • Flips the coordinates of geometries. To use as a last resort. This messes up with the projections stored in table.projection.

      Parameters

      • Optionalcolumn: string

        The name of the column storing the geometries.

      Returns Promise<void>

      Example: Basic usage

      // By default, the method will look for the column storing the geometries.
      await table.flipCoordinates()
      -

    getBoundingBox

    • getBoundingBox(column?): Promise<number[]>

    • Get the bounding box of geometries in [minLong, minLat, maxLong, maxLat] order. By default, the method will try find the column with the geometries, but can also specify one. The input geometry is assumed to be in the EPSG:4326 coordinate system (WGS84), with [latitude, longitude] axis order.

      +

    getBoundingBox

    • getBoundingBox(column?): Promise<number[]>

    • Get the bounding box of geometries in [minLong, minLat, maxLong, maxLat] order. By default, the method will try find the column with the geometries, but can also specify one. The input geometry is assumed to be in the EPSG:4326 coordinate system (WGS84), with [latitude, longitude] axis order.

      Parameters

      • Optionalcolumn: string

        The name of a column storing geometries.

      Returns Promise<number[]>

      Example: Basic usage

      const bbox = await table.getBoundingBox()
      @@ -585,7 +586,7 @@

      Example: Specific column storing geometries

      const bbox = await table.getBoundingBox("geometries")
      -

    getGeoData

    • getGeoData(column?): Promise<{
          features: {
              geometry: any;
              properties: {};
              type: string;
          }[];
          type: string;
      }>

    • Returns the data as a geojson. If the table has more than one column storing geometries, you must specify which column should be used. If the projection is WGS84 or EPSG:4326 ([latitude, longitude] axis order), the coordinates will be flipped to follow the RFC7946 standard ([longitude, latitude] axis order).

      +

    getGeoData

    • getGeoData(column?): Promise<{
          features: {
              geometry: any;
              properties: {};
              type: string;
          }[];
          type: string;
      }>

    • Returns the data as a geojson. If the table has more than one column storing geometries, you must specify which column should be used. If the projection is WGS84 or EPSG:4326 ([latitude, longitude] axis order), the coordinates will be flipped to follow the RFC7946 standard ([longitude, latitude] axis order).

      Parameters

      • Optionalcolumn: string

        The name of a column storing geometries.

      Returns Promise<{
          features: {
              geometry: any;
              properties: {};
              type: string;
          }[];
          type: string;
      }>

      Example: Basic usage

      // By default, the method will look for the column storing the geometries. The other columns in the table will be stored as properties.
      const geojson = await table.getGeoData()
      @@ -593,28 +594,28 @@

      Example: Specific geometry column

      // If the table has more than one column storing geometries, you must specify which column should be used. All the other columns in the table will be stored as properties.
      const geojson = await table.getGeoData("geometries")
      -

    inside

    inside

    • inside(column1, column2, newColumn): Promise<void>

    • Returns true if all points of a geometry lies inside another geometry.

      Parameters

      • column1: string

        The first column holds the geometries that will be tested for containment.

      • column2: string

        The second column stores the geometries to be tested as containers.

      • newColumn: string

        The name of the new column with true or false values.

      Returns Promise<void>

      Example: Basic usage

      // Checks if geometries in column geomA are inside geometries in column geomB and return true or false in new column isInside.
      await table.inside("geomA", "geomB", "isInside")
      -

    intersect

    intersect

    • intersect(column1, column2, newColumn): Promise<void>

    • Returns true if two geometries intersect.

      Parameters

      • column1: string

        The names of a column storing geometries.

      • column2: string

        The name of a column storing geometries.

      • newColumn: string

        The name of the new column with true or false values.

      Returns Promise<void>

      Example: Basic usage

      // Checks if geometries in geomA and in geomB intersect and return true or false in new column inter.
      await table.intersect("geomA", "geomB", "inter")
      -

    intersection

    intersection

    • intersection(column1, column2, newColumn): Promise<void>

    • Computes the intersection of geometries.

      Parameters

      • column1: string

        The names of a column storing geometries.

      • column2: string

        The name of a column storing geometries.

      • newColumn: string

        The name of the new column storing the computed intersections.

      Returns Promise<void>

      Example: Basic usage

      // Computes the intersection of geometries in geomA and geomB columns and puts the new geometries in column inter.
      await table.intersection("geomA", "geomB", "inter")
      -

    isClosedGeo

    isClosedGeo

    • isClosedGeo(newColumn, options?): Promise<void>

    • Adds a column with TRUE if the geometry is closed and FALSE if it's open.

      Parameters

      • newColumn: string

        The name of the new column storing the results.

      • options: {
            column?: string;
        } = {}

        An optional object with configuration options:

        • Optionalcolumn?: string

          The column storing geometries.

          @@ -624,7 +625,7 @@

          Example: Specific column storing geometries

          // If the table has more than one column storing geometries, you must specify which column should be used.
          await table.isClosedGeo("closed", { column: "geom" })
          -

    isValidGeo

    isValidGeo

    • isValidGeo(newColumn, options?): Promise<void>

    • Adds a column with TRUE/FALSE values depending on the validity of geometries.

      Parameters

      • newColumn: string

        The name of the new column storing the results.

      • options: {
            column?: string;
        } = {}

        An optional object with configuration options:

        • Optionalcolumn?: string

          The column storing geometries.

          @@ -634,7 +635,7 @@

          Example: Specific column storing geometries

          // If the table has more than one column storing geometries, you must specify which column should be used.
          await table.isValidGeo("valid", { column: "geom" })
          -

    joinGeo

    joinGeo

    • joinGeo(rightTable, method, options?): Promise<SimpleWebTable>

    • Merges the data of the table with another table based on a spatial join. Note that the returned data is not guaranteed to be in the same order as the original tables.

      By default, the method looks for a column storing the geometries in each table, does a left join and overwrites leftTable (the current table) with the results. The method also appends the name of the table to the columns storing the geometries if they have the same name in both tables.

      It might create a .tmp folder, so make sure to add .tmp to your gitignore.

      Parameters

      • rightTable: SimpleTable

        The right table to be joined.

        @@ -652,14 +653,14 @@

        Example: With options

        // Same thing but with specific column names storing geometries, a specific join type, and returning the results in a new table.
        const tableC = await tableA.joinGeo(tableB, "intersect", { leftTableColumn: "geometriesA", rightTableColumn: "geometriesB", type: "inner", outputTable: true })
        -

    latLon

    • latLon(column, columnLat, columnLon): Promise<void>

    • Extracts the latitude and longitude of points. The input geometry is assumed to be in the EPSG:4326 coordinate system (WGS84), with [latitude, longitude] axis order.

      +

    latLon

    • latLon(column, columnLat, columnLon): Promise<void>

    • Extracts the latitude and longitude of points. The input geometry is assumed to be in the EPSG:4326 coordinate system (WGS84), with [latitude, longitude] axis order.

      Parameters

      • column: string

        The name of the table storing the points.

      • columnLat: string

        The name of the column storing the extracted latitude.

      • columnLon: string

        The name of the column storing the extracted longitude.

      Returns Promise<void>

      Example: Basic usage

      // Extracts the latitude and longitude of points from the points in the "geom" column and put them in the columns "lat" and "lon".
      await table.latLon("geom", "lat", "lon")
      -

    length

    • length(newColumn, options?): Promise<void>

    • Computes the length of line geometries in meters or optionally kilometers. The input geometry is assumed to be in the EPSG:4326 coordinate system (WGS84), with [latitude, longitude] axis order.

      +

    length

    • length(newColumn, options?): Promise<void>

    • Computes the length of line geometries in meters or optionally kilometers. The input geometry is assumed to be in the EPSG:4326 coordinate system (WGS84), with [latitude, longitude] axis order.

      Parameters

      • newColumn: string

        The name of the new column storing the computed lengths.

      • options: {
            column?: string;
            unit?: "m" | "km";
        } = {}

        An optional object with configuration options:

        • Optionalcolumn?: string

          The column storing geometries.

          @@ -673,7 +674,7 @@

          Example: Specific column storing geometries

          // If the table has more than one column storing geometries, you must specify which column should be used.
          await table.length("length", { column: "geom", unit: "km" })
          -

    linesToPolygons

    linesToPolygons

    • linesToPolygons(column?): Promise<void>

    • Transforms closed lines into polygons.

      Parameters

      • Optionalcolumn: string

        The name of a column storing geometries.

      Returns Promise<void>

      Example: Basic usage

      // Transforms geometries into polygons.
      // By default, the method will look for the column storing the geometries.
      await table.linesToPolygons()
      @@ -681,7 +682,7 @@

      Example: Specific column storing geometries

      // If the table has more than one column storing geometries, you must specify which column should be used.
      await table.linesToPolygons("geom")
      -

    loadGeoData

    loadGeoData

    • loadGeoData(file, options?): Promise<SimpleTable>

    • Loads geospatial data from an external file. The coordinates of files or urls ending with .json or .geojson are automatically flipped to [latitude, longitude] axis order.

      Parameters

      • file: string

        The URL or path to the external file containing the geospatial data.

      • options: {
            from?: string;
            toWGS84?: boolean;
        } = {}

        An optional object with configuration options:

        • Optionalfrom?: string

          An option to pass the original projections, if the method is not able to find it.

          @@ -695,7 +696,7 @@

          Example: Reprojecting to WGS84 with [latitude, longitude] axis order

          await table.loadGeoData("./some-data.geojson", { toWGS84: true })
          -

    nbVertices

    • nbVertices(newColumn, options?): Promise<void>

    • Adds a column with the number of vertices in geometries.

      +

    nbVertices

    • nbVertices(newColumn, options?): Promise<void>

    • Adds a column with the number of vertices in geometries.

      Parameters

      • newColumn: string

        The name of the new column storing the results.

      • options: {
            column?: string;
        } = {}

        An optional object with configuration options:

        • Optionalcolumn?: string

          The column storing geometries.

          @@ -705,7 +706,7 @@

          Example: Specific column storing geometries

          // If the table has more than one column storing geometries, you must specify which column should be used.
          await table.nbVertices("nbVertices", { column: "geom" })
          -

    perimeter

    • perimeter(newColumn, options?): Promise<void>

    • Computes the perimeter of polygon geometries in meters or optionally kilometers. The input geometry is assumed to be in the EPSG:4326 coordinate system (WGS84), with [latitude, longitude] axis order.

      +

    perimeter

    • perimeter(newColumn, options?): Promise<void>

    • Computes the perimeter of polygon geometries in meters or optionally kilometers. The input geometry is assumed to be in the EPSG:4326 coordinate system (WGS84), with [latitude, longitude] axis order.

      Parameters

      • newColumn: string

        The name of the new column storing the computed perimeters.

      • options: {
            column?: string;
            unit?: "m" | "km";
        } = {}

        An optional object with configuration options:

        • Optionalcolumn?: string

          The column storing geometries.

          @@ -719,14 +720,14 @@

          Example: Specific column storing geometries

          // If the table has more than one column storing geometries, you must specify which column should be used.
          await table.perimeter("perim", { unit: "km" })
          -

    points

    points

    • points(columnLat, columnLon, newColumn): Promise<void>

    • Creates point geometries from longitude a latitude columns. The geometries will have [latitude, longitude] axis order.

      Parameters

      • columnLat: string

        The name of the column storing the latitude.

      • columnLon: string

        The name of the column storing the longitude.

      • newColumn: string

        The name of the new column storing the point geometries.

      Returns Promise<void>

      Example: Basic usage

      // Uses the columns "lat" and "lon" to create point geometries in column "geom"
      await table.points("lat", "lon", "geom")
      -

    reducePrecision

    reducePrecision

    • reducePrecision(decimals, options?): Promise<void>

    • Reduce the precision of geometries.

      Parameters

      • decimals: number

        The number of decimal places to keep in the coordinates.

      • options: {
            column?: string;
        } = {}

        An optional object with configuration options:

        • Optionalcolumn?: string

          The column storing geometries.

          @@ -736,14 +737,14 @@

          Example: Specific column storing geometries

          // If the table has more than one column storing geometries, you must specify which column should be used.
          await table.reducePrecision(3, { column : "geom" })
          -

    removeIntersection

    removeIntersection

    • removeIntersection(column1, column2, newColumn): Promise<void>

    • Removes the intersection of two geometries.

      Parameters

      • column1: string

        The names of a column storing geometries. These are the reference geometries that will be returned without the intersection.

      • column2: string

        The name of a column storing geometries. These are the geometries used to compute the intersection.

      • newColumn: string

        The name of the new column storing the new geometries.

      Returns Promise<void>

      Example: Basic usage

      // Removes the intersection of geomA and geomB from geomA and returns the results in the new column noIntersection. The column order is important.
      await table.removeIntersection("geomA", "geomB", "noIntersection")
      -

    reproject

    reproject

    • reproject(to, options?): Promise<void>

    • Reprojects the data to another Spatial Reference System (SRS). If you reproject to WGS84 or EPSG:4326, the result will have [latitude, longitude] axis order.

      Parameters

      • to: string

        The target SRS.

      • options: {
            column?: string;
            from?: string;
        } = {}

        An optional object with configuration options:

        • Optionalcolumn?: string

          The column storing geometries.

          @@ -757,7 +758,7 @@

          Example: Specifying the geometries column

          // If the table has more than one column storing geometries, you must specify which column should be used.
          await table.reproject("EPSG:3347", { column: "geom", from: "EPSG:4326" })
          -

    simplify

    • simplify(tolerance, options?): Promise<void>

    • Simplifies the geometries while preserving their topology. The simplification occurs on an object-by-object basis. A higher tolerance results in a more significant simplification.

      +

    simplify

    • simplify(tolerance, options?): Promise<void>

    • Simplifies the geometries while preserving their topology. The simplification occurs on an object-by-object basis. A higher tolerance results in a more significant simplification.

      Parameters

      • tolerance: number

        A number used for the simplification. A higher tolerance results in a more significant simplification.

      • options: {
            column?: string;
        } = {}

        An optional object with configuration options:

        • Optionalcolumn?: string

          The column storing geometries.

          @@ -767,7 +768,7 @@

          Example: Specific column storing geometries

          // If the table has more than one column storing geometries, you must specify which column should be used.
          await table.simplify(0.1, { column: "geom" })
          -

    typeGeo

    typeGeo

    • typeGeo(newColumn, options?): Promise<void>

    • Adds a column with the geometry type.

      Parameters

      • newColumn: string

        The name of the new column storing the results.

      • options: {
            column?: string;
        } = {}

        An optional object with configuration options:

        • Optionalcolumn?: string

          The column storing geometries.

          @@ -777,14 +778,14 @@

          Example: Specific column storing geometries

          // If the table has more than one column storing geometries, you must specify which column should be used.
          await table.typeGeo("type", { column: "geom" })
          -

    union

    union

    • union(column1, column2, newColumn): Promise<void>

    • Computes the union of geometries.

      Parameters

      • column1: string

        The names of a column storing geometries.

      • column2: string

        The name of a column storing geometries.

      • newColumn: string

        The name of the new column storing the computed unions.

      Returns Promise<void>

      Example: Basic usage

      // Computes the union of geometries in geomA and geomB columns and puts the new geometries in column union.
      await tabele.union("geomA", "geomB", "union")
      -

    unnestGeo

    unnestGeo

    • unnestGeo(column?): Promise<void>

    • Unnests geometries recursively.

      Parameters

      • Optionalcolumn: string

        The name of a column storing geometries.

      Returns Promise<void>

      Example: Basic usage

      // Unnests geometries in the column "geom" and returns the same table with unnested items.
      // By default, the method will look for the column storing the geometries.
      await table.unnestGeo()
      @@ -792,7 +793,7 @@

      Example: Specific column storing geometries

      // If the table has more than one column storing geometries, you must specify which column should be used.
      await table.unnestGeo("geom")
      -

    Getting data

    getBottom

    • getBottom(count, options?): Promise<{
          [key: string]:
              | string
              | number
              | boolean
              | Date
              | null;
      }[]>

    • Returns the bottom n rows, optionally with a condition written as a SQL expression. The last row will be returned first. To keep the original order of the data, use the originalOrder option.

      +

    Getting data

    getBottom

    • getBottom(count, options?): Promise<{
          [key: string]:
              | string
              | number
              | boolean
              | Date
              | null;
      }[]>

    • Returns the bottom n rows, optionally with a condition written as a SQL expression. The last row will be returned first. To keep the original order of the data, use the originalOrder option.

      Parameters

      • count: number

        The number of rows to return.

      • options: {
            condition?: string;
            originalOrder?: boolean;
        } = {}

        An optional object with configuration options:

        • Optionalcondition?: string

          The filtering conditions specified as a SQL WHERE clause. Defaults to no condition.

          @@ -806,7 +807,7 @@

          Example: With a condition

          // Returns the last 10 rows with category being 'Books'.
          const bottom10Books = await table.getBottom(10, { condition: `category = 'Books'` })
          -

    getData

    • getData(options?): Promise<{
          [key: string]:
              | string
              | number
              | boolean
              | Date
              | null;
      }[]>

    • Returns the data with an optional condition.

      +

    getData

    • getData(options?): Promise<{
          [key: string]:
              | string
              | number
              | boolean
              | Date
              | null;
      }[]>

    • Returns the data with an optional condition.

      Parameters

      • options: {
            condition?: string;
        } = {}

        An optional object with configuration options:

        • Optionalcondition?: string

          A SQL WHERE clause condition to filter the data. Defaults to no condition.

      Returns Promise<{
          [key: string]:
              | string
              | number
              | boolean
              | Date
              | null;
      }[]>

      Example: Basic usage

      // Returns all data.
      const data = await table.getData()
@@ -815,12 +816,12 @@ 
      Example: With condition
      // Returns just the rows with a category 'Book'. Conditions are SQL expressions.
      const books = await table.getData({ condition: `category = 'Book'` })
 
      
 
-

    getExtent

    • getExtent(column): Promise<[
          | null
          | string
          | number
          | boolean
          | Date,
          | null
          | string
          | number
          | boolean
          | Date]>

    • Returns the extent from specific column as an array with [min, max] order.

      +

    getExtent

    • getExtent(column): Promise<[
          | null
          | string
          | number
          | boolean
          | Date,
          | null
          | string
          | number
          | boolean
          | Date]>

    • Returns the extent from specific column as an array with [min, max] order.

      const extent = await table.getExtent("column1")

      Parameters

      • column: string

        The name of the column.

        -

      Returns Promise<[
          | null
          | string
          | number
          | boolean
          | Date,
          | null
          | string
          | number
          | boolean
          | Date]>

    getFirstRow

    • getFirstRow(options?): Promise<{
          [key: string]:
              | string
              | number
              | boolean
              | Date
              | null;
      }>

    • Returns the first row with optional filtering conditions written as an SQL expression.

      +

    Returns Promise<[
        | null
        | string
        | number
        | boolean
        | Date,
        | null
        | string
        | number
        | boolean
        | Date]>

    getFirstRow

    • getFirstRow(options?): Promise<{
          [key: string]:
              | string
              | number
              | boolean
              | Date
              | null;
      }>

    • Returns the first row with optional filtering conditions written as an SQL expression.

      Parameters

      • options: {
            condition?: string;
        } = {}

        An optional object with configuration options:

        • Optionalcondition?: string

          The filtering conditions specified as a SQL WHERE clause. Defaults to no condition.

      Returns Promise<{
          [key: string]:
              | string
              | number
              | boolean
              | Date
              | null;
      }>

      Example: Basic usage

      // Returns the first row
      const firstRow = await table.getFirstRow()
@@ -829,7 +830,7 @@ 
      <
 
      Example: With condition
      // Returns the first row with category being 'Book'.
      const firstRowBooks = await table.getFirstRow({ condition: `category = 'Book'` })
 
      
 
-

    getLastRow

    • getLastRow(options?): Promise<{
          [key: string]:
              | string
              | number
              | boolean
              | Date
              | null;
      }>

    • Returns the last row with optional filtering conditions written as an SQL expression.

      +

    getLastRow

    • getLastRow(options?): Promise<{
          [key: string]:
              | string
              | number
              | boolean
              | Date
              | null;
      }>

    • Returns the last row with optional filtering conditions written as an SQL expression.

      Parameters

      • options: {
            condition?: string;
        } = {}

        An optional object with configuration options:

        • Optionalcondition?: string

          The filtering conditions specified as a SQL WHERE clause. Defaults to no condition.

      Returns Promise<{
          [key: string]:
              | string
              | number
              | boolean
              | Date
              | null;
      }>

      Example: Basic usage

      // Returns the last row.
      const lastRow = await table.getLastRow()
@@ -838,12 +839,12 @@ 
      Example: With condition
      // Returns the last row of all rows having a category 'Book'.
      const lastRowBooks = await table.getLastRow({ condition: `category = 'Book'` })
 
      
 
-

    getMax

    getMax

    • getMax(column): Promise<
          | null
          | string
          | number
          | boolean
          | Date>

    • Returns the maximum value from a specific column.

      const maximum = await table.getMax("column1")

      Parameters

      • column: string

        The name of the column.

        -

      Returns Promise<
          | null
          | string
          | number
          | boolean
          | Date>

    getMean

    • getMean(column, options?): Promise<number>

    • Returns the mean value from a specific column.

      +

    Returns Promise<
        | null
        | string
        | number
        | boolean
        | Date>

    getMean

    • getMean(column, options?): Promise<number>

    • Returns the mean value from a specific column.

      Parameters

      • column: string

        The name of the column.

      • options: {
            decimals?: number;
        } = {}

        An optional object with configuration options:

        • Optionaldecimals?: number

          The number of decimal places to round the result to.

          @@ -853,7 +854,7 @@

          Example: Rounding result

          // Same thing but rounding to two decimal places.
          const mean = await table.getMean("column1", { decimals: 2 })
          -

    getMedian

    getMedian

    • getMedian(column, options?): Promise<number>

    • Returns the median value from a specific column.

      Parameters

      • column: string

        The name of the column.

      • options: {
            decimals?: number;
        } = {}

        An optional object with configuration options:

        • Optionaldecimals?: number

          The number of decimal places to round the result to.

          @@ -863,12 +864,12 @@

          Example: Rounding results

          // Same thing but rounding to two decimal places.
          const median = await table.getMedian("column1", { decimals: 2})
          -

    getMin

    getMin

    • getMin(column): Promise<
          | null
          | string
          | number
          | boolean
          | Date>

    • Returns the minimum value from a specific column.

      Parameters

      • column: string

        The name of the column.

      Returns Promise<
          | null
          | string
          | number
          | boolean
          | Date>

      Example: Basic usage

      const minimum = await table.getMin("column1")
      -

    getQuantile

    getQuantile

    • getQuantile(column, quantile, options?): Promise<number>

    • Returns the value of a specific quantile from the values in a given column.

      Parameters

      • column: string

        The name of the column from which to calculate the quantile.

      • quantile: number

        The quantile (between 0 and 1) to calculate. For example, 0.25 for the first quartile.

      • options: {
            decimals?: number;
        } = {}

        An optional object with configuration options:

        @@ -879,7 +880,7 @@

        Example: Rounding result

        // Same thing but rounding to two decimal places.
        const firstQuartile = await table.getQuantile("column1", 0.25, { decimals: 2 })
        -

    getSkew

    getSkew

    • getSkew(column, options?): Promise<number>

    • Returns the skewness of values from a specific column.

      Parameters

      • column: string

        The name of the column.

      • options: {
            decimals?: number;
        } = {}

        An optional object with configuration options:

        • Optionaldecimals?: number

          The number of decimal places to round the result to.

          @@ -889,7 +890,7 @@

          Example: Rounding result

          // Same thing but rounding to two decimal places.
          const skew = await table.getSkew("column1", { decimals: 2})
          -

    getStdDev

    getStdDev

    • getStdDev(column, options?): Promise<number>

    • Returns the standard deviation of values from a specific column.

      Parameters

      • column: string

        The name of the column.

      • options: {
            decimals?: number;
        } = {}

        An optional object with configuration options:

        • Optionaldecimals?: number

          The number of decimal places to round the result to.

          @@ -899,12 +900,12 @@

          Example: Rounding result

          // Same thing but rounding to two decimal places.
          const standardDeviation = await table.getStdDev("column1", { decimals: 2 })
          -

    getSum

    getSum

    • getSum(column): Promise<number>

    • Returns the sum of values from a specific column.

      Parameters

      • column: string

        The name of the column.

      Returns Promise<number>

      Example: Basic usage

      const sum = await table.getSum("column1")
      -

    getTop

    • getTop(count, options?): Promise<{
          [key: string]:
              | string
              | number
              | boolean
              | Date
              | null;
      }[]>

    • Returns the top n rows, optionally with a condition written as an SQL expression.

      +

    getTop

    • getTop(count, options?): Promise<{
          [key: string]:
              | string
              | number
              | boolean
              | Date
              | null;
      }[]>

    • Returns the top n rows, optionally with a condition written as an SQL expression.

      Parameters

      • count: number

        The number of rows to return.

      • options: {
            condition?: string;
        } = {}

        An optional object with configuration options:

        • Optionalcondition?: string

          The filtering conditions specified as a SQL WHERE clause. Defaults to no condition.

          @@ -914,17 +915,17 @@

          Example: With a condition

          // Returns the first 10 rows with category being 'Books'.
          const top10Books = await table.getTop(10, { condition: `category = 'Books'` })
          -

    getUniques

    • getUniques(column): Promise<(
          | null
          | string
          | number
          | boolean
          | Date)[]>

    • Returns unique values from a specific column. For convenience, it returns the value ascendingly.

      +

    getUniques

    • getUniques(column): Promise<(
          | null
          | string
          | number
          | boolean
          | Date)[]>

    • Returns unique values from a specific column. For convenience, it returns the value ascendingly.

      Parameters

      • column: string

        The name of the column from which to retrieve unique values.

      Returns Promise<(
          | null
          | string
          | number
          | boolean
          | Date)[]>

      Example: Basic usage

      const uniques = await table.getUniques("column1")
      -

    getValues

    getValues

    • getValues(column): Promise<(
          | null
          | string
          | number
          | boolean
          | Date)[]>

    • Returns the values of a specific column.

      Parameters

      • column: string

        The name of the column.

      Returns Promise<(
          | null
          | string
          | number
          | boolean
          | Date)[]>

      Example: Basic usage

      const values = await table.getValues("column1")
      -

    getVar

    getVar

    • getVar(column, options?): Promise<number>

    • Returns the variance of values from a specific column.

      Parameters

      • column: string

        The name of the column.

      • options: {
            decimals?: number;
        } = {}

        An optional object with configuration options:

        • Optionaldecimals?: number

          The number of decimal places to round the result to.

          @@ -934,14 +935,14 @@

          Example: Rounding result

          // Same thing but rounding to two decimal places
          const variance = await table.getVar("column1")
          -

    Importing data

    fetchData

    fetchGeoData

    insertRows

    Importing data

    fetchData

    fetchGeoData

    insertRows

    • insertRows(rows): Promise<void>

    • Inserts rows formatted as an array of objects into the table.

      Parameters

      • rows: {
            [key: string]: unknown;
        }[]

        An array of objects representing the rows to be inserted into the table.

      Returns Promise<void>

      Example: Basic usage

      const rows = [{ letter: "a", number: 1 }, { letter: "b", number: 2 }]
      await table.insertRows(rows)
      -

    insertTables

    insertTables

    • insertTables(tablesToInsert): Promise<void>

    • Inserts all rows from another table (or multiple tables) into this table.

      Parameters

      Returns Promise<void>

      Example: Basic usage with one table

      // Insert all rows from tableB into this table.
      await tableA.insertTables("tableB")
      @@ -949,12 +950,12 @@

      Example: With multiple tables

      // Insert all rows from tableB and tableC into this table.
      await tableA.insertTables([ "tableB", "tableC" ])
      -

    loadArray

    loadArray

    • loadArray(arrayOfObjects): Promise<SimpleTable>

    • Loads an array of objects into the table.

      Parameters

      • arrayOfObjects: {
            [key: string]: unknown;
        }[]

        An array of objects representing the data.

      Returns Promise<SimpleTable>

      Example: Basic usage

      const data = [{ letter: "a", number: 1 }, { letter: "b", number: 2 }]
      await table.loadArray(data)
      -

    loadData

    loadData

    • loadData(files, options?): Promise<SimpleTable>

    • Loads data from local or remote file(s) into it. CSV, JSON and PARQUET files are accepted.

      Parameters

      • files: string | string[]

        The path(s) or url(s) of file(s) containing the data to be loaded. CSV, JSON, and PARQUET files are accepted.

      • options: {
            allText?: boolean;
            autoDetect?: boolean;
            columnTypes?: {
                [key: string]: string;
            };
            compression?: "none" | "gzip" | "zstd";
            delim?: string;
            fileName?: boolean;
            fileType?:
                | "csv"
                | "dsv"
                | "json"
                | "parquet"
                | "excel";
            header?: boolean;
            ignoreErrors?: boolean;
            jsonFormat?: "unstructured" | "newlineDelimited" | "array";
            limit?: number;
            nullPadding?: boolean;
            records?: boolean;
            sheet?: string;
            skip?: number;
            unifyColumns?: boolean;
        } = {}

        An optional object with configuration options:

        • OptionalallText?: boolean

          A boolean indicating whether all columns should be treated as text. Applicable to CSV files. Defaults to false.

          @@ -979,7 +980,7 @@

          Example: Multiple files

          // Load data from multiple local files.
          await table.loadData([ "./some-data1.json", "./some-data2.json", "./some-data3.json" ])

          // Load data from multiple remote files
          await table.loadData([ "https://some-website.com/some-data1.parquet", "https://some-website.com/some-data2.parquet", "https://some-website.com/some-data3.parquet" ])
          -

    loadDataFromDirectory

    • loadDataFromDirectory(directory, options?): Promise<SimpleTable>

    • Loads data from all files in a local directory. CSV, JSON, and PARQUET files are accepted.

      +

    loadDataFromDirectory

    • loadDataFromDirectory(directory, options?): Promise<SimpleTable>

    • Loads data from all files in a local directory. CSV, JSON, and PARQUET files are accepted.

      Parameters

      • directory: string

        The path of the directory containing the data files to be loaded. CSV, JSON, and PARQUET files are accepted.

      • options: {
            allText?: boolean;
            autoDetect?: boolean;
            columnTypes?: {
                [key: string]: string;
            };
            compression?: "none" | "gzip" | "zstd";
            delim?: string;
            fileName?: boolean;
            fileType?:
                | "csv"
                | "dsv"
                | "json"
                | "parquet"
                | "excel";
            header?: boolean;
            ignoreErrors?: boolean;
            jsonFormat?: "unstructured" | "newlineDelimited" | "array";
            limit?: number;
            nullPadding?: boolean;
            records?: boolean;
            sheet?: string;
            skip?: number;
            unifyColumns?: boolean;
        } = {}

        An optional object with configuration options:

        • OptionalallText?: boolean

          A boolean indicating whether all columns should be treated as text. Applicable to CSV files. Defaults to false.

          @@ -1001,7 +1002,7 @@

          <

      Returns Promise<SimpleTable>

      Example: Basic usage

      await table.loadDataFromDirectory("./data/")
      -

    Restructuring data

    addColumn

    • addColumn(newColumn, type, definition, options?): Promise<void>

    • Adds a new column based on a type (JavaScript or SQL types) and a SQL definition.

      +

    Restructuring data

    addColumn

    addRowNumber

    addRowNumber

    • addRowNumber(newColumn): Promise<void>

    • Adds a new column with the row number.

      Parameters

      • newColumn: string

        The name of the new column storing the row number

      Returns Promise<void>

      Example: Basic usage

      // Adds the row number in new column rowNumber.
      await table.addRowNumber("rowNumber")
      -

    cleanColumnNames

    cleanColumnNames

    • cleanColumnNames(): Promise<void>

    • Cleans column names by removing non-alphanumeric characters and formats them to camel case.

      Returns Promise<void>

      Example: Basic usage

      await table.cleanColumnNames()
      -

    cloneColumn

    cloneColumn

    • cloneColumn(originalColumn, newColumn): Promise<void>

    • Clones a column in this table.

      Parameters

      • originalColumn: string

        The original column.

      • newColumn: string

        The name of the cloned column.

      Returns Promise<void>

      Example: Basic usage

      // Clones column1 as column2
      await table.cloneColumn("column1", "column2")
      -

    cloneColumnWithOffset

    cloneColumnWithOffset

    • cloneColumnWithOffset(originalColumn, newColumn): Promise<void>

    • Clones a column in the table and offsets the values down by one row. The last row will have a NULL value.

      Parameters

      • originalColumn: string

        The original column.

      • newColumn: string

        The name of the cloned column.

      Returns Promise<void>

      Example: Basic usage

      // Clones column1 as column2 and offsets values by 1. So value of column1-row1 will be in column2-row2, column1-row2 will be in column2-row3, etc.
      await table.cloneColumnWithOffset("column1", "column2")
      -

    convert

    convert

    • convert(types, options?): Promise<void>

    • Converts data types (JavaScript or SQL types) of specified columns.

      If you convert timestamps, dates, or times to strings, you need to pass format specifiers as datetimeFormat option. Same to convert strings to timestamps, dates or times.

      If you convert timestamps, dates, or times to numbers, the result will be the number of milliseconds since 1970-01-01 00:00:00. If you convert numbers to timestamps, dates, or times, the same logic applies.

      If you convert strings to numbers, commas (which are often used as thousand separators) will be removed before converting.

      @@ -1052,7 +1053,7 @@

      <

      Example: With dates

      // Converts strings in a specific format to dates
      await table.convert({ column3: "datetime"}, { datetimeFormat: "%Y-%m-%d" })

      // Converts dates to strings with a specific format.
      await table.convert({ column3: "datetime" }, { datetimeFormat: "%Y-%m-%d" })
      -

    crossJoin

    • crossJoin(rightTable, options?): Promise<SimpleTable>

    • Performs a cross join operation between this table and another table, returning all pairs of rows. This table is considered the left table. Note that the returned rows are not guaranteed to be in the same order. It might create a .tmp folder, so make sure to add .tmp to your gitignore.

      +

    crossJoin

    • crossJoin(rightTable, options?): Promise<SimpleTable>

    • Performs a cross join operation between this table and another table, returning all pairs of rows. This table is considered the left table. Note that the returned rows are not guaranteed to be in the same order. It might create a .tmp folder, so make sure to add .tmp to your gitignore.

      Parameters

      • rightTable: SimpleTable

        The right table.

      • options: {
            outputTable?: string | boolean;
        } = {}

        An optional object with configuration options:

        • OptionaloutputTable?: string | boolean

          To return a new table with the results.

          @@ -1065,7 +1066,7 @@

          Example: Results in a new table with a specific name in the DB

          // Returns the resuts in a newTable
          const tableC = await tableA.crossJoin(tableB, { outputTable: "tableC" });
          -

    join

    • join(rightTable, options?): Promise<SimpleWebTable>

    • Merges the data of this table with another table based on a common column. This table is considered the left table. Note that the returned data is not guaranteed to be in the same order as the original tables. It might create a .tmp folder, so make sure to add .tmp to your gitignore.

      +

    join

    • join(rightTable, options?): Promise<SimpleWebTable>

    • Merges the data of this table with another table based on a common column. This table is considered the left table. Note that the returned data is not guaranteed to be in the same order as the original tables. It might create a .tmp folder, so make sure to add .tmp to your gitignore.

      Parameters

      • rightTable: SimpleTable

        The right table to be joined.

      • options: {
            commonColumn?: string;
            outputTable?: string | boolean;
            type?:
                | "inner"
                | "left"
                | "right"
                | "full";
        } = {}

        An optional object with configuration options:

        • OptionalcommonColumn?: string

          The common column used for the join operation. By default, the method automatically searches for a column name that exists in both tables.

          @@ -1077,7 +1078,7 @@

          Example: With options

          // You can change the common column, the join type, and the output table in options.
          const tableC = await tableA.join("tableB", { commonColumn: 'id', type: 'inner', outputTable: true })
          -

    longer

    longer

    • longer(columns, columnsTo, valuesTo): Promise<void>

    • Restructures this table by stacking values. Useful to tidy up data.

      As an example, let's use this table. It shows the number of employees per year in different departments.

    @@ -1152,26 +1153,26 @@

    <

    -

removeColumns

removeColumns

  • removeColumns(columns): Promise<void>

  • Removes one or more columns from this table.

    Parameters

    • columns: string | string[]

      The name or an array of names of the columns to be removed.

    Returns Promise<void>

    Example: Basic usage

    await table.removeColumns(["column1", "column2"])
    -

removeTable

removeTable

  • removeTable(): Promise<void>

  • Remove the table from the database. Invoking methods on this table will throw and error.

    Returns Promise<void>

    Example: Basic usage

    await table.removeTable()
    -

renameColumns

renameColumns

  • renameColumns(names): Promise<void>

  • Renames columns in the table.

    Parameters

    • names: {
          [key: string]: string;
      }

      An object mapping old column names to new column names.

      • [key: string]: string

    Returns Promise<void>

    Example: Basic usage

    // Renaming "How old?" to "age" and "Man or woman?" to "sex".
    await table.renameColumns({ "How old?" : "age", "Man or woman?": "sex" })
    -

selectColumns

selectColumns

  • selectColumns(columns): Promise<void>

  • Selects specific columns in the table and removes the others.

    Parameters

    • columns: string | string[]

      Either a string (one column) or an array of strings (multiple columns) representing the columns to be selected.

    Returns Promise<void>

    Example: Basic usage

    // Selecting only the columns firstName and lastName. All other columns in the table will be removed.
    await table.selectColumns([ "firstName", "lastName" ])
    -

sort

sort

  • sort(order, options?): Promise<void>

  • Sorts the rows based on specified column(s) and order(s).

    Parameters

    • order: {
          [key: string]: "asc" | "desc";
      }

      An object mapping column names to the sorting order: "asc" for ascending or "desc" for descending.

      • [key: string]: "asc" | "desc"
    • options: {
          lang?: {
              [key: string]: string;
          };
      } = {}

      An optional object with configuration options:

wider

wider

Selecting or filtering data

filter

Selecting or filtering data

filter

  • filter(conditions): Promise<void>

  • Filters rows from this table based on SQL conditions. Note that it's often faster to use the removeRows method.

    Parameters

    • conditions: string

      The filtering conditions specified as a SQL WHERE clause.

    Returns Promise<void>

    Example: Basic usage

    // Keeps only rows where the fruit is not an apple.
    await table.filter(`fruit != 'apple'`)
    @@ -1266,23 +1267,23 @@

    Example: More examples

    await table.filter(`price > 100 AND quantity > 0`)
    await table.filter(`category = 'Electronics' OR category = 'Appliances'`)
    await table.filter(`lastPurchaseDate >= '2023-01-01'`)
    -

keep

keep

  • keep(columnsAndValues): Promise<void>

  • Keeps rows with specific values in specific columns.

    Parameters

    • columnsAndValues: {
          [key: string]: unknown[];
      }

      An object with the columns (keys) and the values to be kept (values as arrays)

      • [key: string]: unknown[]

    Returns Promise<void>

    Example: Basic usage

    // Keeps only rows where the job is 'accountant' or 'developer' and where the city is 'Montreal'.
    await table.keep({ job: ["accountant", "developer"], city: ["Montreal"] })
    -

remove

remove

  • remove(columnsAndValues): Promise<void>

  • Remove rows with specific values in specific columns.

    Parameters

    • columnsAndValues: {
          [key: string]: unknown[];
      }

      An object with the columns (keys) and the values to be removed (values as arrays)

      • [key: string]: unknown[]

    Returns Promise<void>

    Example: Basic usage

    // Remove rows where the job is 'accountant' or 'developer' and where the city is 'Montreal'.
    await table.remove({ job: ["accountant", "developer"], city: ["Montreal"] })
    -

removeDuplicates

  • removeDuplicates(options?): Promise<void>

  • Removes duplicate rows from this table, keeping unique rows. Note that SQL does not guarantee any specific order when using DISTINCT. So the data might be returned in a different order than the original.

    +

removeDuplicates

  • removeDuplicates(options?): Promise<void>

  • Removes duplicate rows from this table, keeping unique rows. Note that SQL does not guarantee any specific order when using DISTINCT. So the data might be returned in a different order than the original.

    Parameters

    • options: {
          on?: string | string[];
      } = {}

      An optional object with configuration options:

      • Optionalon?: string | string[]

        A column or multiple columns to consider to remove duplicates. The other columns in the table will not be considered to exclude duplicates.

    Returns Promise<void>

    Example: Basic usage

    await table.removeDuplicates("tableA")
    -

removeMissing

  • removeMissing(options?): Promise<void>

  • Removes rows with missing values from this table. By default, missing values are NULL (as an SQL value), but also "NULL", "null", "NaN" and "undefined" that might have been converted to strings before being loaded into the table. Empty strings "" are also considered missing values.

    +

removeMissing

  • removeMissing(options?): Promise<void>

  • Removes rows with missing values from this table. By default, missing values are NULL (as an SQL value), but also "NULL", "null", "NaN" and "undefined" that might have been converted to strings before being loaded into the table. Empty strings "" are also considered missing values.

    Parameters

    • options: {
          columns?: string | string[];
          invert?: boolean;
          missingValues?: (string | number)[];
      } = {}

      An optional object with configuration options:

      • Optionalcolumns?: string | string[]

        Either a string or an array of strings specifying the columns to consider for missing values. By default, all columns are considered.

      • Optionalinvert?: boolean

        A boolean indicating whether to invert the condition, keeping only rows with missing values. Defaults to false.

        @@ -1293,12 +1294,12 @@

        Example: Specific columns

        // Removes rows with missing values in specific columns.
        await table.removeMissing({ columns: ["firstName", "lastName"] })
        -

removeRows

removeRows

  • removeRows(conditions): Promise<void>

  • Removes rows from this table based on SQL conditions.

    Parameters

    • conditions: string

      The filtering conditions specified as a SQL WHERE clause.

    Returns Promise<void>

    Example: Basic usage

    // Removes rows where the fruit is an apple.
    await table.removeRows(`fruit = 'apple'`)
    -

sample

  • sample(quantity, options?): Promise<void>

  • Selects random rows from the table and removes the others. You can optionally specify a seed to ensure the same random rows are selected each time.

    +

sample

  • sample(quantity, options?): Promise<void>

  • Selects random rows from the table and removes the others. You can optionally specify a seed to ensure the same random rows are selected each time.

    Parameters

    • quantity: string | number

      The number of rows (1000 for example) or a string ("10%" for example) specifying the sampling size.

    • options: {
          seed?: number;
      } = {}

      An optional object with configuration options:

      • Optionalseed?: number

        A number specifying the seed for repeatable sampling. For example, setting it to 1 will ensure random rows will be the same each time you run the method.

        @@ -1311,7 +1312,7 @@

        Example: With a seed

        // Selects always the same random rows
        await table.sample("10%", { seed: 1 })
        -

selectRows

selectRows

  • selectRows(count, options?): Promise<SimpleTable>

  • Selects n rows from this table. An offset and outputTable options are available.

    Parameters

    • count: string | number

      The number of rows.

    • options: {
          offset?: number;
          outputTable?: string | boolean;
      } = {}

      An optional object with configuration options:

      • Optionaloffset?: number

        The number of rows to skip before selecting. Defaults to 0.

        @@ -1328,12 +1329,12 @@

        Example: Into a new table with a specific name in the DB

        // Selects 100 rows and stores them in a new table.
        const tableB = await tableA.selectRows(100, { outputTable: "tableB" })
        -

skip

skip

  • skip(nbRowsToSkip): Promise<void>

  • Skips the first X rows.

    Parameters

    • nbRowsToSkip: number

      The number of rows to skip.

    Returns Promise<void>

    Example: Basic usage

    // Skips the first 10 rows.
    await table.skip(10)
    -

Updating data

concatenate

Updating data

concatenate

  • concatenate(columns, newColumn, options?): Promise<void>

  • Concatenates values from specified columns into a new column.

    Parameters

    • columns: string[]

      An array of column names from which values will be concatenated.

    • newColumn: string

      The name of the new column to store the concatenated values.

    • options: {
          separator?: string;
      } = {}

      An optional object with configuration options:

      @@ -1344,18 +1345,18 @@

      Example: With a separator

      // Same thing, but the values will be separated by a dash
      await table.concatenate(["column1", "column2"], "column3", { separator: "-" })
      -

fill

fill

  • fill(columns): Promise<void>

  • Fills cells containing NULL values. If a cell is empty, it's filled with the previous row's value.

    Parameters

    • columns: string | string[]

      The columns to fill.

    Returns Promise<void>

    Example: Basic usage

    await table.fill("column1")
    -

left

left

  • left(column, numberOfCharacters): Promise<void>

  • Extracts a specific number of characters, starting from the left.

    Parameters

    • column: string

      The name of the column storing the strings

    • numberOfCharacters: number

      The number of characters, starting from the left

    Returns Promise<void>

    Example: Basic usage

    // Strings in column1 will be replaced by the first two characters of each string.
    await table.left("column1", 2)
    -

lower

lower

  • lower(columns): Promise<void>

  • Formats strings to lowercase.

    Parameters

    • columns: string | string[]

      Either a string or an array of strings specifying the columns to be updated.

    Returns Promise<void>

    Example: Basic usage

    await table.lower("column1")
    @@ -1363,7 +1364,7 @@

    Example: Multiple columns

    await table.lower(["column1", "column2"])
    -

replace

replace

  • replace(columns, strings, options?): Promise<void>

  • Replaces specified strings in the selected columns

    Parameters

    • columns: string | string[]

      Either a string or an array of strings specifying the columns where string replacements will occur.

    • strings: {
          [key: string]: string;
      }

      An object mapping old strings to new strings.

      • [key: string]: string
    • options: {
          entireString?: boolean;
          regex?: boolean;
      } = {}

      An optional object with configuration options:

      @@ -1381,19 +1382,19 @@

      Example: Regular expression

      // Replaces using a regular expression. Any sequence of one or more digits would be replaced by a hyphen.
      await table.replace("column1", {"\d+": "-" }, {regex: true})
      -

replaceNulls

replaceNulls

  • replaceNulls(columns, value): Promise<void>

  • Replaces null values in the selected columns.

    Parameters

    • columns: string | string[]

      Either a string or an array of strings specifying the columns where string replacements will occur.

    • value:
          | string
          | number
          | boolean
          | Date

      The value to replace the null values.

    Returns Promise<void>

    Example: Basic usage

    // Replace null values by 0.
    await table.replaceNulls("column1", 0)
    -

right

right

  • right(column, numberOfCharacters): Promise<void>

  • Extracts a specific number of characters, starting from the right.

    Parameters

    • column: string

      The name of the column storing the strings

    • numberOfCharacters: number

      The number of characters, starting from the right

    Returns Promise<void>

    Example: Basic usage

    // Strings in column1 will be replaced by the last two characters of each string.
    await table.right("column1", 2)
    -

round

round

  • round(columns, options?): Promise<void>

  • Rounds numeric values in specified columns.

    Parameters

    • columns: string | string[]

      Either a string or an array of strings specifying the columns containing numeric values to be rounded.

    • options: {
          decimals?: number;
          method?: "round" | "ceiling" | "floor";
      } = {}

      An optional object with configuration options:

      • Optionaldecimals?: number

        The number of decimal places to round to. Defaults to 0.

        @@ -1407,14 +1408,14 @@

        Example: Specific rounding method

        // Rounds column1's values with a specific method. Available methods are "round", "floor" and "ceiling".
        await table.round("column1", { method: "floor" })
        -

splitExtract

  • splitExtract(column, separator, index): Promise<void>

  • Splits strings along a separator and replaces the values with a substring at a specified index (starting at 0). If the index is outside the bounds of the list, return an empty string.

    +

splitExtract

  • splitExtract(column, separator, index): Promise<void>

  • Splits strings along a separator and replaces the values with a substring at a specified index (starting at 0). If the index is outside the bounds of the list, return an empty string.

    Parameters

    • column: string

      The name of the column storing the strings

    • separator: string

      The substring to use as a separator

    • index: number

      The index of the substring to replace values

    Returns Promise<void>

    Example: Basic usage

    // Splits on commas and replaces values with the second substring.
    await table.splitExtract("column1", ",", 1)
    -

trim

trim

  • trim(columns, options?): Promise<void>

  • Trims specified characters from the beginning, end, or both sides of string values.

    Parameters

    • columns: string | string[]

      The column or columns to trim.

    • options: {
          character?: string;
          method?: "leftTrim" | "rightTrim" | "trim";
      } = {}

      An optional object with configuration options:

      • Optionalcharacter?: string

        The string to trim. Defaults to whitespace.

        @@ -1425,23 +1426,23 @@

        Example: Multiple column

        // Trims values in column2, columns3, and column4
        await table.trim(["column2", "column3", "column4"])
        -

updateColumn

updateColumn

  • updateColumn(column, definition): Promise<void>

  • Updates values in a specified column with a SQL expression.

    Parameters

    • column: string

      The name of the column to be updated.

    • definition: string

      The SQL expression to set the new values in the column.

    Returns Promise<void>

    Example: Basic usage

    await table.updateColumn("column1", `LEFT(column2)`)
    -

updateWithJS

  • updateWithJS(dataModifier): Promise<void>

  • Updates data using a JavaScript function. The function takes the existing rows as an array of objects and must return them modified as an array of objects. This method provides a flexible way to update data, but it's slow. This won't work with tables containing geometries.

    +

updateWithJS

  • updateWithJS(dataModifier): Promise<void>

  • Updates data using a JavaScript function. The function takes the existing rows as an array of objects and must return them modified as an array of objects. This method provides a flexible way to update data, but it's slow. This won't work with tables containing geometries.

    Parameters

    • dataModifier: ((rows: {
          [key: string]:
              | number
              | string
              | Date
              | boolean
              | null;
      }[]) => Promise<{
          [key: string]:
              | number
              | string
              | Date
              | boolean
              | null;
      }[]>) | ((rows: {
          [key: string]:
              | number
              | string
              | Date
              | boolean
              | null;
      }[]) => {
          [key: string]:
              | number
              | string
              | Date
              | boolean
              | null;
      }[])

      A function that takes the existing rows and returns modified rows using JavaScript logic. The original rows are objects in an array and the modified rows must be returned as an array of objects too.

    Returns Promise<void>

    Example: Basic usage

    // Adds one to the values from column1. If the values are not numbers, they are replaced by null.
    await table.updateWithJS((rows) => {
     const modifiedRows = rows.map(d => ({
         ...d,
         column1: typeof d.column1 === "number" ? d.column1 + 1 : null
     }))
     return modifiedRows
    })
    -

upper

upper

  • upper(columns): Promise<void>

  • Formats strings to uppercase.

    Parameters

    • columns: string | string[]

      Either a string or an array of strings specifying the columns to be updated.

    Returns Promise<void>

    Example: Basic usage

    await table.upper("tableA", "column1")

    @example Multiple columns
    await table.upper(["column1", "column2"])
    -

Other

cache

Other

cache

  • cache(run, options?): Promise<void>

  • Caches the results of computations in ./.sda-cache which you probably want to add to your .gitignore.

    Parameters

    • run: (() => Promise<void>)

      A function wrapping the computations.

        • (): Promise<void>

        • Returns Promise<void>

    • options: {
          ttl?: number;
      } = {}

      An optional object with configuration options:

      • Optionalttl?: number

        If the data in cache is older than the ttl (in seconds), the computations will be run. By default, there is no ttl.

        @@ -1457,7 +1458,7 @@

        Exam 
        const sdb = new SimpleDB({ cacheVerbose: true })
        const table = sdb.newTable()

        await table.cache(async () => {
            await table.loadData("items.csv")
            await table.summarize({
                values: "price",
                categories: "department",
                summaries: ["min", "max", "mean"]
            })
        }, { ttl: 60 })

        // It's important to call done() on the SimpleDB instance to clean up the cache.
        // We don't want it to grow in size indefinitely.
        await sdb.done()
        -

cloneTable

  • cloneTable(options?): Promise<SimpleTable>

  • Returns a new table with the same structure and data as this table. The data can be optionally filtered. This can be very slow with big tables.

    +

cloneTable

  • cloneTable(options?): Promise<SimpleTable>

  • Returns a new table with the same structure and data as this table. The data can be optionally filtered. This can be very slow with big tables.

    Parameters

    • options: {
          condition?: string;
          outputTable?: string;
      } = {}

      An optional object with configuration options:

      • Optionalcondition?: string

        A SQL WHERE clause condition to filter the data. Defaults to no condition.

      • OptionaloutputTable?: string

        The name in the DB of the new table that will be created as a clone.

        @@ -1470,43 +1471,43 @@

        Example: Cloning with condition

        // Creating tableB as a clone of tableA. Only rows with values greater than 10 in column1 are cloned.
        const tableB = await tableA.cloneTable({ condition: `column1 > 10` })
        -

getColumns

getColumns

getDescription

  • getDescription(): Promise<{
        [key: string]: unknown;
    }[]>

  • Returns descriptive information about the columns, including details like data types, number of null and distinct values. Best to look at with console.table.

    +

    Returns Promise<string[]>

getDescription

  • getDescription(): Promise<{
        [key: string]: unknown;
    }[]>

  • Returns descriptive information about the columns, including details like data types, number of null and distinct values. Best to look at with console.table.

    Returns Promise<{
        [key: string]: unknown;
    }[]>

    Example: Basic usage

    const description = await table.getDescription()
    -

getNbColumns

getNbColumns

getNbRows

getNbRows

getNbValues

getNbValues

  • getNbValues(): Promise<number>

  • Returns the number of values (number of columns * number of rows) in a table.

    Returns Promise<number>

    Example: Basic usage

    const nbValues = await table.getNbValues()
    -

getSchema

getSchema

  • getSchema(): Promise<{
        [key: string]: string | null;
    }[]>

  • Returns the schema (column names and their data types).

    Returns Promise<{
        [key: string]: string | null;
    }[]>

    Example: Basic usage

    const schema = await table.getSchema()
    -

getTypes

getTypes

  • getTypes(): Promise<{
        [key: string]: string;
    }>

  • Returns the data types of columns.

    Returns Promise<{
        [key: string]: string;
    }>

    Example: Basic usage

    const dataTypes = await table.getTypes()
    -

hasColumn

hasColumn

  • hasColumn(column): Promise<boolean>

  • Returns TRUE if the table has the column and FALSE otherwise.

    Parameters

    • column: string

    Returns Promise<boolean>

    Example: Basic usage

    const bool = await table.hasColum("name")
    -

logDescription

  • logDescription(): Promise<void>

  • Logs descriptive information about the columns, including details like data types, number of null and distinct values. It calls getDescription.

    +

logDescription

  • logDescription(): Promise<void>

  • Logs descriptive information about the columns, including details like data types, number of null and distinct values. It calls getDescription.

    Returns Promise<void>

    Example: Basic usage

    await table.logDescription()
    -

logTable

logTable

  • logTable(nbRowsToLog?): Promise<void>

  • Logs a specified number of rows. Default is 10 rows.

    Parameters

    • OptionalnbRowsToLog: number

      The number of rows to log when debugging. Defaults to 10 or the value set in the SimpleWebDB instance.

    Returns Promise<void>

    Example: Basic usage

    // Logs first 10 rows
    await table.logTable();
    @@ -1514,14 +1515,14 @@

    Example: Specific number of rows

    // Logs first 100 rows
    await table.logTable(100);
    -

renameTable

renameTable

setTypes

setTypes

  • setTypes(types): Promise<void>

  • Set the types in the table.

    Parameters

    • types: {
          [key: string]:
              | "integer"
              | "float"
              | "number"
              | "string"
              | "date"
              | "time"
              | "datetime"
              | "datetimeTz"
              | "bigint"
              | "double"
              | "varchar"
              | "timestamp"
              | "timestamp with time zone"
              | "boolean"
              | "geometry";
      }

      An object specifying the columns and their data types (JavaScript or SQL).

      • [key: string]:
            | "integer"
            | "float"
            | "number"
            | "string"
            | "date"
            | "time"
            | "datetime"
            | "datetimeTz"
            | "bigint"
            | "double"
            | "varchar"
            | "timestamp"
            | "timestamp with time zone"
            | "boolean"
            | "geometry"

    Returns Promise<void>

    Example: Basic usage

     await table.setTypes({
        name: "string",
        salary: "integer",
        raise: "float",
    })
    -

Settings

Member Visibility

On This Page

Properties
Analyzing data
Exporting data
Geospatial
Getting data
Importing data
Restructuring data
Selecting or filtering data
Updating data
Other
+

Settings

Member Visibility

On This Page

Properties
Analyzing data
Exporting data
Geospatial
Getting data
Importing data
Restructuring data
Selecting or filtering data
Updating data
Other
diff --git a/docs/classes/SimpleWebDB.html b/docs/classes/SimpleWebDB.html index 4f20bdc5..ac1c4d6c 100644 --- a/docs/classes/SimpleWebDB.html +++ b/docs/classes/SimpleWebDB.html @@ -1,4 +1,4 @@ -SimpleWebDB | Simple-data-analysis - v3.6.2

Class SimpleWebDB

SimpleWebDB is a class that provides a simplified interface for working with DuckDB, a high-performance in-memory analytical database. This class is meant to be used in a web browser. For NodeJS and similar runtimes, use SimpleDB.

+SimpleWebDB | Simple-data-analysis - v3.6.3

Class SimpleWebDB

SimpleWebDB is a class that provides a simplified interface for working with DuckDB, a high-performance in-memory analytical database. This class is meant to be used in a web browser. For NodeJS and similar runtimes, use SimpleDB.

Here's how to instantiate a SimpleWebDB instance and then a SimpleWebTable.

Example: Basic usage

// Instantiating the database.
const sdb = new SimpleWebDB()

// Creating a new table.
const employees = sdb.newTable("employees")

// You can now invoke methods on the table.
await employees.loadData("./employees.csv")
await employees.logTable()

// Removing the table.
await employees.removeTable()

// Removing the DB to free up memory.
await sdb.done()
@@ -6,7 +6,7 @@

Example: Instanciating with options

// Creating a database with options. Debug information will be logged each time a method is invoked. The first 20 rows of tables will be logged (default is 10).
const sdb = new SimpleWebDB({ debug: true, nbRowsToLog: 20 })
-

Hierarchy (view full)

Properties

bigIntToInt +

Hierarchy (view full)

Properties

bigIntToInt cacheSourcesUsed connection db @@ -27,18 +27,18 @@

removeTables

Internal

start

Properties

bigIntToInt

bigIntToInt: undefined | boolean

A flag for SimpleDB. Default is true. When data is retrieved from the database as an array of objects, BIGINT values are automatically converted to integers, which are easier to work with in JavaScript. If you want actual bigint values, set this option to false.

-

cacheSourcesUsed

cacheSourcesUsed: string[]

An object keeping track of the data used in cache.

-

connection

connection: AsyncDuckDBConnection | Connection

A connection to a DuckDB database.

-

db

db: AsyncDuckDB | Database

A DuckDB database.

-

debug

debug: boolean

A flag indicating whether debugging information should be logged. Defaults to false.

-

defaultTableName

defaultTableName: boolean

A flag to know if the name of the table has been attributed by default.

-

durationStart

durationStart: undefined | number

A timestamp used to track the total duration logged in done().

-

nbCharactersToLog

nbCharactersToLog: undefined | number

The number of characters to log for text cells. By default, the whole text is logged.

-

nbRowsToLog

nbRowsToLog: number

The number of rows to log. Defaults to 10.

-

runQuery

runQuery: ((query: string, connection: AsyncDuckDBConnection | Connection, returnDataFromQuery: boolean, options: {
    bigIntToInt?: boolean;
    debug: boolean;
    method: null | string;
    parameters: null | {
        [key: string]: unknown;
    };
}) => Promise<null | {
    [key: string]:
        | number
        | string
        | Date
        | boolean
        | null;
}[]>)

For internal use only. If you want to run a SQL query, use the customQuery method.

-

tableIncrement

tableIncrement: number

A number used when creating new tables.

-

worker

worker: null | Worker

A worker to make DuckDB WASM work.

-

DB methods

customQuery

  • customQuery(query, options?): Promise<null | {
        [key: string]:
            | string
            | number
            | boolean
            | Date
            | null;
    }[]>

  • Executes a custom SQL query, providing flexibility for advanced users.

    +

cacheSourcesUsed

cacheSourcesUsed: string[]

An object keeping track of the data used in cache.

+

connection

connection: AsyncDuckDBConnection | Connection

A connection to a DuckDB database.

+

db

db: AsyncDuckDB | Database

A DuckDB database.

+

debug

debug: boolean

A flag indicating whether debugging information should be logged. Defaults to false.

+

defaultTableName

defaultTableName: boolean

A flag to know if the name of the table has been attributed by default.

+

durationStart

durationStart: undefined | number

A timestamp used to track the total duration logged in done().

+

nbCharactersToLog

nbCharactersToLog: undefined | number

The number of characters to log for text cells. By default, the whole text is logged.

+

nbRowsToLog

nbRowsToLog: number

The number of rows to log. Defaults to 10.

+

runQuery

runQuery: ((query: string, connection: AsyncDuckDBConnection | Connection, returnDataFromQuery: boolean, options: {
    bigIntToInt?: boolean;
    debug: boolean;
    method: null | string;
    parameters: null | {
        [key: string]: unknown;
    };
}) => Promise<null | {
    [key: string]:
        | number
        | string
        | Date
        | boolean
        | null;
}[]>)

For internal use only. If you want to run a SQL query, use the customQuery method.

+

tableIncrement

tableIncrement: number

A number used when creating new tables.

+

worker

worker: null | Worker

A worker to make DuckDB WASM work.

+

DB methods

customQuery

  • customQuery(query, options?): Promise<null | {
        [key: string]:
            | string
            | number
            | boolean
            | Date
            | null;
    }[]>

  • Executes a custom SQL query, providing flexibility for advanced users.

    Parameters

    • query: string

      The custom SQL query to be executed.

    • options: {
          returnDataFrom?: "query" | "none";
          table?: string;
      } = {}

      An optional object with configuration options:

      • OptionalreturnDataFrom?: "query" | "none"

        Specifies whether to return data from the "query" or not. Defaults to "none".

        @@ -46,24 +46,24 @@

    Returns Promise<null | {
        [key: string]:
            | string
            | number
            | boolean
            | Date
            | null;
    }[]>

    Example: Basic usage

    // You can use the returnDataFrom option to retrieve the data from the query, if needed.
    const data = await sdb.customQuery("SELECT * FROM employees WHERE Job = 'Clerk'", { returnDataFrom: "query" })
    -

done

  • done(): Promise<void>

  • Frees up memory. Closes the connection to the database and terminates associated resources.

    +

done

  • done(): Promise<void>

  • Frees up memory. Closes the connection to the database and terminates associated resources.

    Returns Promise<void>

    Example: Basic usage

    await sdb.done();
    -

getExtensions

  • getExtensions(): Promise<{
        [key: string]:
            | string
            | number
            | boolean
            | Date
            | null;
    }[]>

  • Returns the DuckDB extensions.

    +

getExtensions

  • getExtensions(): Promise<{
        [key: string]:
            | string
            | number
            | boolean
            | Date
            | null;
    }[]>

  • Returns the DuckDB extensions.

    const extensions = await sdb.getExtensions()
    -

    Returns Promise<{
        [key: string]:
            | string
            | number
            | boolean
            | Date
            | null;
    }[]>

getTables

  • getTables(): Promise<string[]>

  • Returns the list of tables.

    +

    Returns Promise<{
        [key: string]:
            | string
            | number
            | boolean
            | Date
            | null;
    }[]>

getTables

  • getTables(): Promise<string[]>

  • Returns the list of tables.

    Returns Promise<string[]>

    Example: Basic usage

    const tables = await sdb.getTables()
    -

hasTable

  • hasTable(table): Promise<boolean>

  • Returns true if a specified table exists and false if not.

    +

hasTable

  • hasTable(table): Promise<boolean>

  • Returns true if a specified table exists and false if not.

    Parameters

    • table: string

      The name of the table to check for existence.

    Returns Promise<boolean>

    Example: Basic usage

    const hasEmployees = await sdb.hasTable("employees")
    -

newTable

newTable

  • newTable(name?, projections?): SimpleWebTable

  • Creates a table in the DB.

    Parameters

    • Optionalname: string

      The name of the new table.

    • Optionalprojections: {
          [key: string]: string;
      }

      The projections of the geospatial data, if any.

      • [key: string]: string

    Returns SimpleWebTable

    Example: Basic usage

    // This returns a new SimpleWebTable
    const employees = sdb.newTable()
@@ -72,7 +72,7 @@ 
    Example: With a specific name
    // By default, tables will be named table1, table2, etc.
    // But you can also give them specific names.
    const employees = sdb.newTable("employees")
 
    
 
-

removeTables

  • removeTables(tables): Promise<void>

  • Remove a table or multiple tables from the database. Invoking methods on the tables will throw and error.

    +

removeTables

  • removeTables(tables): Promise<void>

  • Remove a table or multiple tables from the database. Invoking methods on the tables will throw and error.

    Parameters

    Returns Promise<void>

    Example: Basic usage

    await table.removeTables(tableA)
    @@ -80,5 +80,5 @@

    Example: Multiple tables

    await table.removeTables([tableA, tableB])
    -

Internal

start

Settings

Member Visibility

On This Page

Properties
DB methods
Internal
+

Internal

start

Settings

Member Visibility

On This Page

Properties
DB methods
Internal
diff --git a/docs/classes/SimpleWebTable.html b/docs/classes/SimpleWebTable.html index 5c439ad7..94f6fd94 100644 --- a/docs/classes/SimpleWebTable.html +++ b/docs/classes/SimpleWebTable.html @@ -1,11 +1,11 @@ -SimpleWebTable | Simple-data-analysis - v3.6.2

Class SimpleWebTable

SimpleWebTable is a class representing a table in a SimpleWebDB. It can handle tabular and geospatial data. To create one, it's best to instantiate a SimpleWebDB first.

+SimpleWebTable | Simple-data-analysis - v3.6.3

Class SimpleWebTable

SimpleWebTable is a class representing a table in a SimpleWebDB. It can handle tabular and geospatial data. To create one, it's best to instantiate a SimpleWebDB first.

Example: Basic usage

// Creating a database first.
const sdb = new SimpleWebDB()

// Making a new table. This returns a SimpleWebTable.
const table = sdb.newTable()

// You can now invoke methods on the table.
const url = ".../some-file.csv"
await table.fetchData(url)
await table.logTable()

// Removing the DB to free up memory.
await sdb.done()

Example: Geospatial data

const boundaries = sdb.newTable()
// To load geospatial data, use .fetchGeoData instead of .fetchData
const url = ".../some-file.geojson"
await boundaries.fetchGeoData(url)
-

Hierarchy (view full)

Properties

bigIntToInt +

Hierarchy (view full)

Properties

bigIntToInt connection db debug @@ -131,19 +131,19 @@

renameTable setTypes

Properties

bigIntToInt

bigIntToInt: undefined | boolean

A flag for SimpleDB. Default is true. When data is retrieved from the database as an array of objects, BIGINT values are automatically converted to integers, which are easier to work with in JavaScript. If you want actual bigint values, set this option to false.

-

connection

connection: AsyncDuckDBConnection | Connection

A connection to a DuckDB database.

-

db

db: AsyncDuckDB | Database

A DuckDB database.

-

debug

debug: boolean

A flag indicating whether debugging information should be logged. Defaults to false.

-

defaultTableName

defaultTableName: boolean

A flag to know if the name of the table has been attributed by default.

-

name

name: string

Name of the table in the database.

-

nbCharactersToLog

nbCharactersToLog: undefined | number

The number of characters to log for text cells. By default, the whole text is logged.

-

nbRowsToLog

nbRowsToLog: number

The number of rows to log. Defaults to 10.

-

projections

projections: {
    [key: string]: string;
}

The projections of the geospatial data, if any.

-

runQuery

runQuery: ((query: string, connection: AsyncDuckDBConnection | Connection, returnDataFromQuery: boolean, options: {
    bigIntToInt?: boolean;
    debug: boolean;
    method: null | string;
    parameters: null | {
        [key: string]: unknown;
    };
}) => Promise<null | {
    [key: string]:
        | number
        | string
        | Date
        | boolean
        | null;
}[]>)

For internal use only. If you want to run a SQL query, use the customQuery method.

-

sdb

sdb: SimpleWebDB

The SimpleWebDB that created this table.

-

tableIncrement

tableIncrement: number

A number used when creating new tables.

-

worker

worker: null | Worker

A worker to make DuckDB WASM work.

-

Analyzing data

bins

  • bins(values, interval, newColumn, options?): Promise<void>

  • Assigns bins for specified column values based on an interval size.

    +

connection

connection: AsyncDuckDBConnection | Connection

A connection to a DuckDB database.

+

db

db: AsyncDuckDB | Database

A DuckDB database.

+

debug

debug: boolean

A flag indicating whether debugging information should be logged. Defaults to false.

+

defaultTableName

defaultTableName: boolean

A flag to know if the name of the table has been attributed by default.

+

name

name: string

Name of the table in the database.

+

nbCharactersToLog

nbCharactersToLog: undefined | number

The number of characters to log for text cells. By default, the whole text is logged.

+

nbRowsToLog

nbRowsToLog: number

The number of rows to log. Defaults to 10.

+

projections

projections: {
    [key: string]: string;
}

The projections of the geospatial data, if any.

+

runQuery

runQuery: ((query: string, connection: AsyncDuckDBConnection | Connection, returnDataFromQuery: boolean, options: {
    bigIntToInt?: boolean;
    debug: boolean;
    method: null | string;
    parameters: null | {
        [key: string]: unknown;
    };
}) => Promise<null | {
    [key: string]:
        | number
        | string
        | Date
        | boolean
        | null;
}[]>)

For internal use only. If you want to run a SQL query, use the customQuery method.

+

sdb

sdb: SimpleWebDB

The SimpleWebDB that created this table.

+

tableIncrement

tableIncrement: number

A number used when creating new tables.

+

worker

worker: null | Worker

A worker to make DuckDB WASM work.

+

Analyzing data

bins

  • bins(values, interval, newColumn, options?): Promise<void>

  • Assigns bins for specified column values based on an interval size.

    Parameters

    • values: string

      The column containing values from which bins will be computed.

    • interval: number

      The interval size for binning the values.

    • newColumn: string

      The name of the new column where the bins will be stored.

      @@ -155,7 +155,7 @@

      Example: Starting value

      // Same thing, but with the bins starting at a specific value.
      await table.bins("column1", 10, "bins", { startValue: 0 })
      // The bins will follow this pattern: "[0-9]", "[10-19]", "[20-29]", etc.
      -

correlations

correlations

  • correlations(options?): Promise<SimpleWebTable>

  • Calculates correlations between columns.

    If no x and y columns are specified, the method computes the correlations of all numeric columns combinations. It's important to note that correlation is symmetrical: the correlation of x over y is the same as y over x.

    Parameters

    • options: {
          categories?: string | string[];
          decimals?: number;
          outputTable?: string | boolean;
          x?: string;
          y?: string;
      } = {}

      An optional object with configuration options:

      • Optionalcategories?: string | string[]

        The column or columns that define categories. Correlation calculations will be run for each category.

        @@ -178,7 +178,7 @@

        Example: Returning results in a new table with a specific name in the DB

        // Same but results are stored in tableB.
        const tableB = await table.correlations({ outputTable: "tableB" })
        -

linearRegressions

linearRegressions

  • linearRegressions(options?): Promise<SimpleWebTable>

  • Performs linear regression analysis. The results include the slope, the y-intercept the R-squared.

    If no x and y columns are specified, the method computes the linear regression analysis of all numeric columns permutations. It's important to note that linear regression analysis is asymmetrical: the linear regression of x over y is not the same as y over x.

    Parameters

    • options: {
          categories?: string | string[];
          decimals?: number;
          outputTable?: string | true;
          x?: string;
          y?: string;
      } = {}

      An optional object with configuration options:

      • Optionalcategories?: string | string[]

        The column or columns that define categories. Correlation calculations will be run for each category.

        @@ -200,7 +200,7 @@

        Example: Returning results in a new table with a specific name in the DB

        // Same but stores the results in tableB.
        const tableB = await table.linearRegressions({ outputTable: "tableB" })
        -

normalize

  • normalize(column, newColumn, options?): Promise<void>

  • Normalizes the values in a column using min-max normalization.

    +

normalize

  • normalize(column, newColumn, options?): Promise<void>

  • Normalizes the values in a column using min-max normalization.

    Parameters

    • column: string

      The name of the column in which values will be normalized.

    • newColumn: string

      The name of the new column where normalized values will be stored.

    • options: {
          categories?: string | string[];
          decimals?: number;
      } = {}

      An optional object with configuration options:

      @@ -215,7 +215,7 @@

      Example: Rounding values

      // Normalizes the values in the column1 with values from column2 as categories. The values are rounded to two decimal places.
      await table.normalize("column1", { categories: "column2", decimals: 2 })
      -

outliersIQR

  • outliersIQR(column, newColumn, options?): Promise<void>

  • Identifies outliers using the Interquartile Range (IQR) method.

    +

outliersIQR

  • outliersIQR(column, newColumn, options?): Promise<void>

  • Identifies outliers using the Interquartile Range (IQR) method.

    Parameters

    • column: string

      The name of the column in which outliers will be identified.

    • newColumn: string

      The name of the new column where the bins will be stored.

    • options: {
          categories?: string | string[];
      } = {}

      An optional object with configuration options:

      @@ -226,7 +226,7 @@

      Example: With categories

      // Looks for outliers in column age with values from column gender as categories. Creates a new column outliers with TRUE or FALSE values.
      await table.outliersIQR("age", "outliers", { categories: "gender" })
      -

proportionsHorizontal

  • proportionsHorizontal(columns, options?): Promise<void>

  • Computes proportions within a row for specified columns.

    +

proportionsHorizontal

  • proportionsHorizontal(columns, options?): Promise<void>

  • Computes proportions within a row for specified columns.

    For example, let's say this is tableA.

    @@ -356,7 +356,7 @@

    proportionsVertical

    • proportionsVertical(column, newColumn, options?): Promise<void>

    • Computes proportions over a column's values.

      +

    proportionsVertical

    • proportionsVertical(column, newColumn, options?): Promise<void>

    • Computes proportions over a column's values.

      Parameters

      • column: string

        The column containing values for which proportions will be computed. The proportions are calculated based on the sum of values in the specified column.

      • newColumn: string

        The name of the new column where the proportions will be stored.

      • options: {
            categories?: string | string[];
            decimals?: number;
        } = {}

        An optional object with configuration options:

        @@ -371,7 +371,7 @@

        Example: With specific number of decimals

        // Same thing but rounding to two decimals
        await table.proportionsVertical("column1", "perc", { categories: "column2", decimals: 2 })
        -

    quantiles

    • quantiles(values, nbQuantiles, newColumn, options?): Promise<void>

    • Assigns quantiles for specified column values.

      +

    quantiles

    • quantiles(values, nbQuantiles, newColumn, options?): Promise<void>

    • Assigns quantiles for specified column values.

      Parameters

      • values: string

        The column containing values from which quantiles will be assigned.

      • nbQuantiles: number

        The number of quantiles.

      • newColumn: string

        The name of the new column where the assigned quantiles will be stored.

        @@ -383,7 +383,7 @@

        Example: With categories

        // Same thing, except the values in column2 are used as categories.
        await table.quantiles("column1", 10, "quantiles", { categories: "column2" })
        -

    ranks

    • ranks(values, newColumn, options?): Promise<void>

    • Assigns ranks in a new column based on specified column values.

      +

    ranks

    • ranks(values, newColumn, options?): Promise<void>

    • Assigns ranks in a new column based on specified column values.

      Parameters

      • values: string

        The column containing values to be used for ranking.

      • newColumn: string

        The name of the new column where the ranks will be stored.

      • options: {
            categories?: string | string[];
            noGaps?: boolean;
            order?: "asc" | "desc";
        } = {}

        An optional object with configuration options:

        @@ -396,7 +396,7 @@

        Example: With categories

        // Computing ranks in the new column rank from the column1 values. Using the values from column2 as categories.
        await table.ranks("tableA", "column1", "rank", { categories: "column2" })
        -

    rolling

    • rolling(column, newColumn, summary, preceding, following, options?): Promise<void>

    • Computes rolling aggregations, like a rolling average. For rows without enough preceding or following rows, returns NULL. For this method to work properly, don't forget to sort your data first.

      +

    rolling

    • rolling(column, newColumn, summary, preceding, following, options?): Promise<void>

    • Computes rolling aggregations, like a rolling average. For rows without enough preceding or following rows, returns NULL. For this method to work properly, don't forget to sort your data first.

      Parameters

      • column: string

        The name of the column storing the values to be aggregated

      • newColumn: string

        The name of the new column in which the computed values will be stored

      • summary:
            | "min"
            | "max"
            | "mean"
            | "median"
            | "sum"

        How to aggregate the values

        @@ -414,7 +414,7 @@

        Example: Rounding

        // 7-day rolling average of values in column1 with the 3 preceding and 3 following rows. Using values in column2 as categories and rounding to two decimal places.
        await table.rolling("column1", "rollingAvg", "mean", 3, 3, { categories: "column2", decimals: 2 })
        -

    summarize

    summarize

    • summarize(options?): Promise<SimpleWebTable>

    • Creates a summary table based on specified values, categories, and summary operations.

      Parameters

      • options: {
            categories?: string | string[];
            decimals?: number;
            outputTable?: string | boolean;
            summaries?:
                | "count"
                | "countUnique"
                | "countNull"
                | "min"
                | "max"
                | "mean"
                | "median"
                | "sum"
                | "skew"
                | "stdDev"
                | "var"
                | (
                    | "count"
                    | "countUnique"
                    | "countNull"
                    | "min"
                    | "max"
                    | "mean"
                    | "median"
                    | "sum"
                    | "skew"
                    | "stdDev"
                    | "var")[];
            toMs?: boolean;
            values?: string | string[];
        } = {}

        An optional object with configuration options:

        • Optionalcategories?: string | string[]

          The column or columns that define categories for the summarization. This can be a single column name or an array of column names.

        • Optionaldecimals?: number

          The number of decimal places to round the summarized values.

          @@ -449,7 +449,7 @@

          Example: Converting timestamps, dates, or times, to milliseconds.

          // You can't summarize numbers and dates at the same time because your values must be of the same type (strings don't count). The option toMs converts timestamps, dates, and times to numbers (milliseconds).
          await tableA.summarize({ values: ["column1", "column2"], toMs: true })
          -

    zScore

    zScore

    • zScore(column, newColumn, options?): Promise<void>

    • Computes the Z-score.

      Parameters

      • column: string

        The name of the column for which Z-Score will be calculated.

      • newColumn: string

        The name of the new column where the bins will be stored.

      • options: {
            categories?: string | string[];
            decimals?: number;
        } = {}

        An optional object with configuration options:

        @@ -464,7 +464,7 @@

        Example: Rounding values

        // Calculates the Z-score for the values in column age with the column gender as categories and puts the results in column sigma. The score is rounded to two decimal places.
        await table.zScore("age", "sigma", { categories: "gender", decimals: 2 })
        -

    Geospatial

    aggregateGeo

    Geospatial

    aggregateGeo

    • aggregateGeo(method, options?): Promise<SimpleWebTable>

    • Aggregates geometries.

      Parameters

      • method: "union" | "intersection"

        The method to use for the aggregation.

      • options: {
            categories?: string | string[];
            column?: string;
            outputTable?: string | boolean;
        } = {}

        An optional object with configuration options:

        • Optionalcategories?: string | string[]

          The column or columns that define categories for the aggragation. This can be a single column name or an array of column names.

          @@ -485,7 +485,7 @@

          Example: Returning results in a new table with a specific name in the DB

          // Same thing but results a return in tableA
          const tableA = await table.aggregateGeo("union", { categories: "country", outputTable: "tableA" })
          -

    area

    • area(newColumn, options?): Promise<void>

    • Computes the area of geometries in square meters or optionally square kilometers. The input geometry is assumed to be in the EPSG:4326 coordinate system (WGS84), with [latitude, longitude] axis order.

      +

    area

    • area(newColumn, options?): Promise<void>

    • Computes the area of geometries in square meters or optionally square kilometers. The input geometry is assumed to be in the EPSG:4326 coordinate system (WGS84), with [latitude, longitude] axis order.

      Parameters

      • newColumn: string

        The name of the new column storing the computed areas.

      • options: {
            column?: string;
            unit?: "m2" | "km2";
        } = {}

        An optional object with configuration options:

        • Optionalcolumn?: string

          The column storing geometries.

          @@ -499,7 +499,7 @@

          Example: Specific column storing geometries

          // If the table has more than one column storing geometries, you must specify which column should be used.
          await table.area("area", { column: "geom", unit: "km2" })
          -

    buffer

    • buffer(newColumn, distance, options?): Promise<void>

    • Computes a buffer around geometries based on a specified distance. The distance is in the SRS unit.

      +

    buffer

    • buffer(newColumn, distance, options?): Promise<void>

    • Computes a buffer around geometries based on a specified distance. The distance is in the SRS unit.

      Parameters

      • newColumn: string

        The name of the new column to store the buffered geometries.

      • distance: number

        The distance for the buffer, in SRS unit.

      • options: {
            column?: string;
        } = {}

        An optional object with configuration options:

        @@ -510,7 +510,7 @@

        Example: Specific column storing geometries

        // If the table has more than one column storing geometries, you must specify which column should be used.
        await table.buffer("buffer", 1, { column: "geom" })
        -

    centroid

    • centroid(newColumn, options?): Promise<void>

    • Computes the centroid of geometries. The values are returned in the SRS unit.

      +

    centroid

    • centroid(newColumn, options?): Promise<void>

    • Computes the centroid of geometries. The values are returned in the SRS unit.

      Parameters

      • newColumn: string

        The name of the new column storing the centroids.

      • options: {
            column?: string;
        } = {}

        An optional object with configuration options:

        • Optionalcolumn?: string

          The column storing geometries.

          @@ -520,7 +520,7 @@

          Example: Specific column storing geometries

          // If the table has more than one column storing geometries, you must specify which column should be used.
          await table.centroid("centroid", { column: "geom" })
          -

    distance

    • distance(column1, column2, newColumn, options?): Promise<void>

    • Computes the distance between geometries. By default, it uses the SRS unit. You can pass "spheroid" or "haversine" as options.method to get results in meters or optionally kilometers. If you do use these methods, the input geometries must use the EPSG:4326 coordinate system (WGS84), with [latitude, longitude] axis order.

      +

    distance

    • distance(column1, column2, newColumn, options?): Promise<void>

    • Computes the distance between geometries. By default, it uses the SRS unit. You can pass "spheroid" or "haversine" as options.method to get results in meters or optionally kilometers. If you do use these methods, the input geometries must use the EPSG:4326 coordinate system (WGS84), with [latitude, longitude] axis order.

      Parameters

      • column1: string

        The name of a column storing geometries.

      • column2: string

        The name of a column storing geometries.

      • newColumn: string

        The name of the new column storing the centroids.

        @@ -540,7 +540,7 @@

        Example: Spheroid (meters and optionally kilometers)

        // Same but using an ellipsoidal model of the earth's surface. It's the most accurate but the slowest. By default, the distance is returned in meters and optionally as kilometers. The input geometries must use the EPSG:4326 coordinate system (WGS84), with [latitude, longitude] axis order.
        await table.distance("geomA", "geomB", "distance", { method: "spheroid", unit: "km" })
        -

    fetchGeoData

    • fetchGeoData(file, options?): Promise<SimpleWebTable>

    • Loads geospatial data from an external file. The coordinates of files or urls ending with .json or .geojson are automatically flipped to [latitude, longitude] axis order.

      +

    fetchGeoData

    • fetchGeoData(file, options?): Promise<SimpleWebTable>

    • Loads geospatial data from an external file. The coordinates of files or urls ending with .json or .geojson are automatically flipped to [latitude, longitude] axis order.

      Parameters

      • file: string

        The URL or path to the external file containing the geospatial data.

      • options: {
            from?: string;
            toWGS84?: boolean;
        } = {}

        An optional object with configuration options:

        • Optionalfrom?: string

          An option to pass the original projection, if the method is not able to find it.

          @@ -551,7 +551,7 @@

          Example: Reprojecting to WGS84 with [latitude, longitude] axis order from a specific projection

          await table.fetchGeoData("https://some-website.com/some-data.shp.zip", { toWGS84: true, from: "EPSG:3347" })
          -

    fixGeo

    • fixGeo(column?): Promise<void>

    • Attempts to make an invalid geometry valid without removing any vertices.

      +

    fixGeo

    • fixGeo(column?): Promise<void>

    • Attempts to make an invalid geometry valid without removing any vertices.

      Parameters

      • Optionalcolumn: string

        The name of the column storing the geometries.

      Returns Promise<void>

      Example: Basic usage

      // By default, the method will look for the column storing the geometries.
      await table.fixGeo()
      @@ -559,12 +559,12 @@

      Example: Specific column storing geometries

      // If the table has more than one column storing geometries, you must specify which column should be used.
      await table.fixGeo("geom")
      -

    flipCoordinates

    • flipCoordinates(column?): Promise<void>

    • Flips the coordinates of geometries. To use as a last resort. This messes up with the projections stored in table.projection.

      +

    flipCoordinates

    • flipCoordinates(column?): Promise<void>

    • Flips the coordinates of geometries. To use as a last resort. This messes up with the projections stored in table.projection.

      Parameters

      • Optionalcolumn: string

        The name of the column storing the geometries.

      Returns Promise<void>

      Example: Basic usage

      // By default, the method will look for the column storing the geometries.
      await table.flipCoordinates()
      -

    getBoundingBox

    • getBoundingBox(column?): Promise<number[]>

    • Get the bounding box of geometries in [minLong, minLat, maxLong, maxLat] order. By default, the method will try find the column with the geometries, but can also specify one. The input geometry is assumed to be in the EPSG:4326 coordinate system (WGS84), with [latitude, longitude] axis order.

      +

    getBoundingBox

    • getBoundingBox(column?): Promise<number[]>

    • Get the bounding box of geometries in [minLong, minLat, maxLong, maxLat] order. By default, the method will try find the column with the geometries, but can also specify one. The input geometry is assumed to be in the EPSG:4326 coordinate system (WGS84), with [latitude, longitude] axis order.

      Parameters

      • Optionalcolumn: string

        The name of a column storing geometries.

      Returns Promise<number[]>

      Example: Basic usage

      const bbox = await table.getBoundingBox()
      @@ -572,7 +572,7 @@

      Example: Specific column storing geometries

      const bbox = await table.getBoundingBox("geometries")
      -

    getGeoData

    • getGeoData(column?): Promise<{
          features: {
              geometry: any;
              properties: {};
              type: string;
          }[];
          type: string;
      }>

    • Returns the data as a geojson. If the table has more than one column storing geometries, you must specify which column should be used. If the projection is WGS84 or EPSG:4326 ([latitude, longitude] axis order), the coordinates will be flipped to follow the RFC7946 standard ([longitude, latitude] axis order).

      +

    getGeoData

    • getGeoData(column?): Promise<{
          features: {
              geometry: any;
              properties: {};
              type: string;
          }[];
          type: string;
      }>

    • Returns the data as a geojson. If the table has more than one column storing geometries, you must specify which column should be used. If the projection is WGS84 or EPSG:4326 ([latitude, longitude] axis order), the coordinates will be flipped to follow the RFC7946 standard ([longitude, latitude] axis order).

      Parameters

      • Optionalcolumn: string

        The name of a column storing geometries.

      Returns Promise<{
          features: {
              geometry: any;
              properties: {};
              type: string;
          }[];
          type: string;
      }>

      Example: Basic usage

      // By default, the method will look for the column storing the geometries. The other columns in the table will be stored as properties.
      const geojson = await table.getGeoData()
      @@ -580,28 +580,28 @@

      Example: Specific geometry column

      // If the table has more than one column storing geometries, you must specify which column should be used. All the other columns in the table will be stored as properties.
      const geojson = await table.getGeoData("geometries")
      -

    inside

    • inside(column1, column2, newColumn): Promise<void>

    • Returns true if all points of a geometry lies inside another geometry.

      +

    inside

    • inside(column1, column2, newColumn): Promise<void>

    • Returns true if all points of a geometry lies inside another geometry.

      Parameters

      • column1: string

        The first column holds the geometries that will be tested for containment.

      • column2: string

        The second column stores the geometries to be tested as containers.

      • newColumn: string

        The name of the new column with true or false values.

      Returns Promise<void>

      Example: Basic usage

      // Checks if geometries in column geomA are inside geometries in column geomB and return true or false in new column isInside.
      await table.inside("geomA", "geomB", "isInside")
      -

    intersect

    intersect

    • intersect(column1, column2, newColumn): Promise<void>

    • Returns true if two geometries intersect.

      Parameters

      • column1: string

        The names of a column storing geometries.

      • column2: string

        The name of a column storing geometries.

      • newColumn: string

        The name of the new column with true or false values.

      Returns Promise<void>

      Example: Basic usage

      // Checks if geometries in geomA and in geomB intersect and return true or false in new column inter.
      await table.intersect("geomA", "geomB", "inter")
      -

    intersection

    intersection

    • intersection(column1, column2, newColumn): Promise<void>

    • Computes the intersection of geometries.

      Parameters

      • column1: string

        The names of a column storing geometries.

      • column2: string

        The name of a column storing geometries.

      • newColumn: string

        The name of the new column storing the computed intersections.

      Returns Promise<void>

      Example: Basic usage

      // Computes the intersection of geometries in geomA and geomB columns and puts the new geometries in column inter.
      await table.intersection("geomA", "geomB", "inter")
      -

    isClosedGeo

    • isClosedGeo(newColumn, options?): Promise<void>

    • Adds a column with TRUE if the geometry is closed and FALSE if it's open.

      +

    isClosedGeo

    • isClosedGeo(newColumn, options?): Promise<void>

    • Adds a column with TRUE if the geometry is closed and FALSE if it's open.

      Parameters

      • newColumn: string

        The name of the new column storing the results.

      • options: {
            column?: string;
        } = {}

        An optional object with configuration options:

        • Optionalcolumn?: string

          The column storing geometries.

          @@ -611,7 +611,7 @@

          Example: Specific column storing geometries

          // If the table has more than one column storing geometries, you must specify which column should be used.
          await table.isClosedGeo("closed", { column: "geom" })
          -

    isValidGeo

    • isValidGeo(newColumn, options?): Promise<void>

    • Adds a column with TRUE/FALSE values depending on the validity of geometries.

      +

    isValidGeo

    • isValidGeo(newColumn, options?): Promise<void>

    • Adds a column with TRUE/FALSE values depending on the validity of geometries.

      Parameters

      • newColumn: string

        The name of the new column storing the results.

      • options: {
            column?: string;
        } = {}

        An optional object with configuration options:

        • Optionalcolumn?: string

          The column storing geometries.

          @@ -621,7 +621,7 @@

          Example: Specific column storing geometries

          // If the table has more than one column storing geometries, you must specify which column should be used.
          await table.isValidGeo("valid", { column: "geom" })
          -

    joinGeo

    • joinGeo(rightTable, method, options?): Promise<SimpleWebTable>

    • Merges the data of the table with another table based on a spatial join. Note that the returned data is not guaranteed to be in the same order as the original tables.

      +

    joinGeo

    • joinGeo(rightTable, method, options?): Promise<SimpleWebTable>

    • Merges the data of the table with another table based on a spatial join. Note that the returned data is not guaranteed to be in the same order as the original tables.

      By default, the method looks for a column storing the geometries in each table, does a left join and overwrites leftTable (the current table) with the results. The method also appends the name of the table to the columns storing the geometries if they have the same name in both tables.

      It might create a .tmp folder, so make sure to add .tmp to your gitignore.

      Parameters

      • rightTable: SimpleWebTable

        The right table to be joined.

        @@ -639,14 +639,14 @@

        Example: With options

        // Same thing but with specific column names storing geometries, a specific join type, and returning the results in a new table.
        const tableC = await tableA.joinGeo(tableB, "intersect", { leftTableColumn: "geometriesA", rightTableColumn: "geometriesB", type: "inner", outputTable: true })
        -

    latLon

    • latLon(column, columnLat, columnLon): Promise<void>

    • Extracts the latitude and longitude of points. The input geometry is assumed to be in the EPSG:4326 coordinate system (WGS84), with [latitude, longitude] axis order.

      +

    latLon

    • latLon(column, columnLat, columnLon): Promise<void>

    • Extracts the latitude and longitude of points. The input geometry is assumed to be in the EPSG:4326 coordinate system (WGS84), with [latitude, longitude] axis order.

      Parameters

      • column: string

        The name of the table storing the points.

      • columnLat: string

        The name of the column storing the extracted latitude.

      • columnLon: string

        The name of the column storing the extracted longitude.

      Returns Promise<void>

      Example: Basic usage

      // Extracts the latitude and longitude of points from the points in the "geom" column and put them in the columns "lat" and "lon".
      await table.latLon("geom", "lat", "lon")
      -

    length

    • length(newColumn, options?): Promise<void>

    • Computes the length of line geometries in meters or optionally kilometers. The input geometry is assumed to be in the EPSG:4326 coordinate system (WGS84), with [latitude, longitude] axis order.

      +

    length

    • length(newColumn, options?): Promise<void>

    • Computes the length of line geometries in meters or optionally kilometers. The input geometry is assumed to be in the EPSG:4326 coordinate system (WGS84), with [latitude, longitude] axis order.

      Parameters

      • newColumn: string

        The name of the new column storing the computed lengths.

      • options: {
            column?: string;
            unit?: "m" | "km";
        } = {}

        An optional object with configuration options:

        • Optionalcolumn?: string

          The column storing geometries.

          @@ -660,7 +660,7 @@

          Example: Specific column storing geometries

          // If the table has more than one column storing geometries, you must specify which column should be used.
          await table.length("length", { column: "geom", unit: "km" })
          -

    linesToPolygons

    linesToPolygons

    • linesToPolygons(column?): Promise<void>

    • Transforms closed lines into polygons.

      Parameters

      • Optionalcolumn: string

        The name of a column storing geometries.

      Returns Promise<void>

      Example: Basic usage

      // Transforms geometries into polygons.
      // By default, the method will look for the column storing the geometries.
      await table.linesToPolygons()
      @@ -668,7 +668,7 @@

      Example: Specific column storing geometries

      // If the table has more than one column storing geometries, you must specify which column should be used.
      await table.linesToPolygons("geom")
      -

    nbVertices

    • nbVertices(newColumn, options?): Promise<void>

    • Adds a column with the number of vertices in geometries.

      +

    nbVertices

    • nbVertices(newColumn, options?): Promise<void>

    • Adds a column with the number of vertices in geometries.

      Parameters

      • newColumn: string

        The name of the new column storing the results.

      • options: {
            column?: string;
        } = {}

        An optional object with configuration options:

        • Optionalcolumn?: string

          The column storing geometries.

          @@ -678,7 +678,7 @@

          Example: Specific column storing geometries

          // If the table has more than one column storing geometries, you must specify which column should be used.
          await table.nbVertices("nbVertices", { column: "geom" })
          -

    perimeter

    • perimeter(newColumn, options?): Promise<void>

    • Computes the perimeter of polygon geometries in meters or optionally kilometers. The input geometry is assumed to be in the EPSG:4326 coordinate system (WGS84), with [latitude, longitude] axis order.

      +

    perimeter

    • perimeter(newColumn, options?): Promise<void>

    • Computes the perimeter of polygon geometries in meters or optionally kilometers. The input geometry is assumed to be in the EPSG:4326 coordinate system (WGS84), with [latitude, longitude] axis order.

      Parameters

      • newColumn: string

        The name of the new column storing the computed perimeters.

      • options: {
            column?: string;
            unit?: "m" | "km";
        } = {}

        An optional object with configuration options:

        • Optionalcolumn?: string

          The column storing geometries.

          @@ -692,14 +692,14 @@

          Example: Specific column storing geometries

          // If the table has more than one column storing geometries, you must specify which column should be used.
          await table.perimeter("perim", { unit: "km" })
          -

    points

    • points(columnLat, columnLon, newColumn): Promise<void>

    • Creates point geometries from longitude a latitude columns. The geometries will have [latitude, longitude] axis order.

      +

    points

    • points(columnLat, columnLon, newColumn): Promise<void>

    • Creates point geometries from longitude a latitude columns. The geometries will have [latitude, longitude] axis order.

      Parameters

      • columnLat: string

        The name of the column storing the latitude.

      • columnLon: string

        The name of the column storing the longitude.

      • newColumn: string

        The name of the new column storing the point geometries.

      Returns Promise<void>

      Example: Basic usage

      // Uses the columns "lat" and "lon" to create point geometries in column "geom"
      await table.points("lat", "lon", "geom")
      -

    reducePrecision

    reducePrecision

    • reducePrecision(decimals, options?): Promise<void>

    • Reduce the precision of geometries.

      Parameters

      • decimals: number

        The number of decimal places to keep in the coordinates.

      • options: {
            column?: string;
        } = {}

        An optional object with configuration options:

        • Optionalcolumn?: string

          The column storing geometries.

          @@ -709,14 +709,14 @@

          Example: Specific column storing geometries

          // If the table has more than one column storing geometries, you must specify which column should be used.
          await table.reducePrecision(3, { column : "geom" })
          -

    removeIntersection

    • removeIntersection(column1, column2, newColumn): Promise<void>

    • Removes the intersection of two geometries.

      +

    removeIntersection

    • removeIntersection(column1, column2, newColumn): Promise<void>

    • Removes the intersection of two geometries.

      Parameters

      • column1: string

        The names of a column storing geometries. These are the reference geometries that will be returned without the intersection.

      • column2: string

        The name of a column storing geometries. These are the geometries used to compute the intersection.

      • newColumn: string

        The name of the new column storing the new geometries.

      Returns Promise<void>

      Example: Basic usage

      // Removes the intersection of geomA and geomB from geomA and returns the results in the new column noIntersection. The column order is important.
      await table.removeIntersection("geomA", "geomB", "noIntersection")
      -

    reproject

    • reproject(to, options?): Promise<void>

    • Reprojects the data to another Spatial Reference System (SRS). If you reproject to WGS84 or EPSG:4326, the result will have [latitude, longitude] axis order.

      +

    reproject

    • reproject(to, options?): Promise<void>

    • Reprojects the data to another Spatial Reference System (SRS). If you reproject to WGS84 or EPSG:4326, the result will have [latitude, longitude] axis order.

      Parameters

      • to: string

        The target SRS.

      • options: {
            column?: string;
            from?: string;
        } = {}

        An optional object with configuration options:

        • Optionalcolumn?: string

          The column storing geometries.

          @@ -730,7 +730,7 @@

          Example: Specifying the geometries column

          // If the table has more than one column storing geometries, you must specify which column should be used.
          await table.reproject("EPSG:3347", { column: "geom", from: "EPSG:4326" })
          -

    simplify

    • simplify(tolerance, options?): Promise<void>

    • Simplifies the geometries while preserving their topology. The simplification occurs on an object-by-object basis. A higher tolerance results in a more significant simplification.

      +

    simplify

    • simplify(tolerance, options?): Promise<void>

    • Simplifies the geometries while preserving their topology. The simplification occurs on an object-by-object basis. A higher tolerance results in a more significant simplification.

      Parameters

      • tolerance: number

        A number used for the simplification. A higher tolerance results in a more significant simplification.

      • options: {
            column?: string;
        } = {}

        An optional object with configuration options:

        • Optionalcolumn?: string

          The column storing geometries.

          @@ -740,7 +740,7 @@

          Example: Specific column storing geometries

          // If the table has more than one column storing geometries, you must specify which column should be used.
          await table.simplify(0.1, { column: "geom" })
          -

    typeGeo

    typeGeo

    • typeGeo(newColumn, options?): Promise<void>

    • Adds a column with the geometry type.

      Parameters

      • newColumn: string

        The name of the new column storing the results.

      • options: {
            column?: string;
        } = {}

        An optional object with configuration options:

        • Optionalcolumn?: string

          The column storing geometries.

          @@ -750,14 +750,14 @@

          Example: Specific column storing geometries

          // If the table has more than one column storing geometries, you must specify which column should be used.
          await table.typeGeo("type", { column: "geom" })
          -

    union

    union

    • union(column1, column2, newColumn): Promise<void>

    • Computes the union of geometries.

      Parameters

      • column1: string

        The names of a column storing geometries.

      • column2: string

        The name of a column storing geometries.

      • newColumn: string

        The name of the new column storing the computed unions.

      Returns Promise<void>

      Example: Basic usage

      // Computes the union of geometries in geomA and geomB columns and puts the new geometries in column union.
      await tabele.union("geomA", "geomB", "union")
      -

    unnestGeo

    unnestGeo

    • unnestGeo(column?): Promise<void>

    • Unnests geometries recursively.

      Parameters

      • Optionalcolumn: string

        The name of a column storing geometries.

      Returns Promise<void>

      Example: Basic usage

      // Unnests geometries in the column "geom" and returns the same table with unnested items.
      // By default, the method will look for the column storing the geometries.
      await table.unnestGeo()
      @@ -765,7 +765,7 @@

      Example: Specific column storing geometries

      // If the table has more than one column storing geometries, you must specify which column should be used.
      await table.unnestGeo("geom")
      -

    Getting data

    getBottom

    • getBottom(count, options?): Promise<{
          [key: string]:
              | string
              | number
              | boolean
              | Date
              | null;
      }[]>

    • Returns the bottom n rows, optionally with a condition written as a SQL expression. The last row will be returned first. To keep the original order of the data, use the originalOrder option.

      +

    Getting data

    getBottom

    • getBottom(count, options?): Promise<{
          [key: string]:
              | string
              | number
              | boolean
              | Date
              | null;
      }[]>

    • Returns the bottom n rows, optionally with a condition written as a SQL expression. The last row will be returned first. To keep the original order of the data, use the originalOrder option.

      Parameters

      • count: number

        The number of rows to return.

      • options: {
            condition?: string;
            originalOrder?: boolean;
        } = {}

        An optional object with configuration options:

        • Optionalcondition?: string

          The filtering conditions specified as a SQL WHERE clause. Defaults to no condition.

          @@ -779,7 +779,7 @@

          Example: With a condition

          // Returns the last 10 rows with category being 'Books'.
          const bottom10Books = await table.getBottom(10, { condition: `category = 'Books'` })
          -

    getData

    • getData(options?): Promise<{
          [key: string]:
              | string
              | number
              | boolean
              | Date
              | null;
      }[]>

    • Returns the data with an optional condition.

      +

    getData

    • getData(options?): Promise<{
          [key: string]:
              | string
              | number
              | boolean
              | Date
              | null;
      }[]>

    • Returns the data with an optional condition.

      Parameters

      • options: {
            condition?: string;
        } = {}

        An optional object with configuration options:

        • Optionalcondition?: string

          A SQL WHERE clause condition to filter the data. Defaults to no condition.

      Returns Promise<{
          [key: string]:
              | string
              | number
              | boolean
              | Date
              | null;
      }[]>

      Example: Basic usage

      // Returns all data.
      const data = await table.getData()
@@ -788,12 +788,12 @@ 
      Example: With condition
      // Returns just the rows with a category 'Book'. Conditions are SQL expressions.
      const books = await table.getData({ condition: `category = 'Book'` })
 
      
 
-

    getExtent

    • getExtent(column): Promise<[
          | null
          | string
          | number
          | boolean
          | Date,
          | null
          | string
          | number
          | boolean
          | Date]>

    • Returns the extent from specific column as an array with [min, max] order.

      +

    getExtent

    • getExtent(column): Promise<[
          | null
          | string
          | number
          | boolean
          | Date,
          | null
          | string
          | number
          | boolean
          | Date]>

    • Returns the extent from specific column as an array with [min, max] order.

      const extent = await table.getExtent("column1")

      Parameters

      • column: string

        The name of the column.

        -

      Returns Promise<[
          | null
          | string
          | number
          | boolean
          | Date,
          | null
          | string
          | number
          | boolean
          | Date]>

    getFirstRow

    • getFirstRow(options?): Promise<{
          [key: string]:
              | string
              | number
              | boolean
              | Date
              | null;
      }>

    • Returns the first row with optional filtering conditions written as an SQL expression.

      +

    Returns Promise<[
        | null
        | string
        | number
        | boolean
        | Date,
        | null
        | string
        | number
        | boolean
        | Date]>

    getFirstRow

    • getFirstRow(options?): Promise<{
          [key: string]:
              | string
              | number
              | boolean
              | Date
              | null;
      }>

    • Returns the first row with optional filtering conditions written as an SQL expression.

      Parameters

      • options: {
            condition?: string;
        } = {}

        An optional object with configuration options:

        • Optionalcondition?: string

          The filtering conditions specified as a SQL WHERE clause. Defaults to no condition.

      Returns Promise<{
          [key: string]:
              | string
              | number
              | boolean
              | Date
              | null;
      }>

      Example: Basic usage

      // Returns the first row
      const firstRow = await table.getFirstRow()
@@ -802,7 +802,7 @@ 
      <
 
      Example: With condition
      // Returns the first row with category being 'Book'.
      const firstRowBooks = await table.getFirstRow({ condition: `category = 'Book'` })
 
      
 
-

    getLastRow

    • getLastRow(options?): Promise<{
          [key: string]:
              | string
              | number
              | boolean
              | Date
              | null;
      }>

    • Returns the last row with optional filtering conditions written as an SQL expression.

      +

    getLastRow

    • getLastRow(options?): Promise<{
          [key: string]:
              | string
              | number
              | boolean
              | Date
              | null;
      }>

    • Returns the last row with optional filtering conditions written as an SQL expression.

      Parameters

      • options: {
            condition?: string;
        } = {}

        An optional object with configuration options:

        • Optionalcondition?: string

          The filtering conditions specified as a SQL WHERE clause. Defaults to no condition.

      Returns Promise<{
          [key: string]:
              | string
              | number
              | boolean
              | Date
              | null;
      }>

      Example: Basic usage

      // Returns the last row.
      const lastRow = await table.getLastRow()
@@ -811,12 +811,12 @@ 
      Example: With condition
      // Returns the last row of all rows having a category 'Book'.
      const lastRowBooks = await table.getLastRow({ condition: `category = 'Book'` })
 
      
 
-

    getMax

    • getMax(column): Promise<
          | null
          | string
          | number
          | boolean
          | Date>

    • Returns the maximum value from a specific column.

      +

    getMax

    • getMax(column): Promise<
          | null
          | string
          | number
          | boolean
          | Date>

    • Returns the maximum value from a specific column.

      const maximum = await table.getMax("column1")

      Parameters

      • column: string

        The name of the column.

        -

      Returns Promise<
          | null
          | string
          | number
          | boolean
          | Date>

    getMean

    • getMean(column, options?): Promise<number>

    • Returns the mean value from a specific column.

      +

    Returns Promise<
        | null
        | string
        | number
        | boolean
        | Date>

    getMean

    • getMean(column, options?): Promise<number>

    • Returns the mean value from a specific column.

      Parameters

      • column: string

        The name of the column.

      • options: {
            decimals?: number;
        } = {}

        An optional object with configuration options:

        • Optionaldecimals?: number

          The number of decimal places to round the result to.

          @@ -826,7 +826,7 @@

          Example: Rounding result

          // Same thing but rounding to two decimal places.
          const mean = await table.getMean("column1", { decimals: 2 })
          -

    getMedian

    getMedian

    • getMedian(column, options?): Promise<number>

    • Returns the median value from a specific column.

      Parameters

      • column: string

        The name of the column.

      • options: {
            decimals?: number;
        } = {}

        An optional object with configuration options:

        • Optionaldecimals?: number

          The number of decimal places to round the result to.

          @@ -836,12 +836,12 @@

          Example: Rounding results

          // Same thing but rounding to two decimal places.
          const median = await table.getMedian("column1", { decimals: 2})
          -

    getMin

    • getMin(column): Promise<
          | null
          | string
          | number
          | boolean
          | Date>

    • Returns the minimum value from a specific column.

      +

    getMin

    • getMin(column): Promise<
          | null
          | string
          | number
          | boolean
          | Date>

    • Returns the minimum value from a specific column.

      Parameters

      • column: string

        The name of the column.

      Returns Promise<
          | null
          | string
          | number
          | boolean
          | Date>

      Example: Basic usage

      const minimum = await table.getMin("column1")
      -

    getQuantile

    • getQuantile(column, quantile, options?): Promise<number>

    • Returns the value of a specific quantile from the values in a given column.

      +

    getQuantile

    • getQuantile(column, quantile, options?): Promise<number>

    • Returns the value of a specific quantile from the values in a given column.

      Parameters

      • column: string

        The name of the column from which to calculate the quantile.

      • quantile: number

        The quantile (between 0 and 1) to calculate. For example, 0.25 for the first quartile.

      • options: {
            decimals?: number;
        } = {}

        An optional object with configuration options:

        @@ -852,7 +852,7 @@

        Example: Rounding result

        // Same thing but rounding to two decimal places.
        const firstQuartile = await table.getQuantile("column1", 0.25, { decimals: 2 })
        -

    getSkew

    getSkew

    • getSkew(column, options?): Promise<number>

    • Returns the skewness of values from a specific column.

      Parameters

      • column: string

        The name of the column.

      • options: {
            decimals?: number;
        } = {}

        An optional object with configuration options:

        • Optionaldecimals?: number

          The number of decimal places to round the result to.

          @@ -862,7 +862,7 @@

          Example: Rounding result

          // Same thing but rounding to two decimal places.
          const skew = await table.getSkew("column1", { decimals: 2})
          -

    getStdDev

    • getStdDev(column, options?): Promise<number>

    • Returns the standard deviation of values from a specific column.

      +

    getStdDev

    • getStdDev(column, options?): Promise<number>

    • Returns the standard deviation of values from a specific column.

      Parameters

      • column: string

        The name of the column.

      • options: {
            decimals?: number;
        } = {}

        An optional object with configuration options:

        • Optionaldecimals?: number

          The number of decimal places to round the result to.

          @@ -872,12 +872,12 @@

          Example: Rounding result

          // Same thing but rounding to two decimal places.
          const standardDeviation = await table.getStdDev("column1", { decimals: 2 })
          -

    getSum

    getSum

    • getSum(column): Promise<number>

    • Returns the sum of values from a specific column.

      Parameters

      • column: string

        The name of the column.

      Returns Promise<number>

      Example: Basic usage

      const sum = await table.getSum("column1")
      -

    getTop

    • getTop(count, options?): Promise<{
          [key: string]:
              | string
              | number
              | boolean
              | Date
              | null;
      }[]>

    • Returns the top n rows, optionally with a condition written as an SQL expression.

      +

    getTop

    • getTop(count, options?): Promise<{
          [key: string]:
              | string
              | number
              | boolean
              | Date
              | null;
      }[]>

    • Returns the top n rows, optionally with a condition written as an SQL expression.

      Parameters

      • count: number

        The number of rows to return.

      • options: {
            condition?: string;
        } = {}

        An optional object with configuration options:

        • Optionalcondition?: string

          The filtering conditions specified as a SQL WHERE clause. Defaults to no condition.

          @@ -887,17 +887,17 @@

          Example: With a condition

          // Returns the first 10 rows with category being 'Books'.
          const top10Books = await table.getTop(10, { condition: `category = 'Books'` })
          -

    getUniques

    • getUniques(column): Promise<(
          | null
          | string
          | number
          | boolean
          | Date)[]>

    • Returns unique values from a specific column. For convenience, it returns the value ascendingly.

      +

    getUniques

    • getUniques(column): Promise<(
          | null
          | string
          | number
          | boolean
          | Date)[]>

    • Returns unique values from a specific column. For convenience, it returns the value ascendingly.

      Parameters

      • column: string

        The name of the column from which to retrieve unique values.

      Returns Promise<(
          | null
          | string
          | number
          | boolean
          | Date)[]>

      Example: Basic usage

      const uniques = await table.getUniques("column1")
      -

    getValues

    • getValues(column): Promise<(
          | null
          | string
          | number
          | boolean
          | Date)[]>

    • Returns the values of a specific column.

      +

    getValues

    • getValues(column): Promise<(
          | null
          | string
          | number
          | boolean
          | Date)[]>

    • Returns the values of a specific column.

      Parameters

      • column: string

        The name of the column.

      Returns Promise<(
          | null
          | string
          | number
          | boolean
          | Date)[]>

      Example: Basic usage

      const values = await table.getValues("column1")
      -

    getVar

    getVar

    • getVar(column, options?): Promise<number>

    • Returns the variance of values from a specific column.

      Parameters

      • column: string

        The name of the column.

      • options: {
            decimals?: number;
        } = {}

        An optional object with configuration options:

        • Optionaldecimals?: number

          The number of decimal places to round the result to.

          @@ -907,7 +907,7 @@

          Example: Rounding result

          // Same thing but rounding to two decimal places
          const variance = await table.getVar("column1")
          -

    Importing data

    fetchData

    Importing data

    fetchData

    • fetchData(url, options?): Promise<SimpleWebTable>

    • Fetch data from an url into the table. This method is just for the web. For NodeJS and other runtimes, use loadData.

      Parameters

      • url: string

        The URL of the external file containing the data. CSV, JSON, and PARQUET files are accepted.

      • options: {
            autoDetect?: boolean;
            delim?: string;
            fileType?:
                | "csv"
                | "dsv"
                | "json"
                | "parquet";
            header?: boolean;
            skip?: number;
        } = {}

        An optional object with configuration options:

        • OptionalautoDetect?: boolean

          A boolean indicating whether to automatically detect the data format. Defaults to true.

          @@ -918,12 +918,12 @@

      Returns Promise<SimpleWebTable>

      Example: Basic usage

      await table.fetchData("https://some-website.com/some-data.csv")
      -

    insertRows

    insertRows

    • insertRows(rows): Promise<void>

    • Inserts rows formatted as an array of objects into the table.

      Parameters

      • rows: {
            [key: string]: unknown;
        }[]

        An array of objects representing the rows to be inserted into the table.

      Returns Promise<void>

      Example: Basic usage

      const rows = [{ letter: "a", number: 1 }, { letter: "b", number: 2 }]
      await table.insertRows(rows)
      -

    insertTables

    • insertTables(tablesToInsert): Promise<void>

    • Inserts all rows from another table (or multiple tables) into this table.

      +

    insertTables

    • insertTables(tablesToInsert): Promise<void>

    • Inserts all rows from another table (or multiple tables) into this table.

      Parameters

      Returns Promise<void>

      Example: Basic usage with one table

      // Insert all rows from tableB into this table.
      await tableA.insertTables("tableB")
      @@ -931,12 +931,12 @@

      Example: With multiple tables

      // Insert all rows from tableB and tableC into this table.
      await tableA.insertTables([ "tableB", "tableC" ])
      -

    loadArray

    loadArray

    • loadArray(arrayOfObjects): Promise<SimpleWebTable>

    • Loads an array of objects into the table.

      Parameters

      • arrayOfObjects: {
            [key: string]: unknown;
        }[]

        An array of objects representing the data.

      Returns Promise<SimpleWebTable>

      Example: Basic usage

      const data = [{ letter: "a", number: 1 }, { letter: "b", number: 2 }]
      await table.loadArray(data)
      -

    Restructuring data

    addColumn

    • addColumn(newColumn, type, definition, options?): Promise<void>

    • Adds a new column based on a type (JavaScript or SQL types) and a SQL definition.

      +

    Restructuring data

    addColumn

    addRowNumber

    addRowNumber

    • addRowNumber(newColumn): Promise<void>

    • Adds a new column with the row number.

      Parameters

      • newColumn: string

        The name of the new column storing the row number

      Returns Promise<void>

      Example: Basic usage

      // Adds the row number in new column rowNumber.
      await table.addRowNumber("rowNumber")
      -

    cleanColumnNames

    • cleanColumnNames(): Promise<void>

    • Cleans column names by removing non-alphanumeric characters and formats them to camel case.

      +

    cleanColumnNames

    • cleanColumnNames(): Promise<void>

    • Cleans column names by removing non-alphanumeric characters and formats them to camel case.

      Returns Promise<void>

      Example: Basic usage

      await table.cleanColumnNames()
      -

    cloneColumn

    cloneColumn

    • cloneColumn(originalColumn, newColumn): Promise<void>

    • Clones a column in this table.

      Parameters

      • originalColumn: string

        The original column.

      • newColumn: string

        The name of the cloned column.

      Returns Promise<void>

      Example: Basic usage

      // Clones column1 as column2
      await table.cloneColumn("column1", "column2")
      -

    cloneColumnWithOffset

    • cloneColumnWithOffset(originalColumn, newColumn): Promise<void>

    • Clones a column in the table and offsets the values down by one row. The last row will have a NULL value.

      +

    cloneColumnWithOffset

    • cloneColumnWithOffset(originalColumn, newColumn): Promise<void>

    • Clones a column in the table and offsets the values down by one row. The last row will have a NULL value.

      Parameters

      • originalColumn: string

        The original column.

      • newColumn: string

        The name of the cloned column.

      Returns Promise<void>

      Example: Basic usage

      // Clones column1 as column2 and offsets values by 1. So value of column1-row1 will be in column2-row2, column1-row2 will be in column2-row3, etc.
      await table.cloneColumnWithOffset("column1", "column2")
      -

    convert

    • convert(types, options?): Promise<void>

    • Converts data types (JavaScript or SQL types) of specified columns.

      +

    convert

    • convert(types, options?): Promise<void>

    • Converts data types (JavaScript or SQL types) of specified columns.

      If you convert timestamps, dates, or times to strings, you need to pass format specifiers as datetimeFormat option. Same to convert strings to timestamps, dates or times.

      If you convert timestamps, dates, or times to numbers, the result will be the number of milliseconds since 1970-01-01 00:00:00. If you convert numbers to timestamps, dates, or times, the same logic applies.

      If you convert strings to numbers, commas (which are often used as thousand separators) will be removed before converting.

      @@ -987,7 +987,7 @@

      <

      Example: With dates

      // Converts strings in a specific format to dates
      await table.convert({ column3: "datetime"}, { datetimeFormat: "%Y-%m-%d" })

      // Converts dates to strings with a specific format.
      await table.convert({ column3: "datetime" }, { datetimeFormat: "%Y-%m-%d" })
      -

    crossJoin

    • crossJoin(rightTable, options?): Promise<SimpleWebTable>

    • Performs a cross join operation between this table and another table, returning all pairs of rows. This table is considered the left table. Note that the returned rows are not guaranteed to be in the same order. It might create a .tmp folder, so make sure to add .tmp to your gitignore.

      +

    crossJoin

    • crossJoin(rightTable, options?): Promise<SimpleWebTable>

    • Performs a cross join operation between this table and another table, returning all pairs of rows. This table is considered the left table. Note that the returned rows are not guaranteed to be in the same order. It might create a .tmp folder, so make sure to add .tmp to your gitignore.

      Parameters

      • rightTable: SimpleWebTable

        The right table.

      • options: {
            outputTable?: string | boolean;
        } = {}

        An optional object with configuration options:

        • OptionaloutputTable?: string | boolean

          To return a new table with the results.

          @@ -1000,7 +1000,7 @@

          Example: Results in a new table with a specific name in the DB

          // Returns the resuts in a newTable
          const tableC = await tableA.crossJoin(tableB, { outputTable: "tableC" });
          -

    join

    • join(rightTable, options?): Promise<SimpleWebTable>

    • Merges the data of this table with another table based on a common column. This table is considered the left table. Note that the returned data is not guaranteed to be in the same order as the original tables. It might create a .tmp folder, so make sure to add .tmp to your gitignore.

      +

    join

    • join(rightTable, options?): Promise<SimpleWebTable>

    • Merges the data of this table with another table based on a common column. This table is considered the left table. Note that the returned data is not guaranteed to be in the same order as the original tables. It might create a .tmp folder, so make sure to add .tmp to your gitignore.

      Parameters

      • rightTable: SimpleWebTable

        The right table to be joined.

      • options: {
            commonColumn?: string;
            outputTable?: string | boolean;
            type?:
                | "inner"
                | "left"
                | "right"
                | "full";
        } = {}

        An optional object with configuration options:

        • OptionalcommonColumn?: string

          The common column used for the join operation. By default, the method automatically searches for a column name that exists in both tables.

          @@ -1012,7 +1012,7 @@

          Example: With options

          // You can change the common column, the join type, and the output table in options.
          const tableC = await tableA.join("tableB", { commonColumn: 'id', type: 'inner', outputTable: true })
          -

    longer

    • longer(columns, columnsTo, valuesTo): Promise<void>

    • Restructures this table by stacking values. Useful to tidy up data.

      +

    longer

    • longer(columns, columnsTo, valuesTo): Promise<void>

    • Restructures this table by stacking values. Useful to tidy up data.

      As an example, let's use this table. It shows the number of employees per year in different departments.

    @@ -1087,26 +1087,26 @@

    <

    -

removeColumns

removeColumns

  • removeColumns(columns): Promise<void>

  • Removes one or more columns from this table.

    Parameters

    • columns: string | string[]

      The name or an array of names of the columns to be removed.

    Returns Promise<void>

    Example: Basic usage

    await table.removeColumns(["column1", "column2"])
    -

removeTable

  • removeTable(): Promise<void>

  • Remove the table from the database. Invoking methods on this table will throw and error.

    +

removeTable

  • removeTable(): Promise<void>

  • Remove the table from the database. Invoking methods on this table will throw and error.

    Returns Promise<void>

    Example: Basic usage

    await table.removeTable()
    -

renameColumns

renameColumns

  • renameColumns(names): Promise<void>

  • Renames columns in the table.

    Parameters

    • names: {
          [key: string]: string;
      }

      An object mapping old column names to new column names.

      • [key: string]: string

    Returns Promise<void>

    Example: Basic usage

    // Renaming "How old?" to "age" and "Man or woman?" to "sex".
    await table.renameColumns({ "How old?" : "age", "Man or woman?": "sex" })
    -

selectColumns

  • selectColumns(columns): Promise<void>

  • Selects specific columns in the table and removes the others.

    +

selectColumns

  • selectColumns(columns): Promise<void>

  • Selects specific columns in the table and removes the others.

    Parameters

    • columns: string | string[]

      Either a string (one column) or an array of strings (multiple columns) representing the columns to be selected.

    Returns Promise<void>

    Example: Basic usage

    // Selecting only the columns firstName and lastName. All other columns in the table will be removed.
    await table.selectColumns([ "firstName", "lastName" ])
    -

sort

sort

  • sort(order, options?): Promise<void>

  • Sorts the rows based on specified column(s) and order(s).

    Parameters

    • order: {
          [key: string]: "asc" | "desc";
      }

      An object mapping column names to the sorting order: "asc" for ascending or "desc" for descending.

      • [key: string]: "asc" | "desc"
    • options: {
          lang?: {
              [key: string]: string;
          };
      } = {}

      An optional object with configuration options:

      • Optionallang?: {
            [key: string]: string;
        }

        An object mapping column names to language codes. See DuckDB Collations documentation for more: https://duckdb.org/docs/sql/expressions/collations.

        @@ -1119,7 +1119,7 @@

        Example: Languages and special characters

        // Taking French accent into account in column1
        await table.sort({ column1: "asc", column2: "desc" }, { lang: { column1: "fr" }})
        -

wider

wider

  • wider(columnsFrom, valuesFrom): Promise<void>

  • Restructures this table by unstacking values.

    As an example, let's use this table. It shows the number of employees per year in different departments.

    @@ -1193,7 +1193,7 @@

    -

Selecting or filtering data

filter

  • filter(conditions): Promise<void>

  • Filters rows from this table based on SQL conditions. Note that it's often faster to use the removeRows method.

    +

Selecting or filtering data

filter

  • filter(conditions): Promise<void>

  • Filters rows from this table based on SQL conditions. Note that it's often faster to use the removeRows method.

    Parameters

    • conditions: string

      The filtering conditions specified as a SQL WHERE clause.

    Returns Promise<void>

    Example: Basic usage

    // Keeps only rows where the fruit is not an apple.
    await table.filter(`fruit != 'apple'`)
    @@ -1201,23 +1201,23 @@

    Example: More examples

    await table.filter(`price > 100 AND quantity > 0`)
    await table.filter(`category = 'Electronics' OR category = 'Appliances'`)
    await table.filter(`lastPurchaseDate >= '2023-01-01'`)
    -

keep

keep

  • keep(columnsAndValues): Promise<void>

  • Keeps rows with specific values in specific columns.

    Parameters

    • columnsAndValues: {
          [key: string]: unknown[];
      }

      An object with the columns (keys) and the values to be kept (values as arrays)

      • [key: string]: unknown[]

    Returns Promise<void>

    Example: Basic usage

    // Keeps only rows where the job is 'accountant' or 'developer' and where the city is 'Montreal'.
    await table.keep({ job: ["accountant", "developer"], city: ["Montreal"] })
    -

remove

remove

  • remove(columnsAndValues): Promise<void>

  • Remove rows with specific values in specific columns.

    Parameters

    • columnsAndValues: {
          [key: string]: unknown[];
      }

      An object with the columns (keys) and the values to be removed (values as arrays)

      • [key: string]: unknown[]

    Returns Promise<void>

    Example: Basic usage

    // Remove rows where the job is 'accountant' or 'developer' and where the city is 'Montreal'.
    await table.remove({ job: ["accountant", "developer"], city: ["Montreal"] })
    -

removeDuplicates

  • removeDuplicates(options?): Promise<void>

  • Removes duplicate rows from this table, keeping unique rows. Note that SQL does not guarantee any specific order when using DISTINCT. So the data might be returned in a different order than the original.

    +

removeDuplicates

  • removeDuplicates(options?): Promise<void>

  • Removes duplicate rows from this table, keeping unique rows. Note that SQL does not guarantee any specific order when using DISTINCT. So the data might be returned in a different order than the original.

    Parameters

    • options: {
          on?: string | string[];
      } = {}

      An optional object with configuration options:

      • Optionalon?: string | string[]

        A column or multiple columns to consider to remove duplicates. The other columns in the table will not be considered to exclude duplicates.

    Returns Promise<void>

    Example: Basic usage

    await table.removeDuplicates("tableA")
    -

removeMissing

  • removeMissing(options?): Promise<void>

  • Removes rows with missing values from this table. By default, missing values are NULL (as an SQL value), but also "NULL", "null", "NaN" and "undefined" that might have been converted to strings before being loaded into the table. Empty strings "" are also considered missing values.

    +

removeMissing

  • removeMissing(options?): Promise<void>

  • Removes rows with missing values from this table. By default, missing values are NULL (as an SQL value), but also "NULL", "null", "NaN" and "undefined" that might have been converted to strings before being loaded into the table. Empty strings "" are also considered missing values.

    Parameters

    • options: {
          columns?: string | string[];
          invert?: boolean;
          missingValues?: (string | number)[];
      } = {}

      An optional object with configuration options:

      • Optionalcolumns?: string | string[]

        Either a string or an array of strings specifying the columns to consider for missing values. By default, all columns are considered.

      • Optionalinvert?: boolean

        A boolean indicating whether to invert the condition, keeping only rows with missing values. Defaults to false.

        @@ -1228,12 +1228,12 @@

        Example: Specific columns

        // Removes rows with missing values in specific columns.
        await table.removeMissing({ columns: ["firstName", "lastName"] })
        -

removeRows

removeRows

  • removeRows(conditions): Promise<void>

  • Removes rows from this table based on SQL conditions.

    Parameters

    • conditions: string

      The filtering conditions specified as a SQL WHERE clause.

    Returns Promise<void>

    Example: Basic usage

    // Removes rows where the fruit is an apple.
    await table.removeRows(`fruit = 'apple'`)
    -

sample

  • sample(quantity, options?): Promise<void>

  • Selects random rows from the table and removes the others. You can optionally specify a seed to ensure the same random rows are selected each time.

    +

sample

  • sample(quantity, options?): Promise<void>

  • Selects random rows from the table and removes the others. You can optionally specify a seed to ensure the same random rows are selected each time.

    Parameters

    • quantity: string | number

      The number of rows (1000 for example) or a string ("10%" for example) specifying the sampling size.

    • options: {
          seed?: number;
      } = {}

      An optional object with configuration options:

      • Optionalseed?: number

        A number specifying the seed for repeatable sampling. For example, setting it to 1 will ensure random rows will be the same each time you run the method.

        @@ -1246,7 +1246,7 @@

        Example: With a seed

        // Selects always the same random rows
        await table.sample("10%", { seed: 1 })
        -

selectRows

selectRows

  • selectRows(count, options?): Promise<SimpleWebTable>

  • Selects n rows from this table. An offset and outputTable options are available.

    Parameters

    • count: string | number

      The number of rows.

    • options: {
          offset?: number;
          outputTable?: string | boolean;
      } = {}

      An optional object with configuration options:

      • Optionaloffset?: number

        The number of rows to skip before selecting. Defaults to 0.

        @@ -1263,12 +1263,12 @@

        Example: Into a new table with a specific name in the DB

        // Selects 100 rows and stores them in a new table.
        const tableB = await tableA.selectRows(100, { outputTable: "tableB" })
        -

skip

skip

  • skip(nbRowsToSkip): Promise<void>

  • Skips the first X rows.

    Parameters

    • nbRowsToSkip: number

      The number of rows to skip.

    Returns Promise<void>

    Example: Basic usage

    // Skips the first 10 rows.
    await table.skip(10)
    -

Updating data

concatenate

  • concatenate(columns, newColumn, options?): Promise<void>

  • Concatenates values from specified columns into a new column.

    +

Updating data

concatenate

  • concatenate(columns, newColumn, options?): Promise<void>

  • Concatenates values from specified columns into a new column.

    Parameters

    • columns: string[]

      An array of column names from which values will be concatenated.

    • newColumn: string

      The name of the new column to store the concatenated values.

    • options: {
          separator?: string;
      } = {}

      An optional object with configuration options:

      @@ -1279,18 +1279,18 @@

      Example: With a separator

      // Same thing, but the values will be separated by a dash
      await table.concatenate(["column1", "column2"], "column3", { separator: "-" })
      -

fill

  • fill(columns): Promise<void>

  • Fills cells containing NULL values. If a cell is empty, it's filled with the previous row's value.

    +

fill

  • fill(columns): Promise<void>

  • Fills cells containing NULL values. If a cell is empty, it's filled with the previous row's value.

    Parameters

    • columns: string | string[]

      The columns to fill.

    Returns Promise<void>

    Example: Basic usage

    await table.fill("column1")
    -

left

  • left(column, numberOfCharacters): Promise<void>

  • Extracts a specific number of characters, starting from the left.

    +

left

  • left(column, numberOfCharacters): Promise<void>

  • Extracts a specific number of characters, starting from the left.

    Parameters

    • column: string

      The name of the column storing the strings

    • numberOfCharacters: number

      The number of characters, starting from the left

    Returns Promise<void>

    Example: Basic usage

    // Strings in column1 will be replaced by the first two characters of each string.
    await table.left("column1", 2)
    -

lower

lower

  • lower(columns): Promise<void>

  • Formats strings to lowercase.

    Parameters

    • columns: string | string[]

      Either a string or an array of strings specifying the columns to be updated.

    Returns Promise<void>

    Example: Basic usage

    await table.lower("column1")
    @@ -1298,7 +1298,7 @@

    Example: Multiple columns

    await table.lower(["column1", "column2"])
    -

replace

  • replace(columns, strings, options?): Promise<void>

  • Replaces specified strings in the selected columns

    +

replace

  • replace(columns, strings, options?): Promise<void>

  • Replaces specified strings in the selected columns

    Parameters

    • columns: string | string[]

      Either a string or an array of strings specifying the columns where string replacements will occur.

    • strings: {
          [key: string]: string;
      }

      An object mapping old strings to new strings.

      • [key: string]: string
    • options: {
          entireString?: boolean;
          regex?: boolean;
      } = {}

      An optional object with configuration options:

      @@ -1316,19 +1316,19 @@

      Example: Regular expression

      // Replaces using a regular expression. Any sequence of one or more digits would be replaced by a hyphen.
      await table.replace("column1", {"\d+": "-" }, {regex: true})
      -

replaceNulls

replaceNulls

  • replaceNulls(columns, value): Promise<void>

  • Replaces null values in the selected columns.

    Parameters

    • columns: string | string[]

      Either a string or an array of strings specifying the columns where string replacements will occur.

    • value:
          | string
          | number
          | boolean
          | Date

      The value to replace the null values.

    Returns Promise<void>

    Example: Basic usage

    // Replace null values by 0.
    await table.replaceNulls("column1", 0)
    -

right

  • right(column, numberOfCharacters): Promise<void>

  • Extracts a specific number of characters, starting from the right.

    +

right

  • right(column, numberOfCharacters): Promise<void>

  • Extracts a specific number of characters, starting from the right.

    Parameters

    • column: string

      The name of the column storing the strings

    • numberOfCharacters: number

      The number of characters, starting from the right

    Returns Promise<void>

    Example: Basic usage

    // Strings in column1 will be replaced by the last two characters of each string.
    await table.right("column1", 2)
    -

round

round

  • round(columns, options?): Promise<void>

  • Rounds numeric values in specified columns.

    Parameters

    • columns: string | string[]

      Either a string or an array of strings specifying the columns containing numeric values to be rounded.

    • options: {
          decimals?: number;
          method?: "round" | "ceiling" | "floor";
      } = {}

      An optional object with configuration options:

      • Optionaldecimals?: number

        The number of decimal places to round to. Defaults to 0.

        @@ -1342,14 +1342,14 @@

        Example: Specific rounding method

        // Rounds column1's values with a specific method. Available methods are "round", "floor" and "ceiling".
        await table.round("column1", { method: "floor" })
        -

splitExtract

  • splitExtract(column, separator, index): Promise<void>

  • Splits strings along a separator and replaces the values with a substring at a specified index (starting at 0). If the index is outside the bounds of the list, return an empty string.

    +

splitExtract

  • splitExtract(column, separator, index): Promise<void>

  • Splits strings along a separator and replaces the values with a substring at a specified index (starting at 0). If the index is outside the bounds of the list, return an empty string.

    Parameters

    • column: string

      The name of the column storing the strings

    • separator: string

      The substring to use as a separator

    • index: number

      The index of the substring to replace values

    Returns Promise<void>

    Example: Basic usage

    // Splits on commas and replaces values with the second substring.
    await table.splitExtract("column1", ",", 1)
    -

trim

  • trim(columns, options?): Promise<void>

  • Trims specified characters from the beginning, end, or both sides of string values.

    +

trim

  • trim(columns, options?): Promise<void>

  • Trims specified characters from the beginning, end, or both sides of string values.

    Parameters

    • columns: string | string[]

      The column or columns to trim.

    • options: {
          character?: string;
          method?: "leftTrim" | "rightTrim" | "trim";
      } = {}

      An optional object with configuration options:

      • Optionalcharacter?: string

        The string to trim. Defaults to whitespace.

        @@ -1360,23 +1360,23 @@

        Example: Multiple column

        // Trims values in column2, columns3, and column4
        await table.trim(["column2", "column3", "column4"])
        -

updateColumn

  • updateColumn(column, definition): Promise<void>

  • Updates values in a specified column with a SQL expression.

    +

updateColumn

  • updateColumn(column, definition): Promise<void>

  • Updates values in a specified column with a SQL expression.

    Parameters

    • column: string

      The name of the column to be updated.

    • definition: string

      The SQL expression to set the new values in the column.

    Returns Promise<void>

    Example: Basic usage

    await table.updateColumn("column1", `LEFT(column2)`)
    -

updateWithJS

  • updateWithJS(dataModifier): Promise<void>

  • Updates data using a JavaScript function. The function takes the existing rows as an array of objects and must return them modified as an array of objects. This method provides a flexible way to update data, but it's slow. This won't work with tables containing geometries.

    +

updateWithJS

  • updateWithJS(dataModifier): Promise<void>

  • Updates data using a JavaScript function. The function takes the existing rows as an array of objects and must return them modified as an array of objects. This method provides a flexible way to update data, but it's slow. This won't work with tables containing geometries.

    Parameters

    • dataModifier: ((rows: {
          [key: string]:
              | number
              | string
              | Date
              | boolean
              | null;
      }[]) => Promise<{
          [key: string]:
              | number
              | string
              | Date
              | boolean
              | null;
      }[]>) | ((rows: {
          [key: string]:
              | number
              | string
              | Date
              | boolean
              | null;
      }[]) => {
          [key: string]:
              | number
              | string
              | Date
              | boolean
              | null;
      }[])

      A function that takes the existing rows and returns modified rows using JavaScript logic. The original rows are objects in an array and the modified rows must be returned as an array of objects too.

    Returns Promise<void>

    Example: Basic usage

    // Adds one to the values from column1. If the values are not numbers, they are replaced by null.
    await table.updateWithJS((rows) => {
     const modifiedRows = rows.map(d => ({
         ...d,
         column1: typeof d.column1 === "number" ? d.column1 + 1 : null
     }))
     return modifiedRows
    })
    -

upper

upper

  • upper(columns): Promise<void>

  • Formats strings to uppercase.

    Parameters

    • columns: string | string[]

      Either a string or an array of strings specifying the columns to be updated.

    Returns Promise<void>

    Example: Basic usage

    await table.upper("tableA", "column1")

    @example Multiple columns
    await table.upper(["column1", "column2"])
    -

Other

cloneTable

  • cloneTable(options?): Promise<SimpleWebTable>

  • Returns a new table with the same structure and data as this table. The data can be optionally filtered. This can be very slow with big tables.

    +

Other

cloneTable

  • cloneTable(options?): Promise<SimpleWebTable>

  • Returns a new table with the same structure and data as this table. The data can be optionally filtered. This can be very slow with big tables.

    Parameters

    • options: {
          condition?: string;
          outputTable?: string;
      } = {}

      An optional object with configuration options:

      • Optionalcondition?: string

        A SQL WHERE clause condition to filter the data. Defaults to no condition.

      • OptionaloutputTable?: string

        The name in the DB of the new table that will be created as a clone.

        @@ -1389,43 +1389,43 @@

        Example: Cloning with condition

        // Creating tableB as a clone of tableA. Only rows with values greater than 10 in column1 are cloned.
        const tableB = await tableA.cloneTable({ condition: `column1 > 10` })
        -

getColumns

getColumns

  • getColumns(): Promise<string[]>

  • Return the list of column names.

    const columns = await table.getColumns()
    -

    Returns Promise<string[]>

getDescription

  • getDescription(): Promise<{
        [key: string]: unknown;
    }[]>

  • Returns descriptive information about the columns, including details like data types, number of null and distinct values. Best to look at with console.table.

    +

    Returns Promise<string[]>

getDescription

  • getDescription(): Promise<{
        [key: string]: unknown;
    }[]>

  • Returns descriptive information about the columns, including details like data types, number of null and distinct values. Best to look at with console.table.

    Returns Promise<{
        [key: string]: unknown;
    }[]>

    Example: Basic usage

    const description = await table.getDescription()
    -

getNbColumns

getNbColumns

  • getNbColumns(): Promise<number>

  • Returns the number of columns.

    Returns Promise<number>

    Example: Basic usage

    const nbColumns = await table.getNbColumns()
    -

getNbRows

getNbRows

  • getNbRows(): Promise<number>

  • Returns the number of rows in a table.

    Returns Promise<number>

    Example: Basic usage

    const nbRows = await table.getNbRows()
    -

getNbValues

  • getNbValues(): Promise<number>

  • Returns the number of values (number of columns * number of rows) in a table.

    +

getNbValues

  • getNbValues(): Promise<number>

  • Returns the number of values (number of columns * number of rows) in a table.

    Returns Promise<number>

    Example: Basic usage

    const nbValues = await table.getNbValues()
    -

getSchema

  • getSchema(): Promise<{
        [key: string]: string | null;
    }[]>

  • Returns the schema (column names and their data types).

    +

getSchema

  • getSchema(): Promise<{
        [key: string]: string | null;
    }[]>

  • Returns the schema (column names and their data types).

    Returns Promise<{
        [key: string]: string | null;
    }[]>

    Example: Basic usage

    const schema = await table.getSchema()
    -

getTypes

getTypes

  • getTypes(): Promise<{
        [key: string]: string;
    }>

  • Returns the data types of columns.

    Returns Promise<{
        [key: string]: string;
    }>

    Example: Basic usage

    const dataTypes = await table.getTypes()
    -

hasColumn

hasColumn

  • hasColumn(column): Promise<boolean>

  • Returns TRUE if the table has the column and FALSE otherwise.

    Parameters

    • column: string

    Returns Promise<boolean>

    Example: Basic usage

    const bool = await table.hasColum("name")
    -

logDescription

  • logDescription(): Promise<void>

  • Logs descriptive information about the columns, including details like data types, number of null and distinct values. It calls getDescription.

    +

logDescription

  • logDescription(): Promise<void>

  • Logs descriptive information about the columns, including details like data types, number of null and distinct values. It calls getDescription.

    Returns Promise<void>

    Example: Basic usage

    await table.logDescription()
    -

logTable

logTable

  • logTable(nbRowsToLog?): Promise<void>

  • Logs a specified number of rows. Default is 10 rows.

    Parameters

    • OptionalnbRowsToLog: number

      The number of rows to log when debugging. Defaults to 10 or the value set in the SimpleWebDB instance.

    Returns Promise<void>

    Example: Basic usage

    // Logs first 10 rows
    await table.logTable();
    @@ -1433,14 +1433,14 @@

    Example: Specific number of rows

    // Logs first 100 rows
    await table.logTable(100);
    -

renameTable

renameTable

  • renameTable(name): Promise<void>

  • Rename the table.

    Parameters

    • name: string

      New name for the table

    Returns Promise<void>

    Example: Basic usage

    await table.renameTable("newName")
    -

setTypes

setTypes

  • setTypes(types): Promise<void>

  • Set the types in the table.

    Parameters

    • types: {
          [key: string]:
              | "integer"
              | "float"
              | "number"
              | "string"
              | "date"
              | "time"
              | "datetime"
              | "datetimeTz"
              | "bigint"
              | "double"
              | "varchar"
              | "timestamp"
              | "timestamp with time zone"
              | "boolean"
              | "geometry";
      }

      An object specifying the columns and their data types (JavaScript or SQL).

      • [key: string]:
            | "integer"
            | "float"
            | "number"
            | "string"
            | "date"
            | "time"
            | "datetime"
            | "datetimeTz"
            | "bigint"
            | "double"
            | "varchar"
            | "timestamp"
            | "timestamp with time zone"
            | "boolean"
            | "geometry"

    Returns Promise<void>

    Example: Basic usage

     await table.setTypes({
        name: "string",
        salary: "integer",
        raise: "float",
    })
    -

Settings

Member Visibility

On This Page

Properties
Analyzing data
Geospatial
Getting data
Importing data
Restructuring data
Selecting or filtering data
Updating data
Other
+

Settings

Member Visibility

On This Page

Properties
Analyzing data
Geospatial
Getting data
Importing data
Restructuring data
Selecting or filtering data
Updating data
Other
diff --git a/docs/hierarchy.html b/docs/hierarchy.html index c993882a..917a5560 100644 --- a/docs/hierarchy.html +++ b/docs/hierarchy.html @@ -1 +1 @@ -Simple-data-analysis - v3.6.2

Simple-data-analysis - v3.6.2

Class Hierarchy

Settings

Member Visibility
+Simple-data-analysis - v3.6.3

Simple-data-analysis - v3.6.3

Class Hierarchy

Settings

Member Visibility
diff --git a/docs/index.html b/docs/index.html index 655a997f..4b42219b 100644 --- a/docs/index.html +++ b/docs/index.html @@ -1,4 +1,4 @@ -Simple-data-analysis - v3.6.2

Simple-data-analysis - v3.6.2

Simple data analysis (SDA)

SDA is an easy-to-use and high-performance JavaScript library for data analysis. You can use it with tabular and geospatial data.

+Simple-data-analysis - v3.6.3

Simple-data-analysis - v3.6.3

Simple data analysis (SDA)

SDA is an easy-to-use and high-performance JavaScript library for data analysis. You can use it with tabular and geospatial data.

The documentation is available here. Tests are run for Node.js and Bun.

To use the library in your browser, check out simple-data-analysis-flow. You might also find the journalism library and Code Like a Journalist interesting.

The library is maintained by Nael Shiab, computational journalist and senior data producer for CBC News.

@@ -103,4 +103,4 @@

Others

If you want to generate and save charts with Node.js and other runtimes, check the journalism library, more specifically the savePlotChart function.

-

Settings

Member Visibility

On This Page

Simple data analysis (SDA)
+

Settings

Member Visibility

On This Page

Simple data analysis (SDA)
diff --git a/docs/modules.html b/docs/modules.html index fbf6bb56..655ffed2 100644 --- a/docs/modules.html +++ b/docs/modules.html @@ -1,5 +1,5 @@ -Simple-data-analysis - v3.6.2

Simple-data-analysis - v3.6.2

Index

Classes

SimpleDB +Simple-data-analysis - v3.6.3

Simple-data-analysis - v3.6.3

Index

Classes

SimpleDB SimpleTable SimpleWebDB SimpleWebTable -

Settings

Member Visibility
+

Settings

Member Visibility