field align memory

Author: James Cor

memory/database.go

@@ -55,15 +55,15 @@ var _ sql.SchemaValidator = (*BaseDatabase)(nil)
 
 // BaseDatabase is an in-memory database that can't store views, only for testing the engine
 type BaseDatabase struct {
-	name              string
 	tables            map[string]MemTable
 	fkColl            *ForeignKeyCollection
+	tablesMu          *sync.RWMutex
+	name              string
 	triggers          []sql.TriggerDefinition
 	storedProcedures  []sql.StoredProcedureDetails
 	events            []sql.EventDefinition
-	primaryKeyIndexes bool
 	collation         sql.CollationID
-	tablesMu          *sync.RWMutex
+	primaryKeyIndexes bool
 }
 
 var _ MemoryDatabase = (*Database)(nil)

memory/index.go

@@ -28,21 +28,23 @@ import (
 const CommentPreventingIndexBuilding = "__FOR TESTING: I cannot be built__"
 
 type Index struct {
-	DB         string // required for engine tests with driver
-	DriverName string // required for engine tests with driver
-	Tbl        *Table // required for engine tests with driver
-	TableName  string
-	Exprs      []sql.Expression
-	Name       string
-	Unique     bool
-	Spatial    bool
-	Fulltext   bool
 	// If SupportedVectorFunction is non-nil, this index can be used to optimize ORDER BY
 	// expressions on this type of distance function.
 	SupportedVectorFunction vector.DistanceType
-	CommentStr              string
-	PrefixLens              []uint16
+
+	Tbl        *Table // required for engine tests with driver
+	DriverName string // required for engine tests with driver
+	DB         string // required for engine tests with driver
+	TableName  string
+	Name       string
+	CommentStr string
+
+	Exprs      []sql.Expression
+	PrefixLens []uint16
 	fulltextInfo
+	Unique   bool
+	Spatial  bool
+	Fulltext bool
 }
 
 type fulltextInfo struct {

memory/index_driver.go

@@ -24,8 +24,8 @@ const IndexDriverId = "MemoryIndexDriver"
 // create or delete indexes, but will use the index types defined in this package to alter how queries are executed,
 // retrieving values from the indexes rather than from the tables directly.
 type TestIndexDriver struct {
-	db      string
 	indexes map[string][]sql.DriverIndex
+	db      string
 }
 
 // NewIndexDriver returns a new index driver for database and the indexes given, keyed by the table name.

memory/provider.go

@@ -17,12 +17,12 @@ var _ sql.ExternalStoredProcedureProvider = (*DbProvider)(nil)
 // DbProvider is a provider for in-memory databases
 type DbProvider struct {
 	dbs                       map[string]sql.Database
+	tableFunctions            map[string]sql.TableFunction
+	externalProcedureRegistry sql.ExternalStoredProcedureRegistry
+	mu                        *sync.RWMutex
 	history                   bool
 	readOnly                  bool
 	nativeIndexes             bool
-	mu                        *sync.RWMutex
-	tableFunctions            map[string]sql.TableFunction
-	externalProcedureRegistry sql.ExternalStoredProcedureRegistry
 }
 
 type ProviderOption func(*DbProvider)

memory/required_lookup_table.go

@@ -18,8 +18,8 @@ var _ sql.IndexRequired = RequiredLookupTable{}
 
 // RequiredLookupTable is a table that will error if not executed as an index lookup
 type RequiredLookupTable struct {
-	indexOk bool
 	IntSequenceTable
+	indexOk bool
 }
 
 func (s RequiredLookupTable) RequiredPredicates() []string {

memory/table.go

@@ -45,23 +45,15 @@ type MemTable interface {
 
 // Table represents an in-memory database table.
 type Table struct {
-	name string
-
-	// Schema and related info
-	data *TableData
-	// ignoreSessionData is used to ignore session data for versioned tables (smoke tests only), unused otherwise
+	data              *TableData
+	db                *BaseDatabase
+	name              string
+	projection        []string
+	projectedSchema   sql.Schema
+	columns           []int
+	filters           []sql.Expression
 	ignoreSessionData bool
-
-	// Projection info and settings
-	pkIndexesEnabled bool
-	projection       []string
-	projectedSchema  sql.Schema
-	columns          []int
-
-	// filters is used for primary index scans with an index lookup
-	filters []sql.Expression
-
-	db *BaseDatabase
+	pkIndexesEnabled  bool
 }
 
 var _ sql.Table = (*Table)(nil)
@@ -301,16 +293,16 @@ func (i rangePartitionIter) Next(ctx *sql.Context) (sql.Partition, error) {
 
 // indexScanPartitionIter is a partition iterator that returns a single partition for an index scan
 type indexScanPartitionIter struct {
-	once   sync.Once
 	index  *Index
 	ranges sql.Expression
 	lookup sql.IndexLookup
+	once   sync.Once
 }
 
 type indexScanPartition struct {
 	index  *Index
-	lookup sql.IndexLookup
 	ranges sql.Expression
+	lookup sql.IndexLookup
 }
 
 func (i indexScanPartition) Key() []byte {
@@ -414,17 +406,18 @@ func (t *Table) PartitionCount(ctx *sql.Context) (int64, error) {
 }
 
 type indexScanRowIter struct {
-	i             int
+	index     *Index
+	ranges    sql.Expression
+	lookup    sql.IndexLookup
+	indexRows []sql.Row
+
 	incrementFunc func()
-	index         *Index
-	lookup        sql.IndexLookup
-	ranges        sql.Expression
 	primaryRows   map[string][]sql.Row
-	indexRows     []sql.Row
 
 	columns     []int
-	numColumns  int
 	virtualCols []int
+	i           int
+	numColumns  int
 }
 
 func newIndexScanRowIter(
@@ -677,13 +670,12 @@ func (p *partitionIter) Next(*sql.Context) (sql.Partition, error) {
 func (p *partitionIter) Close(*sql.Context) error { return nil }
 
 type tableIter struct {
+	indexValues sql.IndexValueIter
+	rows        []sql.Row
+	filters     []sql.Expression
 	columns     []int
 	virtualCols []int
 	numColumns  int
-
-	rows        []sql.Row
-	filters     []sql.Expression
-	indexValues sql.IndexValueIter
 	pos         int
 }
 
@@ -2240,8 +2232,8 @@ func (t *Table) CreatePrimaryKey(ctx *sql.Context, columns []sql.IndexColumn) er
 }
 
 type pkfield struct {
-	i int
 	c *sql.Column
+	i int
 }
 
 type partitionRow struct {
@@ -2250,11 +2242,11 @@ type partitionRow struct {
 }
 
 type partitionssort struct {
-	pk      []pkfield
+	ctx     *sql.Context
 	ps      map[string][]sql.Row
-	allRows []partitionRow
 	indexes map[indexName][]sql.Row
-	ctx     *sql.Context
+	pk      []pkfield
+	allRows []partitionRow
 }
 
 func (ps partitionssort) Len() int {

memory/table_data.go

@@ -33,29 +33,21 @@ import (
 // freely as needed for different views on a table (column projections, index lookups, filters, etc.) but the
 // storage of underlying data lives here.
 type TableData struct {
-	dbName    string
-	tableName string
-	comment   string
-
-	// Schema / config data
-	schema                  sql.PrimaryKeySchema
 	indexes                 map[string]sql.Index
 	fkColl                  *ForeignKeyCollection
+	secondaryIndexStorage   map[indexName][]sql.Row
+	partitions              map[string][]sql.Row
+	fullTextConfigTableName string
+	tableName               string
+	comment                 string
+	dbName                  string
+	schema                  sql.PrimaryKeySchema
 	checks                  []sql.CheckDefinition
-	collation               sql.CollationID
+	partitionKeys           [][]byte
 	autoColIdx              int
+	autoIncVal              uint64
+	collation               sql.CollationID
 	primaryKeyIndexes       bool
-	fullTextConfigTableName string
-
-	// Data storage
-	partitions    map[string][]sql.Row
-	partitionKeys [][]byte
-	autoIncVal    uint64
-
-	// Indexes are implemented as an unordered slice of rows. The first N elements in the row are the values of the
-	// indexed columns, and the final value is the location of the row in the primary storage.
-	// TODO: we could make these much more performant by using a tree or other ordered collection
-	secondaryIndexStorage map[indexName][]sql.Row
 }
 
 type indexName string
@@ -374,7 +366,7 @@ func (td *TableData) sortRows(ctx *sql.Context) {
 	for _, column := range td.schema.Schema {
 		if column.PrimaryKey {
 			idx, col := td.getColumnOrdinal(column.Name)
-			pk = append(pk, pkfield{idx, col})
+			pk = append(pk, pkfield{i: idx, c: col})
 		}
 	}
 

memory/table_editor.go

@@ -28,16 +28,13 @@ import (
 
 // tableEditor manages the edits that a targetTable receives.
 type tableEditor struct {
-	editedTable  *Table
-	initialTable *Table
-
-	discardChanges bool
 	ea             tableEditAccumulator
-
-	// array of key ordinals for each unique index defined on the targetTable
-	uniqueIdxCols [][]int
-	prefixLengths [][]uint16
-	fkTable       *Table
+	editedTable    *Table
+	initialTable   *Table
+	fkTable        *Table
+	uniqueIdxCols  [][]int
+	prefixLengths  [][]uint16
+	discardChanges bool
 }
 
 var _ sql.Table = (*tableEditor)(nil)