init - add project files

tools/jet-2.12.0/postgres/select_statement.go

@@ -0,0 +1,231 @@
+package postgres
+
+import (
+	"math"
+
+	"github.com/go-jet/jet/v2/internal/jet"
+)
+
+// RowLock is interface for SELECT statement row lock types
+type RowLock = jet.RowLock
+
+// Row lock types
+var (
+	UPDATE        = jet.NewRowLock("UPDATE")
+	NO_KEY_UPDATE = jet.NewRowLock("NO KEY UPDATE")
+	SHARE         = jet.NewRowLock("SHARE")
+	KEY_SHARE     = jet.NewRowLock("KEY SHARE")
+)
+
+// Window function clauses
+var (
+	PARTITION_BY = jet.PARTITION_BY
+	ORDER_BY     = jet.ORDER_BY
+	UNBOUNDED    = int64(math.MaxInt64)
+	CURRENT_ROW  = jet.CURRENT_ROW
+)
+
+// PRECEDING window frame clause
+func PRECEDING(offset int64) jet.FrameExtent {
+	return jet.PRECEDING(toJetFrameOffset(offset))
+}
+
+// FOLLOWING window frame clause
+func FOLLOWING(offset int64) jet.FrameExtent {
+	return jet.FOLLOWING(toJetFrameOffset(offset))
+}
+
+// Window definition reference
+var Window = jet.WindowName
+
+// SelectStatement is interface for PostgreSQL SELECT statement
+type SelectStatement interface {
+	Statement
+	jet.HasProjections
+	Expression
+
+	DISTINCT(on ...jet.ColumnExpression) SelectStatement
+	FROM(tables ...ReadableTable) SelectStatement
+	WHERE(expression BoolExpression) SelectStatement
+	GROUP_BY(groupByClauses ...GroupByClause) SelectStatement
+	HAVING(boolExpression BoolExpression) SelectStatement
+	WINDOW(name string) windowExpand
+	ORDER_BY(orderByClauses ...OrderByClause) SelectStatement
+	LIMIT(limit int64) SelectStatement
+	OFFSET(offset int64) SelectStatement
+	// OFFSET_e can be used when an integer expression is needed as offset, otherwise OFFSET can be used
+	OFFSET_e(offset IntegerExpression) SelectStatement
+	FETCH_FIRST(count IntegerExpression) fetchExpand
+	FOR(lock RowLock) SelectStatement
+
+	UNION(rhs SelectStatement) setStatement
+	UNION_ALL(rhs SelectStatement) setStatement
+	INTERSECT(rhs SelectStatement) setStatement
+	INTERSECT_ALL(rhs SelectStatement) setStatement
+	EXCEPT(rhs SelectStatement) setStatement
+	EXCEPT_ALL(rhs SelectStatement) setStatement
+
+	AsTable(alias string) SelectTable
+}
+
+// SELECT creates new SelectStatement with list of projections
+func SELECT(projection Projection, projections ...Projection) SelectStatement {
+	return newSelectStatement(nil, append([]Projection{projection}, projections...))
+}
+
+func newSelectStatement(table ReadableTable, projections []Projection) SelectStatement {
+	newSelect := &selectStatementImpl{}
+	newSelect.ExpressionStatement = jet.NewExpressionStatementImpl(Dialect, jet.SelectStatementType, newSelect,
+		&newSelect.Select,
+		&newSelect.From,
+		&newSelect.Where,
+		&newSelect.GroupBy,
+		&newSelect.Having,
+		&newSelect.Window,
+		&newSelect.OrderBy,
+		&newSelect.Limit,
+		&newSelect.Offset,
+		&newSelect.Fetch,
+		&newSelect.For)
+
+	newSelect.Select.ProjectionList = projections
+	if table != nil {
+		newSelect.From.Tables = []jet.Serializer{table}
+	}
+	newSelect.Limit.Count = -1
+
+	newSelect.setOperatorsImpl.parent = newSelect
+
+	return newSelect
+}
+
+type selectStatementImpl struct {
+	jet.ExpressionStatement
+	setOperatorsImpl
+
+	Select  jet.ClauseSelect
+	From    jet.ClauseFrom
+	Where   jet.ClauseWhere
+	GroupBy jet.ClauseGroupBy
+	Having  jet.ClauseHaving
+	Window  jet.ClauseWindow
+	OrderBy jet.ClauseOrderBy
+	Limit   jet.ClauseLimit
+	Offset  jet.ClauseOffset
+	Fetch   jet.ClauseFetch
+	For     jet.ClauseFor
+}
+
+func (s *selectStatementImpl) DISTINCT(on ...jet.ColumnExpression) SelectStatement {
+	s.Select.Distinct = true
+	s.Select.DistinctOnColumns = on
+	return s
+}
+
+func (s *selectStatementImpl) FROM(tables ...ReadableTable) SelectStatement {
+	s.From.Tables = readableTablesToSerializerList(tables)
+	return s
+}
+
+func (s *selectStatementImpl) WHERE(condition BoolExpression) SelectStatement {
+	s.Where.Condition = condition
+	return s
+}
+
+func (s *selectStatementImpl) GROUP_BY(groupByClauses ...GroupByClause) SelectStatement {
+	s.GroupBy.List = groupByClauses
+	return s
+}
+
+func (s *selectStatementImpl) HAVING(boolExpression BoolExpression) SelectStatement {
+	s.Having.Condition = boolExpression
+	return s
+}
+
+func (s *selectStatementImpl) WINDOW(name string) windowExpand {
+	s.Window.Definitions = append(s.Window.Definitions, jet.WindowDefinition{Name: name})
+	return windowExpand{selectStatement: s}
+}
+
+func (s *selectStatementImpl) ORDER_BY(orderByClauses ...OrderByClause) SelectStatement {
+	s.OrderBy.List = orderByClauses
+	return s
+}
+
+func (s *selectStatementImpl) LIMIT(limit int64) SelectStatement {
+	s.Limit.Count = limit
+	return s
+}
+
+func (s *selectStatementImpl) OFFSET(offset int64) SelectStatement {
+	s.Offset.Count = Int(offset)
+	return s
+}
+
+func (s *selectStatementImpl) OFFSET_e(offset IntegerExpression) SelectStatement {
+	s.Offset.Count = offset
+	return s
+}
+
+func (s *selectStatementImpl) FETCH_FIRST(count IntegerExpression) fetchExpand {
+	s.Fetch.Count = count
+
+	return fetchExpand{
+		selectStatement: s,
+	}
+}
+
+func (s *selectStatementImpl) FOR(lock RowLock) SelectStatement {
+	s.For.Lock = lock
+	return s
+}
+
+func (s *selectStatementImpl) AsTable(alias string) SelectTable {
+	return newSelectTable(s, alias, nil)
+}
+
+//-----------------------------------------------------
+
+type windowExpand struct {
+	selectStatement *selectStatementImpl
+}
+
+func (w windowExpand) AS(window ...jet.Window) SelectStatement {
+	if len(window) == 0 {
+		return w.selectStatement
+	}
+	windowsDefinition := w.selectStatement.Window.Definitions
+	windowsDefinition[len(windowsDefinition)-1].Window = window[0]
+	return w.selectStatement
+}
+
+func toJetFrameOffset(offset int64) jet.Serializer {
+	if offset == UNBOUNDED {
+		return jet.UNBOUNDED
+	}
+	return jet.FixedLiteral(offset)
+}
+
+func readableTablesToSerializerList(tables []ReadableTable) []jet.Serializer {
+	var ret []jet.Serializer
+	for _, table := range tables {
+		ret = append(ret, table)
+	}
+	return ret
+}
+
+type fetchExpand struct {
+	selectStatement *selectStatementImpl
+}
+
+func (f fetchExpand) ROWS_ONLY() SelectStatement {
+	f.selectStatement.Fetch.WithTies = false
+
+	return f.selectStatement
+}
+
+func (f fetchExpand) ROWS_WITH_TIES() SelectStatement {
+	f.selectStatement.Fetch.WithTies = true
+
+	return f.selectStatement
+}