More around Tuples

expression.go2

@@ -212,6 +212,12 @@ type NumberExpression[T numeric] interface {
 	NotIn(v ...TypedExpression[T]) NumberExpression[T]
 }
 
+type FactoryExpression[T any] interface {
+	TypedExpression[T]
+	Args() []Expression
+	New() T
+}
+
 // =======================================================
 // Implementations
 

queries.go2

@@ -6,23 +6,23 @@ import (
 )
 
 type WhereClause[T any] interface {
-	Where(e ...PredicateExpression) WhereClause[T]
+	Where(e ...PredicateExpression) T
 }
 
 type SimpleQuery[T any] interface {
 	WhereClause[T]
-	Distinct() SimpleQuery[T]
-	Limit(v int64) SimpleQuery[T]
-	Offset(v int64) SimpleQuery[T]
-	Restrict(m QueryModifiers) SimpleQuery[T]
-	OrderBy(o ...Order) SimpleQuery[T]
-	Set(e ParamExpression, value interface{}) SimpleQuery[T]
+	Distinct() T
+	Limit(v int64) T
+	Offset(v int64) T
+	Restrict(m QueryModifiers) T
+	OrderBy(o ...Order) T
+	Set(e ParamExpression, value interface{}) T
 }
 
 type Query[T any] interface {
 	SimpleQuery[T]
-	GroupBy(e ...Expression) Query[T]
-	Having(e ...PredicateExpression) Query[T]
+	GroupBy(e ...Expression) T
+	Having(e ...PredicateExpression) T
 }
 
 type Fetchable[T any] interface {
@@ -36,18 +36,50 @@ type Fetchable[T any] interface {
 	FetchOneOnly(ctx context.Context) (T, error)
 	// TODO - FetchPage(ctx context.Context, limit, offset int64) (T, error)
 }
-
-func Select[T, Q any](exp TypedExpression[T]) FetchableQuery[T, Q] {
-	return nil
-}
-
 type FetchableQuery[T, Q any] interface {
-	Fetchable[T]
+	// Fetchable[T]
 	SimpleQuery[Q]
 	// Select(exp TypedExpression[T]) FetchableQuery[T]
 	// SelectMany(exp []Expression) FetchableQuery[Tuple?]
 }
 
+func SelectColumn[T any](exp TypedExpression[T]) SimpleQuery[T] {
+	q := SQLQuery[TypedExpression[T]]{}
+	md := &BasicQueryMetadata{}
+	q.mixin = NewQueryMixin(q, md, true)
+	q.mixin.SetProjection(exp)
+	return q
+}
+type SQLQuery[T any] struct {
+	mixin QueryMixin[T]
+}
+func (q SQLQuery[T]) Distinct() T {
+	return q.mixin.SetDistinct(true)
+}
+func (q SQLQuery[T]) Limit(v int64) T {
+	return q.mixin.Limit(v)
+}
+func (q SQLQuery[T]) Offset(v int64) T {
+	return q.mixin.Offset(v)
+}
+func (q SQLQuery[T]) Restrict(m QueryModifiers) T {
+	return q.mixin.Restrict(m)
+}
+func (q SQLQuery[T]) OrderBy(o ...Order) T {
+	return q.mixin.OrderBy(o...)
+}
+func (q SQLQuery[T]) Set(e ParamExpression, value interface{}) T {
+	return q.mixin.SetParam(e, value)
+}
+func (q SQLQuery[T]) Where(p ...PredicateExpression) T {
+	return q.mixin.Where(p...)
+}
+
+
+
+
+
+
 type SubQueryExpression interface {
 	Expression
 	Metadata() QueryMetadata
@@ -237,6 +269,12 @@ const (
 
 
 
+func NewQueryMixin2[T any](qm QueryMetadata, expandPaths bool) QueryMixin[T] {
+	return QueryMixin[T]{
+		qm: qm,
+		expandPaths: expandPaths,
+	}
+}
 
 func NewQueryMixin[T any](self T, qm QueryMetadata, expandPaths bool) QueryMixin[T] {
 	return QueryMixin[T]{
@@ -267,9 +305,10 @@ func (q QueryMixin[T]) AddJoinFlag(jf JoinFlag) T {
 // 	return q.self
 // }
 
-// func (q QueryMixin[T]) SetProjection(e Expression) Expression {
-//
-// }
+func (q QueryMixin[T]) SetProjection(e Expression) Expression {
+	q.qm.SetProjection(e)
+	return e
+}
 
 func (q QueryMixin[T]) Distinct() T {
 	q.qm.SetDistinct(true)
@@ -395,8 +434,9 @@ func (q QueryMixin[T]) SetParam(e ParamExpression, v interface{}) T {
 	return q.self
 }
 
-func (q QueryMixin[T]) SetDistinct(d bool) {
+func (q QueryMixin[T]) SetDistinct(d bool) T {
 	q.qm.SetDistinct(d)
+	return q.self
 }
 func (q QueryMixin[T]) SetSelf(s T) {
 	q.self = s

tuple.go2

@@ -1,9 +1,45 @@
 package lingo
 
+type binding struct {
+	exp Expression
+	pos int
+}
+
 type Tuple struct {
-	values []interface{}
+	values   []Expression
+	bindings []binding
+}
+
+func NewTuple(args []Expression) Tuple {
+	values := make([]Expression, len(args))
+	copy(values, args)
+	return Tuple{
+		values:   values,
+		bindings: createBindings(args),
+	}
+}
+
+func createBindings(args []Expression) []binding {
+	// might need to change this to a map from `binding`
+	var bindings []binding
+	for idx, arg := range args {
+		// if its an alias, include the alias name
+		if op, ok := arg.(Operation); ok {
+			if op.Operator() == OpAlias {
+				bindings = append(bindings, binding{
+					exp: op.Arg(1),
+					pos: idx,
+				})
+			}
+		}
+		bindings = append(bindings, binding{
+			exp: arg,
+			pos: idx,
+		})
+	}
+	return bindings
 }
 
-func NewTuple(args []interface{}) {
-
+func (t Tuple) Args() []Expression {
+	return t.values
 }