Daff

https://paulfitz.github.io/daff-doc/
Admin
Daff is a data diff tool that compares tables and visualizes their differences, supporting multiple...
Tokens:32,055
Snippets:195
Trust Score:8.3
Update:11 months ago
Show doc for...
Tokens:
Raw
### String.fromCharCode Static Method Example

Source: https://paulfitz.github.io/daff-doc/types/String

Illustrates the use of the static `fromCharCode` method to create a String from a given character code (integer).

```Haxe
var charA = String.fromCharCode(65);
trace(charA); // Output: "A"

var charZ = String.fromCharCode(90);
trace(charZ); // Output: "Z"
```

--------------------------------

### String.substr Method Example

Source: https://paulfitz.github.io/daff-doc/types/String

Illustrates extracting a portion of a String using `substr`. It allows specifying a starting position and an optional length, handling negative positions and lengths exceeding string bounds.

```Haxe
var message = "Hello World";
var sub1 = message.substr(6, 5);
trace(sub1); // Output: "World"

var sub2 = message.substr(6);
trace(sub2); // Output: "World"

var sub3 = message.substr(-5);
trace(sub3); // Output: "World"

var sub4 = message.substr(0, 5);
trace(sub4); // Output: "Hello"
```

--------------------------------

### String.split Method Example

Source: https://paulfitz.github.io/daff-doc/types/String

Demonstrates splitting a String into an array of substrings based on a delimiter. Handles cases with empty strings, empty delimiters, and delimiters not found.

```Haxe
var csvData = "apple,banana,cherry";
var fruits = csvData.split(",");
trace(fruits); // Output: ["apple", "banana", "cherry"]

var words = "one two three".split(" ");
trace(words); // Output: ["one", "two", "three"]

var emptyStringSplit = "".split(",");
trace(emptyStringSplit); // Output: [""]

var emptyDelimiterSplit = "abc".split("");
trace(emptyDelimiterSplit); // Output: ["a", "b", "c"]
```

--------------------------------

### daff.SqlDatabase Interface Methods

Source: https://paulfitz.github.io/daff-doc/types/coopy/SqlDatabase

This section details the methods available for the daff.SqlDatabase interface, covering operations like starting and ending transactions, retrieving data, and metadata.

```APIDOC
## daff.SqlDatabase

### Description
Provides an interface for interacting with SQL databases, including methods for data retrieval and manipulation.

### Methods

#### begin

- **Description**: Starts a new transaction or query.
- **Method**: `begin`
- **Parameters**:
  - `query` (String) - Required - The SQL query string.
  - `args` (Array<Dynamic>) - Optional - Arguments for the query.
  - `order` (Array<String>) - Optional - Ordering for the query results.
- **Returns**: Bool - True if the operation was successful, false otherwise.

#### beginRow

- **Description**: Begins reading a specific row from a table.
- **Method**: `beginRow`
- **Parameters**:
  - `name` (SqlTableName) - Required - The name of the table.
  - `row` (Int) - Required - The row index.
  - `order` (Array<String>) - Optional - Ordering for the row data.
- **Returns**: Bool - True if the operation was successful, false otherwise.

#### end

- **Description**: Ends the current transaction or query.
- **Method**: `end`
- **Returns**: Bool - True if the operation was successful, false otherwise.

#### get

- **Description**: Retrieves data at a specific index.
- **Method**: `get`
- **Parameters**:
  - `index` (Int) - Required - The index of the data to retrieve.
- **Returns**: Dynamic - The retrieved data.

#### getColumns

- **Description**: Retrieves the columns of a table.
- **Method**: `getColumns`
- **Parameters**:
  - `name` (SqlTableName) - Required - The name of the table.
- **Returns**: Array<SqlColumn> - An array of SqlColumn objects.

#### getHelper

- **Description**: Retrieves the SQL helper object.
- **Method**: `getHelper`
- **Returns**: SqlHelper - The SQL helper object.

#### getNameForAttachment

- **Description**: Gets the name for attachment.
- **Method**: `getNameForAttachment`
- **Returns**: String - The attachment name.

#### getQuotedColumnName

- **Description**: Gets the quoted column name.
- **Method**: `getQuotedColumnName`
- **Parameters**:
  - `name` (String) - Required - The column name.
- **Returns**: String - The quoted column name.

#### getQuotedTableName

- **Description**: Gets the quoted table name.
- **Method**: `getQuotedTableName`
- **Parameters**:
  - `name` (SqlTableName) - Required - The table name.
- **Returns**: String - The quoted table name.

#### read

- **Description**: Reads data from the database.
- **Method**: `read`
- **Returns**: Bool - True if the read operation was successful, false otherwise.

#### rowid

- **Description**: Gets the row identifier.
- **Method**: `rowid`
- **Returns**: String - The row identifier.

#### width

- **Description**: Gets the width of the data.
- **Method**: `width`
- **Returns**: Int - The width of the data.
```

--------------------------------

### Getting Sample CSS for DiffRender

Source: https://paulfitz.github.io/daff-doc/types/coopy/DiffRender

Provides a sample CSS stylesheet that can be used to style the HTML generated by the DiffRender class. This allows for basic visual formatting of the diff output. The returned string contains CSS rules.

```daff
var css = daff.DiffRender.sampleCss();
```

--------------------------------

### String.indexOf Method Example

Source: https://paulfitz.github.io/daff-doc/types/String

Illustrates finding the first occurrence of a substring within a String using `indexOf`. The optional `startIndex` parameter allows searching from a specific position.

```Haxe
var sentence = "The quick brown fox jumps over the lazy dog";
var indexFox = sentence.indexOf("fox");
trace(indexFox); // Output: 16

var indexThe = sentence.indexOf("the", 10);
trace(indexThe); // Output: 31

var indexNotFound = sentence.indexOf("cat");
trace(indexNotFound); // Output: -1
```

--------------------------------

### String.charCodeAt Method Example

Source: https://paulfitz.github.io/daff-doc/types/String

Demonstrates retrieving the character code (Unicode value) of a character at a specific index using `charCodeAt`. Returns null for invalid indices.

```Haxe
var myString = "Haxe";
var codeH = myString.charCodeAt(0);
trace(codeH); // Output: 72

var codeE = myString.charCodeAt(3);
trace(codeE); // Output: 101

var invalidCode = myString.charCodeAt(-1);
trace(invalidCode); // Output: null
```

--------------------------------

### String.charAt Method Example

Source: https://paulfitz.github.io/daff-doc/types/String

Shows how to retrieve a single character from a String at a specified index using the `charAt` method. Returns an empty string for invalid indices.

```Haxe
var myString = "Haxe";
var firstChar = myString.charAt(0);
trace(firstChar); // Output: "H"

var lastChar = myString.charAt(3);
trace(lastChar); // Output: "e"

var invalidChar = myString.charAt(10);
trace(invalidChar); // Output: ""
```

--------------------------------

### Calculate and Retrieve Viterbi Path

Source: https://paulfitz.github.io/daff-doc/types/coopy/Viterbi

Computes the optimal state sequence after all transitions have been defined. Methods like get(), getCost(), and toString() can then be used to retrieve the results.

```TypeScript
viterbi.calculatePath();
const optimalState = viterbi.get(stepIndex);
const totalCost = viterbi.getCost();
const pathString = viterbi.toString();
```

--------------------------------

### String Construction and Concatenation Example

Source: https://paulfitz.github.io/daff-doc/types/String

Demonstrates how to construct String objects using literals and concatenate them using the '+' operator. Non-string operands are automatically converted using Std.string().

```Haxe
var greeting = "Hello";
var name = "World";
var message = greeting + " " + name;
trace(message); // Output: "Hello World"

var number = 123;
var text = "The number is: " + number;
trace(text); // Output: "The number is: 123"
```

--------------------------------

### Manage Viterbi Sequence Steps

Source: https://paulfitz.github.io/daff-doc/types/coopy/Viterbi

Manages the steps within the Viterbi sequence. beginTransitions() starts a new step, addTransition() records possible transitions for that step, and endTransitions() finalizes the step.

```TypeScript
viterbi.beginTransitions();
// Add transitions for the current step
viterbi.endTransitions();
```

--------------------------------

### String.lastIndexOf Method Example

Source: https://paulfitz.github.io/daff-doc/types/String

Shows how to find the last occurrence of a substring within a String using `lastIndexOf`. The optional `startIndex` parameter affects the search range.

```Haxe
var sentence = "The quick brown fox jumps over the lazy dog";
var lastIndexThe = sentence.lastIndexOf("the");
trace(lastIndexThe); // Output: 31

var lastIndexOver = sentence.lastIndexOf("over", 20);
trace(lastIndexOver); // Output: 25

var lastIndexNotFound = sentence.lastIndexOf("cat");
trace(lastIndexNotFound); // Output: -1
```

--------------------------------

### Apply Changes and Get Alignment

Source: https://paulfitz.github.io/daff-doc/types/coopy/SqlCompare

Shows how to apply changes using the daff.SqlCompare.apply() method, which returns an Alignment object representing the differences between the tables. This is a core function for generating diffs.

```typescript
compare.apply(): Alignment
```

--------------------------------

### DAFF View Interface: Hash Operations

Source: https://paulfitz.github.io/daff-doc/types/coopy/View

Provides methods for checking, getting, and setting key-value pairs in hash/map objects within the DAFF framework. It also includes a method to create new hash objects.

```daff.View
interface daff.View {
  hashExists(h: Dynamic, str: String): Bool
  hashGet(h: Dynamic, str: String): Dynamic
  hashSet(h: Dynamic, str: String, d: Dynamic): Void
  makeHash(): Dynamic
  isHash(h: Dynamic): Bool
}
```

--------------------------------

### Get Table Metadata as a Table with daff.Meta

Source: https://paulfitz.github.io/daff-doc/types/coopy/Meta

The asTable method returns a Table object representing the metadata of the original table, including column information. If available, the returned table has an extra initial column and its header row is prefixed with '@'. This method is useful for inspecting table structure.

```typescript
/**
 * Returns a table describing the columns of a table, if available.
 * If a table is returned, it should have the same number of columns as the original, plus on extra initial column.
 * Its header row should be the same as the original, with “@” in the extra column.
 * Subsequent rows may have an arbitrary tag in the first column, followed by values to be associated with that tag for each column.
 * @returns A table describing the columns of a table, if available.
 */
asTable(): Table
```

--------------------------------

### daff.Coopy - Class Documentation

Source: https://paulfitz.github.io/daff-doc/types/coopy/Coopy

Documentation for the daff.Coopy class, which serves as the main entry-point to the library and its command-line tool. It includes static variables, static methods, constructor, and instance methods for table comparison and manipulation.

```APIDOC
## daff.Coopy

This is the main entry-point to the library and the associated command-line tool.

### Type
**class**

### Static Variables

#### **VERSION** : String
Library version.

### Static Methods

#### compareTables (local : Table, remote : Table, ?flags : CompareFlags) : CompareTable
Prepare to compare two tables.

**Parameters:**
* `local` (Table) - the reference version of the table
* `remote` (Table) - another version of the table
* `flags` (CompareFlags) - control how the comparison will be made

**Returns:**
A worker object that can be used to make the comparison (normally you’ll just want to call `.align()` on it).

#### compareTables3 (parent : Table, local : Table, remote : Table, ?flags : CompareFlags) : CompareTable
Prepare to compare two tables, given knowledge of a common ancestor. The comparison will answer: what changes should be made to `local` in order to incorporate the differences between `parent` and `remote`. This is useful if the `local` table has changes in it that you want to preserve.

**Parameters:**
* `parent` (Table) - the common ancestor of the `local` and `remote` tables
* `local` (Table) - the reference version of the table
* `remote` (Table) - another version of the table
* `flags` (CompareFlags) - control how the comparison will be made

**Returns:**
A worker object that can be used to make the comparison (normally you’ll just want to call `.align()` on it).

#### diff (local : Table, remote : Table, ?flags : CompareFlags) : Table
Compare two tables and visualize their difference as another table.

**Parameters:**
* `local` (Table) - the reference version of the table
* `remote` (Table) - another version of the table
* `flags` (CompareFlags) - control how the comparison will be made

**Returns:**
A table like that produced by `daff a.csv b.csv`.

#### diffAsAnsi (local : Table, remote : Table, ?flags : CompareFlags) : String
Compare two tables and visualize their difference in text decorated with ansi console codes.

**Parameters:**
* `local` (Table) - the reference version of the table
* `remote` (Table) - another version of the table
* `flags` (CompareFlags) - control how the comparison will be made

**Returns:**
A string like that produced by `daff --color a.csv b.csv`.

#### diffAsHtml (local : Table, remote : Table, ?flags : CompareFlags) : String
Compare two tables and visualize their difference using html.

**Parameters:**
* `local` (Table) - the reference version of the table
* `remote` (Table) - another version of the table
* `flags` (CompareFlags) - control how the comparison will be made

**Returns:**
An html string like that produced by `daff --output-format html --fragment a.csv b.csv`.

#### main () : Int
This is the entry point for the daff command-line utility. It is a thin wrapper around the `coopyhx` method.

**Returns:**
An integer representing the exit code.

#### patch (local : Table, patch : Table, ?flags : CompareFlags) : Bool
Apply a patch to a table.

**Parameters:**
* `local` (Table) - the reference version of the table
* `patch` (Table) - the changes to apply (in daff format)
* `flags` (CompareFlags) - control how the patch operations will be made

**Returns:**
`true` on success, `false` otherwise.

#### tablify (data : Dynamic) : Table
This takes input in an unknown format and tries to make a table out of it, through the power of guesswork.

**Parameters:**
* `data` (Dynamic) - an alleged table

**Returns:**
A daff-compatible table, or `null` if conversion fails.

### Constructor

#### new(?io : TableIO)

### Methods

#### coopyhx (io : TableIO) : Int

#### loadTable (name : String) : Table
Load a table from a file.

**Parameters:**
* `name` (String) - filename to read from

**Returns:**
A table.

#### run (args : Array<String>, ?io : TableIO) : Int
This implements the daff command-line utility.

**Parameters:**
* `args` (Array<String>) - the list of command-line arguments
* `io` (TableIO) - should be an implementation of all the system services daff needs, if null one will be created

**Returns:**
0 on success, non-zero on error.
```

--------------------------------

### splice

Source: https://paulfitz.github.io/daff-doc/types/Array

Removes elements from the Array starting at a specified position and returns the removed elements. Modifies the Array in place.

```APIDOC
## splice (pos : Int, len : Int) : Array<T>

### Description
Removes `len` elements from `this` Array, starting at and including `pos`, and returns them.

This operation modifies `this` Array in place.

If `len` is < 0 or `pos` exceeds `this.length`, the result is the empty Array.

If `pos` is negative, its value is calculated from the end of `this` Array by `this.length + pos`. If this yields a negative value, 0 is used instead.

If the sum of the resulting values for `len` and `pos` exceed `this.length`, this operation will affect the elements from `pos` to the end of `this` Array.

The length of the returned Array is equal to the new length of `this` Array subtracted from the original length of `this` Array. In other words, each element of the original `this` Array either remains in `this` Array or becomes an element of the returned Array.

### Method
`splice`

### Parameters
#### Path Parameters
None

#### Query Parameters
- **pos** (Int) - Required - The starting index for removal.
- **len** (Int) - Required - The number of elements to remove.

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **Array<T>** - An array containing the removed elements.
```

--------------------------------

### DAFF SqlColumn Class Documentation

Source: https://paulfitz.github.io/daff-doc/types/coopy/SqlColumn

Documentation for the `daff.SqlColumn` class, detailing its constructor, variables, and methods.

```APIDOC
## daff.SqlColumn

> _Type:_ **class**

## Constructor:
##### **new**()

## Variables:
##### **name** : String
##### **primary** : Bool
##### **type_family** : String
##### **type_value** : String

## Methods:
##### **getName** () : String
##### **isPrimaryKey** () : Bool
##### **setName** (name : String) : Void
##### **setPrimaryKey** (primary : Bool) : Void
##### **setType** (value : String, family : String) : Void
##### **toString** () : String
```

--------------------------------

### Run daff Command-Line Utility

Source: https://paulfitz.github.io/daff-doc/types/coopy/Coopy

The 'run' method executes the daff command-line utility with the provided arguments. It requires an implementation of system services, or it will create one internally. The 'main' method is a thin wrapper around this for the entry point.

```typescript
import * as daff from "daff";

// Example of running the command-line utility
const args: string[] = ["a.csv", "b.csv", "--output-format", "html"];
const exitCode: number = daff.Coopy.run(args);

console.log(`Daff utility exited with code: ${exitCode}`);

// The main method can also be called directly
// daff.Coopy.main();

```

--------------------------------

### daff.Coopy Constructor and Methods

Source: https://paulfitz.github.io/daff-doc/index

Details the constructor and instance methods for the daff.Coopy class.

```APIDOC
## daff.Coopy - Constructor and Methods

### Constructor

- **new**(?io : TableIO)
  - **Description**: Creates a new instance of daff.Coopy.
  - **Parameters**:
    - `io` (TableIO) - Optional - The table I/O handler.

### Methods

- **coopyhx** (io : TableIO) : Int
  - **Description**: Internal method for executing Coopy operations.
  - **Parameters**:
    - `io` (TableIO) - Required - The table I/O handler.
  - **Returns**: Int - Exit code.

- **loadTable** (name : String) : Table
  - **Description**: Load a table from a file.
  - **Parameters**:
    - `name` (String) - Required - Filename to read from.
  - **Returns**: Table - The loaded table.

- **run** (args : Array<String>, ?io : TableIO) : Int
  - **Description**: Implements the daff command-line utility.
  - **Parameters**:
    - `args` (Array<String>) - Required - The list of command-line arguments.
    - `io` (TableIO) - Optional - An implementation of system services needed by daff; if null, one will be created.
  - **Returns**: Int - 0 on success, non-zero on error.
```

--------------------------------

### daff.SqlTables Class Documentation

Source: https://paulfitz.github.io/daff-doc/types/coopy/SqlTables

Provides detailed documentation for the daff.SqlTables class, including its constructor, properties, and methods.

```APIDOC
## daff.SqlTables

### Description
Represents a table backed by an SQL database, implementing the `daff.Table` interface.

### Class
`daff.SqlTables`

### Implements
- `daff.Table`

### Constructor
#### `new(db: SqlDatabase, flags: CompareFlags)`
- **db** (`SqlDatabase`) - The SQL database instance.
- **flags** (`CompareFlags`) - Flags to control comparison behavior.

### Variables
#### `height` (accessor, null): Int
- **Description**: The number of rows in the table.

#### `width` (accessor, null): Int
- **Description**: The number of columns in the table.

### Methods
#### `clear()`: Void
- **Description**: Clears all data from the table.

#### `clone()`: Table
- **Description**: Creates a deep copy of the table.

#### `create()`: Table
- **Description**: Creates a new, empty table.

#### `getCell(x: Int, y: Int)`: Dynamic
- **Description**: Retrieves the cell content at the specified coordinates.
- **Parameters**:
  - **x** (`Int`) - The column index.
  - **y** (`Int`) - The row index.

#### `getCellView()`: View
- **Description**: Returns a view of the cells in the table.

#### `getData()`: Dynamic
- **Description**: Retrieves all data from the table.

#### `getMeta()`: Meta
- **Description**: Returns the metadata associated with the table.

#### `get_height()`: Int
- **Description**: Returns the current height (number of rows) of the table.

#### `get_width()`: Int
- **Description**: Returns the current width (number of columns) of the table.

#### `insertOrDeleteColumns(fate: Array<Int>, wfate: Int)`: Bool
- **Description**: Inserts or deletes columns based on the provided fate array and width fate.
- **Parameters**:
  - **fate** (`Array<Int>`) - An array indicating column operations.
  - **wfate** (`Int`) - A fate value for width operations.
- **Returns**: `Bool` indicating success or failure.

#### `insertOrDeleteRows(fate: Array<Int>, hfate: Int)`: Bool
- **Description**: Inserts or deletes rows based on the provided fate array and height fate.
- **Parameters**:
  - **fate** (`Array<Int>`) - An array indicating row operations.
  - **hfate** (`Int`) - A fate value for height operations.
- **Returns**: `Bool` indicating success or failure.

#### `isResizable()`: Bool
- **Description**: Checks if the table can be resized.

#### `resize(w: Int, h: Int)`: Bool
- **Description**: Resizes the table to the specified width and height.
- **Parameters**:
  - **w** (`Int`) - The new width.
  - **h** (`Int`) - The new height.
- **Returns**: `Bool` indicating success or failure.

#### `setCell(x: Int, y: Int, c: Dynamic)`: Void
- **Description**: Sets the content of a cell at the specified coordinates.
- **Parameters**:
  - **x** (`Int`) - The column index.
  - **y** (`Int`) - The row index.
  - **c** (`Dynamic`) - The new cell content.

#### `trimBlank()`: Bool
- **Description**: Removes blank rows and columns from the table.
- **Returns**: `Bool` indicating if any changes were made.

```

--------------------------------

### Get Diff Statistics - daff.TableDiff

Source: https://paulfitz.github.io/daff-doc/types/coopy/TableDiff

Retrieves statistics about the table difference, such as the number of deleted, updated, or added rows. This method is part of the daff.TableDiff class.

```typescript
const diffStats = tableDiff.getSummary();
```

--------------------------------

### Instantiate daff.SimpleTable

Source: https://paulfitz.github.io/daff-doc/types/coopy/SimpleTable

Constructs a new instance of daff.SimpleTable with specified dimensions. The constructor takes the desired width and height as integer arguments.

```Haxe
new daff.SimpleTable(w:Int, h:Int)
```

--------------------------------

### DAFF SqlCompare Class Documentation

Source: https://paulfitz.github.io/daff-doc/types/coopy/SqlCompare

Documentation for the `daff.SqlCompare` class, which facilitates the comparison of SQL tables.

```APIDOC
## daff.SqlCompare

> _Type:_ **class**

## Constructor:
##### **new**(db : SqlDatabase, local : SqlTable, remote : SqlTable, alt : SqlTable, ?align : Alignment)

## Variables:
##### **alt** : SqlTable
##### **db** : SqlDatabase
##### **local** : SqlTable
##### **remote** : SqlTable

## Methods:
##### **apply** () : Alignment
##### **scanColumns** (all_cols1 : Array<String>, all_cols2 : Array<String>, key_cols : Array<String>, present1 : Map<String, Int>, present2 : Map<String, Int>, align : Alignment) : Void
##### **validateSchema** () : Bool
```

--------------------------------

### daff.Merger Class and Constructor

Source: https://paulfitz.github.io/daff-doc/types/coopy/Merger

Documentation for the daff.Merger class, including its constructor and parameters.

```APIDOC
## daff.Merger

Merge changes made in one table into another, given knowledge of a common ancestor.

### Description

This class is responsible for merging changes from a remote table into a local table, using a parent table as a common ancestor. It takes into account comparison flags to guide the merge process.

### Constructor

##### **new**(parent : Table, local : Table, remote : Table, flags : CompareFlags)

Initializes a new instance of the `Merger` class.

#### Parameters

- **parent** (Table) - Required - The common ancestor table.
- **local** (Table) - Required - The reference table into which changes will be merged.
- **remote** (Table) - Required - The table from which changes are being pulled.
- **flags** (CompareFlags) - Required - Flags to control the comparison and merging behavior.
```

--------------------------------

### Table Initialization and Copying (daff)

Source: https://paulfitz.github.io/daff-doc/types/coopy/Table

Create new tables or copy existing ones using `create()` and `clone()`. `create()` attempts to return an empty table of the same type, facilitating the creation of new data structures. `clone()` provides a deep copy of the table, ensuring data integrity when modifications are needed on a separate instance.

```daff
var newTable:Table = table.create()
var copiedTable:Table = table.clone()
```

--------------------------------

### Serialize daff.Unit to String

Source: https://paulfitz.github.io/daff-doc/types/coopy/Unit

Explains how to get a standard string representation of the daff.Unit object using the `toString()` method. The format depends on whether a parent index is present.

```typescript
const unitWithParent = new daff.Unit(1, 2, 3);
const unitString1 = unitWithParent.toString(); // Returns "3|1:2"

const unitWithoutParent = new daff.Unit(1, 2, -2);
const unitString2 = unitWithoutParent.toString(); // Returns "1:2"
```

--------------------------------

### DAFF Tables Class API

Source: https://paulfitz.github.io/daff-doc/types/coopy/Tables

Documentation for the daff.Tables class, including its constructor, variables, and methods.

```APIDOC
## daff.Tables

### Description
Manages a collection of tables, providing methods to add, retrieve, and query them.

### Type
Class

### Constructor
#### new(template : Table)
- **template** (Table) - A template table to initialize the collection.

### Variables
#### alignment
- **alignment** (Alignment) - Stores alignment information for the tables.

### Methods
#### add(name : String) : Table
- **name** (String) - The name of the table to add.
- Returns: The added Table object.

#### get(name : String) : Table
- **name** (String) - The name of the table to retrieve.
- Returns: The requested Table object.

#### getOrder() : Array<String>
- Returns: An array of strings representing the order of tables.

#### hasInsDel() : Bool
- Returns: True if the tables have insertions or deletions, false otherwise.

#### one() : Table
- Returns: A single Table object from the collection.
```

--------------------------------

### daff.SqliteHelper Class

Source: https://paulfitz.github.io/daff-doc/types/coopy/SqliteHelper

This section details the daff.SqliteHelper class, its constructor, and its methods for interacting with SQLite databases.

```APIDOC
## daff.SqliteHelper

### Description
Provides functionalities to interact with SQLite databases, implementing the `daff.SqlHelper` interface.

### Type
Class

### Implements
- daff.SqlHelper

## Constructor
### new()

Initializes a new instance of the `daff.SqliteHelper` class.

## Methods

### alterColumns

#### Description
Alters the columns of a specified table in the database.

#### Method
`alterColumns`

#### Parameters
- **db** (SqlDatabase) - The database object.
- **name** (SqlTableName) - The name of the table to alter.
- **columns** (Array<ColumnChange>) - An array of column changes to apply.

#### Returns
- **Bool** - True if the operation was successful, false otherwise.

### attach

#### Description
Attaches a resource to the database.

#### Method
`attach`

#### Parameters
- **db** (SqlDatabase) - The database object.
- **tag** (String) - The tag for the resource.
- **resource_name** (String) - The name of the resource to attach.

#### Returns
- **Bool** - True if the attachment was successful, false otherwise.

### countRows

#### Description
Counts the number of rows in a specified table.

#### Method
`countRows`

#### Parameters
- **db** (SqlDatabase) - The database object.
- **name** (SqlTableName) - The name of the table.

#### Returns
- **Int** - The number of rows in the table.

### delete

#### Description
Deletes rows from a specified table based on conditions.

#### Method
`delete`

#### Parameters
- **db** (SqlDatabase) - The database object.
- **name** (SqlTableName) - The name of the table.
- **conds** (Map<String, Dynamic>) - A map of conditions for deletion.

#### Returns
- **Bool** - True if the deletion was successful, false otherwise.

### getRowIDs

#### Description
Retrieves the IDs of all rows in a specified table.

#### Method
`getRowIDs`

#### Parameters
- **db** (SqlDatabase) - The database object.
- **name** (SqlTableName) - The name of the table.

#### Returns
- **Array<Int>** - An array of row IDs.

### getTableNames

#### Description
Retrieves the names of all tables in the database.

#### Method
`getTableNames`

#### Parameters
- **db** (SqlDatabase) - The database object.

#### Returns
- **Array<String>** - An array of table names.

### insert

#### Description
Inserts a new row into a specified table.

#### Method
`insert`

#### Parameters
- **db** (SqlDatabase) - The database object.
- **name** (SqlTableName) - The name of the table.
- **vals** (Map<String, Dynamic>) - A map of values to insert.

#### Returns
- **Bool** - True if the insertion was successful, false otherwise.

### update

#### Description
Updates existing rows in a specified table based on conditions.

#### Method
`update`

#### Parameters
- **db** (SqlDatabase) - The database object.
- **name** (SqlTableName) - The name of the table.
- **conds** (Map<String, Dynamic>) - A map of conditions for the update.
- **vals** (Map<String, Dynamic>) - A map of values to update.

#### Returns
- **Bool** - True if the update was successful, false otherwise.

```

--------------------------------

### DAFF SqlHelper Methods

Source: https://paulfitz.github.io/daff-doc/types/coopy/SqlHelper

This section details the methods available in the daff.SqlHelper interface for performing various SQL operations.

```APIDOC
## daff.SqlHelper Methods

### Description
Provides methods for interacting with SQL databases, including table manipulation, data insertion, updates, deletions, and row retrieval.

### Methods

#### alterColumns

##### Description
Alters the columns of a SQL table.

##### Method
`alterColumns`

##### Parameters
- **db** (SqlDatabase) - The SQL database connection.
- **name** (SqlTableName) - The name of the table to alter.
- **columns** (Array<ColumnChange>) - An array of column changes to apply.

##### Returns
- **Bool** - True if the operation was successful, false otherwise.

#### attach

##### Description
Attaches a resource to the database.

##### Method
`attach`

##### Parameters
- **db** (SqlDatabase) - The SQL database connection.
- **tag** (String) - The tag for the resource.
- **resource_name** (String) - The name of the resource to attach.

##### Returns
- **Bool** - True if the operation was successful, false otherwise.

#### countRows

##### Description
Counts the number of rows in a SQL table.

##### Method
`countRows`

##### Parameters
- **db** (SqlDatabase) - The SQL database connection.
- **name** (SqlTableName) - The name of the table.

##### Returns
- **Int** - The number of rows in the table.

#### delete

##### Description
Deletes rows from a SQL table based on specified conditions.

##### Method
`delete`

##### Parameters
- **db** (SqlDatabase) - The SQL database connection.
- **name** (SqlTableName) - The name of the table to delete from.
- **conds** (Map<String, Dynamic>) - A map of conditions for deletion.

##### Returns
- **Bool** - True if the operation was successful, false otherwise.

#### getRowIDs

##### Description
Retrieves the IDs of all rows in a SQL table.

##### Method
`getRowIDs`

##### Parameters
- **db** (SqlDatabase) - The SQL database connection.
- **name** (SqlTableName) - The name of the table.

##### Returns
- **Array<Int>** - An array of row IDs.

#### getTableNames

##### Description
Retrieves a list of all table names in the database.

##### Method
`getTableNames`

##### Parameters
- **db** (SqlDatabase) - The SQL database connection.

##### Returns
- **Array<String>** - An array of table names.

#### insert

##### Description
Inserts a new row into a SQL table.

##### Method
`insert`

##### Parameters
- **db** (SqlDatabase) - The SQL database connection.
- **name** (SqlTableName) - The name of the table to insert into.
- **vals** (Map<String, Dynamic>) - A map of values to insert.

##### Returns
- **Bool** - True if the operation was successful, false otherwise.

#### update

##### Description
Updates existing rows in a SQL table based on specified conditions.

##### Method
`update`

##### Parameters
- **db** (SqlDatabase) - The SQL database connection.
- **name** (SqlTableName) - The name of the table to update.
- **conds** (Map<String, Dynamic>) - A map of conditions for the update.
- **vals** (Map<String, Dynamic>) - A map of new values to set.

##### Returns
- **Bool** - True if the operation was successful, false otherwise.

```

--------------------------------

### Get Parent or Local Index from daff.Unit

Source: https://paulfitz.github.io/daff-doc/types/coopy/Unit

Illustrates the usage of the `lp()` method, which returns the parent table's row/column number if available, otherwise it returns the local table's row/column number.

```typescript
const unitWithParent = new daff.Unit(1, 2, 3);
const index1 = unitWithParent.lp(); // Returns 3

const unitWithoutParent = new daff.Unit(1, 2, -2);
const index2 = unitWithoutParent.lp(); // Returns 1
```

--------------------------------

### daff.TableIO API

Source: https://paulfitz.github.io/daff-doc/types/coopy/TableIO

Provides access to system services for file operations, command execution, and standard input/output streams.

```APIDOC
## daff.TableIO

System services for the daff command-line utility.

### Class
`daff.TableIO`

### Constructor
#### `new()`
Initializes a new instance of the TableIO class.

### Methods

#### `args()`
##### Description
Returns the command-line arguments.
##### Method
`GET`
##### Endpoint
`/TableIO/args`
##### Returns
- `Array<String>`: The command-line arguments.

#### `command(cmd: String, args: Array<String>)`
##### Description
Executes a command with the given arguments.
##### Method
`POST`
##### Endpoint
`/TableIO/command`
##### Parameters
- `cmd` (String) - Required - The command to execute.
- `args` (Array<String>) - Required - The arguments to pass to the command.
##### Returns
- `Int`: The return value of the executed command.

#### `exists(path: String)`
##### Description
Checks if a file exists at the specified path.
##### Method
`GET`
##### Endpoint
`/TableIO/exists`
##### Parameters
- `path` (String) - Required - The path to the file.
##### Returns
- `Bool`: True if the file exists, false otherwise.

#### `getContent(name: String)`
##### Description
Reads the content of a file.
##### Method
`GET`
##### Endpoint
`/TableIO/getContent`
##### Parameters
- `name` (String) - Required - The name of the file to read.
##### Returns
- `String`: The content of the file.

#### `hasAsync()`
##### Description
Checks if the platform has a built-in way to call a command synchronously.
##### Method
`GET`
##### Endpoint
`/TableIO/hasAsync`
##### Returns
- `Bool`: True if the platform does not have synchronous command execution (e.g., old Node.js).

#### `isTty()`
##### Description
Checks if the output is a TTY (teletypewriter).
##### Method
`GET`
##### Endpoint
`/TableIO/isTty`
##### Returns
- `Bool`: True if the output is a TTY. Only trustworthy if `isTtyKnown()` is true.

#### `isTtyKnown()`
##### Description
Determines if it is known whether the output is a TTY.
##### Method
`GET`
##### Endpoint
`/TableIO/isTtyKnown`
##### Returns
- `Bool`: True if the TTY status can be determined.

#### `openSqliteDatabase(path: String)`
##### Description
Tries to open an SQLite database at the specified path.
##### Method
`GET`
##### Endpoint
`/TableIO/openSqliteDatabase`
##### Parameters
- `path` (String) - Required - The path to the SQLite database.
##### Returns
- `SqlDatabase`: The opened database object, or null on failure.

#### `saveContent(name: String, txt: String)`
##### Description
Saves content to a file.
##### Method
`POST`
##### Endpoint
`/TableIO/saveContent`
##### Parameters
- `name` (String) - Required - The name of the file to save.
- `txt` (String) - Required - The content to save to the file.
##### Returns
- `Bool`: True on successful save, false otherwise.

#### `sendToBrowser(html: String)`
##### Description
Sends HTML content to the browser.
##### Method
`POST`
##### Endpoint
`/TableIO/sendToBrowser`
##### Parameters
- `html` (String) - Required - The HTML content to send.
##### Returns
- `Void`

#### `valid()`
##### Description
Checks if system services are implemented correctly for the current platform.
##### Method
`GET`
##### Endpoint
`/TableIO/valid`
##### Returns
- `Bool`: True if system services are valid, false otherwise.

#### `writeStderr(txt: String)`
##### Description
Writes text to the standard error stream.
##### Method
`POST`
##### Endpoint
`/TableIO/writeStderr`
##### Parameters
- `txt` (String) - Required - The text to write to standard error.
##### Returns
- `Void`

#### `writeStdout(txt: String)`
##### Description
Writes text to the standard output stream.
##### Method
`POST`
##### Endpoint
`/TableIO/writeStdout`
##### Parameters
- `txt` (String) - Required - The text to write to standard output.
##### Returns
- `Void`
```

--------------------------------

### Get Table Name with daff.Meta

Source: https://paulfitz.github.io/daff-doc/types/coopy/Meta

The getName method retrieves the name of the table, if one is assigned. It returns a string containing the table's name or null if the table is unnamed. This is useful for identifying specific tables in a dataset.

```typescript
/**
 * @returns a name for the table if it has one, otherwise null.
 */
getName(): String
```

--------------------------------

### Construct daff.SqlCompare Instance

Source: https://paulfitz.github.io/daff-doc/types/coopy/SqlCompare

Demonstrates the instantiation of the daff.SqlCompare class, which is used for comparing SQL tables. It requires a SqlDatabase object and three SqlTable objects representing local, remote, and alternative data, optionally taking an Alignment object.

```typescript
new daff.SqlCompare(db: SqlDatabase, local: SqlTable, remote: SqlTable, alt: SqlTable, align?: Alignment)
```

--------------------------------

### Get Row Content (daff.Row)

Source: https://paulfitz.github.io/daff-doc/types/coopy/Row

The getRowString method retrieves the string content of a specified column within a row. It takes an integer representing the column index as input and returns the content of that column as a string. This is a core method for accessing data within a row.

```TypeScript
getRowString (c : Int) : String
```

--------------------------------

### DAFF daff.Ndjson: Add Row from String

Source: https://paulfitz.github.io/daff-doc/types/coopy/Ndjson

Parses a string representing a single row in NDJSON format and inserts it into the table at the specified row number. The table automatically resizes if necessary. Row 0 is typically reserved for headers, with data starting from row 1.

```typescript
ndjson.addRow(r: Int, txt: String): Void
```

--------------------------------

### daff.Coopy Static Methods

Source: https://paulfitz.github.io/daff-doc/index

Details the static methods available for comparing and processing tables using daff.Coopy.

```APIDOC
## daff.Coopy - Static Methods

### compareTables

- **Description**: Prepare to compare two tables.
- **Method**: static
- **Parameters**:
  - `local` (Table) - Required - The reference version of the table.
  - `remote` (Table) - Required - Another version of the table.
  - `flags` (CompareFlags) - Optional - Controls how the comparison will be made.
- **Returns**: CompareTable - A worker to make the comparison.

### compareTables3

- **Description**: Prepare to compare two tables, given knowledge of a common ancestor. The comparison answers what changes should be made to `local` to incorporate differences between `parent` and `remote`.
- **Method**: static
- **Parameters**:
  - `parent` (Table) - Required - The common ancestor of the `local` and `remote` tables.
  - `local` (Table) - Required - The reference version of the table.
  - `remote` (Table) - Required - Another version of the table.
  - `flags` (CompareFlags) - Optional - Controls how the comparison will be made.
- **Returns**: CompareTable - A worker to make the comparison.

### diff

- **Description**: Compare two tables and visualize their difference as another table.
- **Method**: static
- **Parameters**:
  - `local` (Table) - Required - The reference version of the table.
  - `remote` (Table) - Required - Another version of the table.
  - `flags` (CompareFlags) - Optional - Controls how the comparison will be made.
- **Returns**: Table - A table like that produced by `daff a.csv b.csv`.

### diffAsAnsi

- **Description**: Compare two tables and visualize their difference in text decorated with ANSI console codes.
- **Method**: static
- **Parameters**:
  - `local` (Table) - Required - The reference version of the table.
  - `remote` (Table) - Required - Another version of the table.
  - `flags` (CompareFlags) - Optional - Controls how the comparison will be made.
- **Returns**: String - An ANSI-decorated string like that produced by `daff --color a.csv b.csv`.

### diffAsHtml

- **Description**: Compare two tables and visualize their difference using HTML.
- **Method**: static
- **Parameters**:
  - `local` (Table) - Required - The reference version of the table.
  - `remote` (Table) - Required - Another version of the table.
  - `flags` (CompareFlags) - Optional - Controls how the comparison will be made.
- **Returns**: String - An HTML string like that produced by `daff --output-format html --fragment a.csv b.csv`.

### main

- **Description**: Entry point for the daff command-line utility. It is a thin wrapper around the `coopyhx` method.
- **Method**: static
- **Returns**: Int - Exit code.

### patch

- **Description**: Apply a patch to a table.
- **Method**: static
- **Parameters**:
  - `local` (Table) - Required - The reference version of the table.
  - `patch` (Table) - Required - The changes to apply (in daff format).
  - `flags` (CompareFlags) - Optional - Controls how the patch operations will be made.
- **Returns**: Bool - True on success.

### tablify

- **Description**: Takes input in an unknown format and tries to make a table out of it through guesswork.
- **Method**: static
- **Parameters**:
  - `data` (Dynamic) - Required - An alleged table.
- **Returns**: Table - A daff-compatible table, or null.
```

--------------------------------

### DAFF Configuration Options

Source: https://paulfitz.github.io/daff-doc/types/coopy/CompareFlags

This section details the various configuration options available for DAFF, which control how data comparisons are performed and how results are presented.

```APIDOC
## Configuration Options

### `tables` (Array<String>)

List of tables to process. Used when reading from a source with multiple tables. Defaults to null, meaning all tables.

### `terminal_format` (String)

Format to use for terminal output. "plain" for plain text, "ansi", for ansi color codes, null to autodetect. Defaults to autodetect.

### `unchanged_column_context` (Int)

When showing context columns around a changed column, what is the minimum number of such columns we should show?

### `unchanged_context` (Int)

When showing context rows around a changed row, what is the minimum number of such rows we should show?

### `use_glyphs` (Bool)

Choose whether we can use utf8 characters for describing diff (specifically long arrow). Defaults to true.

### `warnings` (Array<String>)

List of warnings generated during a comparison.
```
Tokens:
Raw