go.charczuk.com@v0.0.0-20240327042549-bc490516bd1a/projects/nodes/pkg/types/table.go

/*

Copyright (c) 2023 - Present. Will Charczuk. All rights reserved.
Use of this source code is governed by a MIT license that can be found in the LICENSE file at the root of the repository.

*/

package types

import (
	"encoding/csv"
	"fmt"
	"io"
)

// TableFromCSVReader returns a table from a reader that holds csv data.
func TableFromCSVReader(data io.Reader) (*Table, error) {
	output := new(Table)

	csvr := csv.NewReader(data)

	headers, err := csvr.Read()
	if err != nil {
		return nil, err
	}
	for _, header := range headers {
		output.Columns = append(output.Columns, TableColumn{
			Name: header,
		})
	}
	var row []string
	for {
		row, err = csvr.Read()
		if err == io.EOF {
			break
		}
		if err != nil {
			return nil, err
		}
		for index, colValue := range row {
			if index < len(output.Columns) {
				output.Columns[index].Values = append(output.Columns[index].Values, colValue)
			}
		}
	}
	return output, nil
}

// TableFromCSV returns a table from a csv.
func TableFromCSV(data [][]string) (*Table, error) {
	output := new(Table)
	if len(data) == 0 {
		return output, nil
	}

	headers := data[0]
	for _, header := range headers {
		output.Columns = append(output.Columns, TableColumn{
			Name: header,
		})
	}
	if len(data) > 1 {
		for _, row := range data[1:] {
			for index, colValue := range row {
				if index < len(output.Columns) {
					output.Columns[index].Values = append(output.Columns[index].Values, colValue)
				}
			}
		}
	}
	return output, nil
}

// TableFromJSON returns a table from a json object.
func TableFromJSON(obj map[string]any) (*Table, error) {
	if obj == nil {
		return nil, nil
	}

	output := new(Table)

	rawColumns, ok := obj["columns"]
	if !ok {
		return nil, fmt.Errorf("raw table field missing: 'columns'")
	}

	typedRawColumns, _ := rawColumns.([]any)
	for _, rawColumn := range typedRawColumns {
		if typedRawColumn, ok := rawColumn.(map[string]any); ok {
			tableColumn, err := TableColumnFromJSON(typedRawColumn)
			if err != nil {
				return nil, err
			}
			if tableColumn != nil {
				output.Columns = append(output.Columns, *tableColumn)
			}
		}
	}
	return output, nil
}

// TableColumnFromJSON returns a table column from a json object.
func TableColumnFromJSON(obj map[string]any) (*TableColumn, error) {
	if obj == nil {
		return nil, nil
	}
	output := new(TableColumn)
	output.Name, _ = obj["name"].(string)
	output.ValueType, _ = obj["value_type"].(string)

	rawValues, ok := obj["values"]
	if !ok {
		return nil, fmt.Errorf("raw table column field missing: 'values'")
	}
	if typedRawValues, ok := rawValues.([]any); ok {
		output.Values = append(output.Values, typedRawValues...)
	}
	return output, nil
}

// Table is a column oriented store of data.
//
// Specifically it breaks the data into columns, and those columns have values
// which you can think of as rows.
//
// This makes inserting a new column very easy (and fast!), but it also means
// that some operations are kind of finicky (specifically inserting rows).
type Table struct {
	Columns []TableColumn `json:"columns"`
}

// RowCount returns the maximum number of rows
// in any of the columns of the table.
func (t *Table) RowCount() (maxRows int) {
	if len(t.Columns) == 0 {
		return
	}
	maxRows = len(t.Columns[0].Values)
	for _, c := range t.Columns[1:] {
		if len(c.Values) > maxRows {
			maxRows = len(c.Values)
		}
	}
	return
}

// Rows returns the values of the table organized
// by row (instead of by column.)
func (t *Table) Rows() [][]any {
	var output [][]any
	if len(t.Columns) == 0 {
		return output
	}
	var maxRows int = len(t.Columns[0].Values)
	for _, c := range t.Columns[1:] {
		if len(c.Values) > maxRows {
			maxRows = len(c.Values)
		}
	}
	output = make([][]any, 0, maxRows)
	for rowIndex := 0; rowIndex < maxRows; rowIndex++ {
		row := make([]any, 0, len(t.Columns))
		for _, c := range t.Columns {
			if rowIndex >= len(c.Values) {
				row = append(row, nil)
				continue
			}
			row = append(row, c.Values[rowIndex])
		}
		output = append(output, row)
	}
	return output
}

// Set sets the value for a given row and column.
//
// If the row is beyond the current row count for a given column,
// nil values are added to satisfy the "density" of the table.
func (t *Table) Set(row, col int, value any) error {
	if col < 0 {
		return fmt.Errorf("table column index invalid: %d", col)
	}
	if col >= len(t.Columns) {
		return fmt.Errorf("table column index out of range: %d", col)
	}
	if row < 0 {
		return fmt.Errorf("table row index invalid: %d", row)
	}
	vlen := len(t.Columns[col].Values)
	if row >= vlen {
		missing := (row + 1) - vlen
		for x := 0; x < missing; x++ {
			t.Columns[col].Values = append(t.Columns[col].Values, nil)
		}
	}
	t.Columns[col].Values[row] = value
	return nil
}

// Delete deletes a value at a given row and column.
func (t *Table) Delete(row, col int) error {
	if col < 0 {
		return fmt.Errorf("table column index invalid: %d", col)
	}
	if col >= len(t.Columns) {
		return fmt.Errorf("table column index out of range: %d", col)
	}
	if row < 0 {
		return fmt.Errorf("table row index invalid: %d", row)
	}
	if row >= len(t.Columns[col].Values) {
		return fmt.Errorf("table row index out of range: %d", row)
	}
	t.Columns[col].Values[row] = nil
	return nil
}

// InsertColumn insets a new column at a given index.
func (t *Table) InsertColumn(columnIndex int, newColumn TableColumn) error {
	if columnIndex < 0 {
		return fmt.Errorf("table column index invalid: %d", columnIndex)
	}
	if columnIndex > len(t.Columns) {
		return fmt.Errorf("table column index out of range: %d", columnIndex)
	}
	if columnIndex >= len(t.Columns) {
		t.Columns = append(t.Columns, newColumn)
	} else {
		before := t.Columns[:columnIndex]
		after := t.Columns[columnIndex:]
		t.Columns = append(before, append([]TableColumn{newColumn}, after...)...)
	}
	return nil
}

// DeleteColumn deletes a column at a given index.
func (t *Table) DeleteColumn(columnIndex int) error {
	if columnIndex < 0 {
		return fmt.Errorf("table column index invalid: %d", columnIndex)
	}
	if columnIndex >= len(t.Columns) {
		return fmt.Errorf("table column index out of range: %d", columnIndex)
	}
	before := t.Columns[:columnIndex]
	after := t.Columns[columnIndex+1:]
	t.Columns = append(before, after...)
	return nil
}

// InsertRow inserts a row at a given index.
func (t *Table) InsertRow(rowIndex int, rowValues []any) error {
	if rowIndex < 0 {
		return fmt.Errorf("table insert row  index invalid: %d", rowIndex)
	}
	for index := range t.Columns {
		var rowValue any
		if index < len(rowValues) {
			rowValue = rowValues[index]
		}
		if len(t.Columns[index].Values) >= rowIndex {
			t.Columns[index].Values = append(t.Columns[index].Values[:rowIndex], append([]any{rowValue}, t.Columns[index].Values[rowIndex:]...)...)
		} else {
			missing := (rowIndex - len(t.Columns[index].Values))
			for x := 0; x < missing; x++ {
				t.Columns[index].Values = append(t.Columns[index].Values, nil)
			}
			t.Columns[index].Values = append(t.Columns[index].Values, rowValue)
		}
	}
	return nil
}

// DeleteRow deletes a row at a given index.
func (t *Table) DeleteRow(rowIndex int) error {
	if rowIndex < 0 {
		return fmt.Errorf("table column index invalid: %d", rowIndex)
	}
	for columnIndex := range t.Columns {
		if rowIndex >= len(t.Columns[columnIndex].Values) {
			continue
		}
		before := t.Columns[columnIndex].Values[:rowIndex]
		after := t.Columns[columnIndex].Values[rowIndex+1:]
		t.Columns[columnIndex].Values = append(before, after...)
	}
	return nil
}

// ReorderColumn swaps the column order from a given old index to a given new index.
func (t *Table) ReorderColumn(oldColumn, newColumn int) error {
	if oldColumn < 0 {
		return fmt.Errorf("table old column index invalid: %d", oldColumn)
	}
	if oldColumn >= len(t.Columns) {
		return fmt.Errorf("table old column index out of range: %d", oldColumn)
	}
	if newColumn < 0 {
		return fmt.Errorf("table new column index invalid: %d", newColumn)
	}
	if newColumn >= len(t.Columns) {
		return fmt.Errorf("table new column index out of range: %d", newColumn)
	}
	t.Columns[oldColumn], t.Columns[newColumn] = t.Columns[newColumn], t.Columns[oldColumn]
	return nil
}

// ReorderRow swaps the row order from a given old index to a given new index.
func (t *Table) ReorderRow(oldRow, newRow int) error {
	if len(t.Columns) == 0 {
		return fmt.Errorf("table reorder row; cannot re-order empty table")
	}
	minColumnLength := len(t.Columns[0].Values)
	for _, col := range t.Columns[1:] {
		if len(col.Values) < minColumnLength {
			minColumnLength = len(col.Values)
		}
	}
	if oldRow < 0 {
		return fmt.Errorf("table old row index invalid: %d", oldRow)
	}
	if oldRow >= minColumnLength {
		return fmt.Errorf("table old row index out of range: %d", oldRow)
	}
	if newRow < 0 {
		return fmt.Errorf("table new row index invalid: %d", newRow)
	}
	if newRow >= minColumnLength {
		return fmt.Errorf("table new row index out of range: %d", newRow)
	}
	for index := range t.Columns {
		t.Columns[index].Values[oldRow], t.Columns[index].Values[newRow] = t.Columns[index].Values[newRow], t.Columns[index].Values[oldRow]
	}
	return nil
}

// SetColumnName sets the column name for a column at a given index.
func (t *Table) SetColumnName(columnIndex int, columnName string) error {
	if columnIndex < 0 {
		return fmt.Errorf("table column index invalid: %d", columnIndex)
	}
	if columnIndex >= len(t.Columns) {
		return fmt.Errorf("table column index out of range: %d", columnIndex)
	}
	t.Columns[columnIndex].Name = columnName
	return nil
}

// ApplyOps applies operations to the table.
func (t *Table) ApplyOps(ops ...TableOp) error {
	var err error
	for _, op := range ops {
		switch op.Type {
		case TableOpTypeSet:
			err = t.Set(op.Row, op.Col, op.Value)
		case TableOpTypeSetColumnName:
			err = t.SetColumnName(op.Col, op.Name)
		case TableOpTypeDelete:
			err = t.Delete(op.Row, op.Col)
		case TableOpTypeInsertColumn:
			err = t.InsertColumn(op.Col, TableColumn{
				Name:      op.Name,
				ValueType: op.ValueType,
				Values:    op.Values,
			})
		case TableOpTypeInsertRow:
			err = t.InsertRow(op.Row, op.Values)
		case TableOpTypeDeleteColumn:
			err = t.DeleteColumn(op.Col)
		case TableOpTypeDeleteRow:
			err = t.DeleteRow(op.Row)
		case TableOpTypeReorderColumn:
			err = t.ReorderColumn(op.Old, op.New)
		case TableOpTypeReorderRow:
			err = t.ReorderRow(op.Old, op.New)
		default:
			err = fmt.Errorf("invalid table op type: %v", op.Type)
		}
		if err != nil {
			return err
		}
	}
	return nil
}

// Range returns a subset of the table data according to a given range predicate.
func (t *Table) Range(r TableRange) [][]any {
	output := [][]any{}
	for row := r.Top; row <= r.Bottom; row++ {
		var rowValues []any
		for col := r.Left; col <= r.Right; col++ {
			if col < len(t.Columns) && row < len(t.Columns[col].Values) {
				rowValues = append(rowValues, t.Columns[col].Values[row])
				continue
			}
			rowValues = append(rowValues, nil)
		}
		output = append(output, rowValues)
	}
	return output
}

// TableColumn is a vector of data.
type TableColumn struct {
	Name      string `json:"name"`
	ValueType string `json:"value_type"`
	Values    []any  `json:"values"`
}

// TableOp is an operation a user can take on a table.
//
// NOTE(wc): The format here is kind of gross because we don't have the ability
// to do the typescript thing where we discriminate types based on a string field value.
//
// We could use interfaces and do a bunch of careful implementing but this is fine for now.
type TableOp struct {
	// type determines what function to call
	Type string `json:"type"`
	// the column name typically
	Name string `json:"name"`
	// the colmn value type typically
	ValueType string `json:"value_type"`

	// used for various commands
	Col int `json:"col"`
	Row int `json:"row"`

	// used for reodering
	Old int `json:"old"`
	New int `json:"new"`

	// for setting the value
	Value any `json:"value"`
	// for inserting rows and columns
	Values []any `json:"values"`
}

// TableOpType is a type of operation on a table.
type TableOpType string

// TableOp types.
const (
	TableOpTypeSet           = "set"
	TableOpTypeSetColumnName = "set_column_name"
	TableOpTypeDelete        = "delete"
	TableOpTypeInsertColumn  = "insert_column"
	TableOpTypeDeleteColumn  = "delete_column"
	TableOpTypeInsertRow     = "insert_row"
	TableOpTypeDeleteRow     = "delete_row"
	TableOpTypeReorderColumn = "reorder_column"
	TableOpTypeReorderRow    = "reorder_row"
)

// TableInfo is the table metdata less the actual data.
type TableInfo struct {
	Rows    int      `json:"rows"`
	Columns []string `json:"columns"`
}

// TableRange holds visible coordinates.
type TableRange struct {
	Top    int `json:"top"`
	Left   int `json:"left"`
	Bottom int `json:"bottom"`
	Right  int `json:"right"`
}