sqlserve

type Client struct {
	// contains filtered or unexported fields
}

type Column struct {
	Name string `json:"name"`
	Type string `json:"type"`
}

type Objects struct {
	Relations []Relation `json:"relations"`
	// Truncated says the service cut the answer, which the tree has to draw:
	// a browser silently missing half a warehouse is worse than one that
	// says it is showing part.
	Truncated bool `json:"truncated"`

	// Writable says a statement on THIS connection may change data, which
	// the console draws and never decides. It arrives here rather than on an
	// endpoint of its own because the tree already asks this question about
	// this connection.
	Writable bool `json:"writable"`
}

type Price struct {
	// State is "priced", "refused" or "unpriced", and the screen draws the
	// three differently: a figure, a warning, and a plain sentence. A
	// warehouse with nothing to say is not a problem with somebody's SQL,
	// and drawing it like one would teach them to ignore the line.
	State string

	// Bytes is what the statement would process, when State is "priced".
	Bytes int64

	// Why is the service's own sentence, when there is no number. It is
	// carried through unchanged: a console that reworded the ceiling's
	// refusal would drift from what actually happens at Run.
	Why string
}

type Refused struct{ Why string }

type Relation struct {
	Schema string `json:"schema"`
	Name   string `json:"name"`
}

type Result struct {
	Columns []string `json:"columns"`
	// Rows holds `any` because NULL IS NOT THE EMPTY STRING: one is "nothing
	// was recorded" and the other is a value somebody wrote, and they are
	// drawn differently. A nil cell is NULL, all the way to the template.
	Rows      [][]any `json:"rows"`
	Truncated bool    `json:"truncated"`
	Limit     int     `json:"limit"`

	// Bytes is what the warehouse says it scanned, Millis how long it took.
	// Both are zero for a preview, which does not report them: a preview is
	// a glance and nobody chose its cost. For a query they go UNDER THE GRID,
	// because the difference between the query somebody wrote and the one
	// that was cheap is the thing a query tab can actually teach.
	Bytes  int64 `json:"bytes"`
	Millis int64 `json:"ms"`

	// Wrote says the statement CHANGED data, and Changed how many rows.
	//
	// A POINTER, because zero is an answer and absence is a different one.
	// An UPDATE whose WHERE matched nothing changed zero rows; a CREATE
	// TABLE changes no rows at all. A screen that said "0 rows" for the
	// second would read as a failure, and whoever ran it would run it again.
	//
	// The console still does not read the SQL. It is told what happened by
	// the only thing that can know -- the service that ran it.
	Wrote   bool   `json:"wrote"`
	Changed *int64 `json:"changed"`
}