Function buildTableEntry

backend/api/mcp/tool_schema.go:578–638

buildTableEntry converts a single tableMetadata into the response shape at the requested detail level.

(t *tableMetadata, include string)

// buildTableEntry converts a single tableMetadata into the response shape at the
// requested detail level.
func buildTableEntry(t *tableMetadata, include string) TableEntry {
	rowCount, _ := t.RowCount.Int64()
	entry := TableEntry{
		Name:     t.Name,
		RowCount: rowCount,
		Comment:  t.Comment,
	}

	if include == schemaIncludeSummary {
		entry.ColumnCount = len(t.Columns)
		return entry
	}

	// Derive primary-key columns from indexes (ColumnMetadata has no primary_key field).
	pkColumns := primaryKeyColumns(t.Indexes)

	entry.Columns = make([]ColumnEntry, 0, len(t.Columns))
	for _, c := range t.Columns {
		col := ColumnEntry{
			Name:       c.Name,
			Type:       c.Type,
			Nullable:   c.Nullable,
			PrimaryKey: pkColumns[c.Name],
		}
		if include == schemaIncludeDetails {
			col.Default = c.Default
			col.Comment = c.Comment
		}
		entry.Columns = append(entry.Columns, col)
	}

	if include == schemaIncludeDetails {
		entry.Indexes = make([]IndexEntry, 0, len(t.Indexes))
		for _, idx := range t.Indexes {
			entry.Indexes = append(entry.Indexes, IndexEntry{
				Name:    idx.Name,
				Type:    idx.Type,
				Unique:  idx.Unique,
				Columns: append([]string{}, idx.Expressions...),
			})
		}
		slices.SortStableFunc(entry.Indexes, func(a, b IndexEntry) int {
			return strings.Compare(a.Name, b.Name)
		})

		entry.ForeignKeys = make([]FKEntry, 0, len(t.ForeignKeys))
		for _, fk := range t.ForeignKeys {
			entry.ForeignKeys = append(entry.ForeignKeys, FKEntry{
				Name:              fk.Name,
				Columns:           append([]string{}, fk.Columns...),
				ReferencedTable:   fk.ReferencedTable,
				ReferencedColumns: append([]string{}, fk.ReferencedColumns...),
			})
		}
		slices.SortStableFunc(entry.ForeignKeys, func(a, b FKEntry) int {
			return strings.Compare(a.Name, b.Name)
		})
	}