24841644892

Committed 23 Apr 2026 02:44PM UTC coverage: 85.279% (-4.0%) from 89.306%

Build # 24841644892

Build Type

push

gh-ci

Committed by

web-flow

Commit Message

feat: v1.11.0 PostgreSQL compatibility and SQL feature expansion (#2090)

* Add structured audit logging with immutable audit trail

Introduces a new --audit-log flag that records all gRPC operations as
structured JSON events in immudb's tamper-proof KV store. Events are
stored under the audit: key prefix in systemdb, queryable via Scan and
verifiable via VerifiableGet. An async buffered writer ensures minimal
latency impact. Configurable event filtering (all/write/admin) via
--audit-log-events flag.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* Add PostgreSQL ORM compatibility layer and verification functions

Extend the pgsql wire protocol with immudb verification functions
(immudb_state, immudb_verify_row, immudb_verify_tx, immudb_history,
immudb_tx) accessible via standard SQL SELECT statements.

Add pg_catalog resolvers (pg_attribute, pg_index, pg_constraint,
pg_type, pg_settings, pg_description) and information_schema
resolvers (tables, columns, schemata, key_column_usage) to support
ORM introspection from Django, SQLAlchemy, GORM, and ActiveRecord.

Add PostgreSQL compatibility functions: current_database,
current_schema, current_user, format_type, pg_encoding_to_char,
pg_get_expr, pg_get_constraintdef, obj_description, col_description,
has_table_privilege, has_schema_privilege, and others.

Add SHOW statement emulation for common ORM config queries and
schema-qualified name stripping for information_schema and public
schema references.

* Implement EXISTS and IN subquery support in SQL engine

Replace the previously stubbed ExistsBoolExp and InSubQueryExp
implementations with working non-correlated subquery execution.

EXISTS subqueries resolve the inner SELECT and check if any rows
are returned. IN subqueries resolve the inner SELECT, iterate the
result set, and compare each value against the outer expression.
Both support NOT variants (NOT EXISTS, NOT IN).

Correlated subqueries (referencing outer query columns) ar... (continued)

Coverage Stats

7254 of 10471 new or added lines in 124 files covered. (69.28%)

115 existing lines in 18 files now uncovered.

44599 of 52298 relevant lines covered (85.28%)

127676.6 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

78.48

/embedded/sql/aggregated_values.go

/*
Copyright 2026 Codenotary Inc. All rights reserved.

SPDX-License-Identifier: BUSL-1.1
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    https://mariadb.com/bsl11/

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package sql

import (
        "strconv"
        "strings"
)

type AggregatedValue interface {
        TypedValue
        updateWith(val TypedValue) error
        Selector() string
        ColBounded() bool
}

type CountValue struct {
        c        int64
        sel      string
        distinct bool
        // allRows is true for COUNT(*) — every row counts including NULLs.
        // false for COUNT(col) — NULL values are skipped per SQL semantics.
        allRows bool
        seen    map[string]bool // for DISTINCT tracking
}

func (v *CountValue) Selector() string {
        return v.sel
}

func (v *CountValue) ColBounded() bool {
        return v.distinct
}

func (v *CountValue) Type() SQLValueType {
        return IntegerType
}

func (v *CountValue) IsNull() bool {
        return false
}

func (v *CountValue) String() string {
        return strconv.FormatInt(v.c, 10)
}

func (v *CountValue) RawValue() interface{} {
        return v.c
}

func (v *CountValue) Compare(val TypedValue) (int, error) {
        if val.Type() != IntegerType {
                return 0, ErrNotComparableValues
        }

        nv := val.RawValue().(int64)

        if v.c == nv {
                return 0, nil
        }

        if v.c > nv {
                return 1, nil
        }

        return -1, nil
}

func (v *CountValue) updateWith(val TypedValue) error {
        if v.distinct {
                if val == nil || val.IsNull() {
                        return nil // NULL values are not counted in DISTINCT
                }
                key := val.String()
                if v.seen == nil {
                        v.seen = make(map[string]bool)
                }
                if v.seen[key] {
                        return nil // already seen this value
                }
                v.seen[key] = true
        } else if !v.allRows {
                // COUNT(col) — skip NULL values per SQL semantics. Only
                // COUNT(*) counts every row regardless of value.
                if val == nil || val.IsNull() {
                        return nil
                }
        }
        v.c++
        return nil
}

// ValueExp

func (v *CountValue) inferType(cols map[string]ColDescriptor, params map[string]SQLValueType, implicitTable string) (SQLValueType, error) {
        return IntegerType, nil
}

func (v *CountValue) requiresType(t SQLValueType, cols map[string]ColDescriptor, params map[string]SQLValueType, implicitTable string) error {
        if t != IntegerType {
                return ErrNotComparableValues
        }
        return nil
}

func (v *CountValue) jointColumnTo(col *Column, tableAlias string) (*ColSelector, error) {
        return nil, ErrUnexpected
}

func (v *CountValue) substitute(params map[string]interface{}) (ValueExp, error) {
        return nil, ErrUnexpected
}

func (v *CountValue) reduce(tx *SQLTx, row *Row, implicitTable string) (TypedValue, error) {
        return nil, ErrUnexpected
}

func (v *CountValue) selectors() []Selector {
        return nil
}

func (v *CountValue) reduceSelectors(row *Row, implicitTable string) ValueExp {
        return nil
}

func (v *CountValue) isConstant() bool {
        return false
}

func (v *CountValue) selectorRanges(table *Table, asTable string, params map[string]interface{}, rangesByColID map[uint32]*typedValueRange) error {
        return nil
}

type SumValue struct {
        val TypedValue
        sel string
}

func (v *SumValue) Selector() string {
        return v.sel
}

func (v *SumValue) ColBounded() bool {
        return true
}

func (v *SumValue) Type() SQLValueType {
        return v.val.Type()
}

func (v *SumValue) IsNull() bool {
        return v.val.IsNull()
}

func (v *SumValue) String() string {
        return v.val.String()
}

func (v *SumValue) RawValue() interface{} {
        return v.val.RawValue()
}

func (v *SumValue) Compare(val TypedValue) (int, error) {
        return v.val.Compare(val)
}

func (v *SumValue) updateWith(val TypedValue) error {
        if val.IsNull() {
                // Skip NULL values
                return nil
        }

        if !IsNumericType(val.Type()) {
                return ErrNumericTypeExpected
        }

        if v.val.IsNull() {
                // First non-null value
                v.val = val
                return nil
        }

        newVal, err := applyNumOperator(ADDOP, v.val, val)
        if err != nil {
                return err
        }

        v.val = newVal

        return nil
}

// ValueExp

func (v *SumValue) inferType(cols map[string]ColDescriptor, params map[string]SQLValueType, implicitTable string) (SQLValueType, error) {
        return IntegerType, nil
}

func (v *SumValue) requiresType(t SQLValueType, cols map[string]ColDescriptor, params map[string]SQLValueType, implicitTable string) error {
        if t != IntegerType {
                return ErrNotComparableValues
        }
        return nil
}

func (v *SumValue) jointColumnTo(col *Column, tableAlias string) (*ColSelector, error) {
        return nil, ErrUnexpected
}

func (v *SumValue) substitute(params map[string]interface{}) (ValueExp, error) {
        return nil, ErrUnexpected
}

func (v *SumValue) reduce(tx *SQLTx, row *Row, implicitTable string) (TypedValue, error) {
        return nil, ErrUnexpected
}

func (v *SumValue) selectors() []Selector {
        return nil
}

func (v *SumValue) reduceSelectors(row *Row, implicitTable string) ValueExp {
        return v
}

func (v *SumValue) isConstant() bool {
        return false
}

func (v *SumValue) selectorRanges(table *Table, asTable string, params map[string]interface{}, rangesByColID map[uint32]*typedValueRange) error {
        return nil
}

type MinValue struct {
        val TypedValue
        sel string
}

func (v *MinValue) Selector() string {
        return v.sel
}

func (v *MinValue) ColBounded() bool {
        return true
}

func (v *MinValue) Type() SQLValueType {
        return v.val.Type()
}

func (v *MinValue) IsNull() bool {
        return v.val.IsNull()
}

func (v *MinValue) String() string {
        return v.val.String()
}

func (v *MinValue) RawValue() interface{} {
        return v.val.RawValue()
}

func (v *MinValue) Compare(val TypedValue) (int, error) {
        return v.val.Compare(val)
}

func (v *MinValue) updateWith(val TypedValue) error {
        if val.IsNull() {
                // Skip NULL values
                return nil
        }

        if v.val.IsNull() {
                // First non-null value
                v.val = val
                return nil
        }

        cmp, err := v.val.Compare(val)
        if err != nil {
                return err
        }

        if cmp == 1 {
                v.val = val
        }

        return nil
}

// ValueExp

func (v *MinValue) inferType(cols map[string]ColDescriptor, params map[string]SQLValueType, implicitTable string) (SQLValueType, error) {
        if v.val.IsNull() {
                return AnyType, ErrUnexpected
        }

        return v.val.Type(), nil
}

func (v *MinValue) requiresType(t SQLValueType, cols map[string]ColDescriptor, params map[string]SQLValueType, implicitTable string) error {
        if v.val.IsNull() {
                return ErrUnexpected
        }

        if t != v.val.Type() {
                return ErrNotComparableValues
        }

        return nil
}

func (v *MinValue) jointColumnTo(col *Column, tableAlias string) (*ColSelector, error) {
        return nil, ErrUnexpected
}

func (v *MinValue) substitute(params map[string]interface{}) (ValueExp, error) {
        return nil, ErrUnexpected
}

func (v *MinValue) reduce(tx *SQLTx, row *Row, implicitTable string) (TypedValue, error) {
        return nil, ErrUnexpected
}

func (v *MinValue) selectors() []Selector {
        return nil
}

func (v *MinValue) reduceSelectors(row *Row, implicitTable string) ValueExp {
        return nil
}

func (v *MinValue) isConstant() bool {
        return false
}

func (v *MinValue) selectorRanges(table *Table, asTable string, params map[string]interface{}, rangesByColID map[uint32]*typedValueRange) error {
        return nil
}

type MaxValue struct {
        val TypedValue
        sel string
}

func (v *MaxValue) Selector() string {
        return v.sel
}

func (v *MaxValue) ColBounded() bool {
        return true
}

func (v *MaxValue) Type() SQLValueType {
        return v.val.Type()
}

func (v *MaxValue) IsNull() bool {
        return v.val.IsNull()
}

func (v *MaxValue) String() string {
        return v.val.String()
}

func (v *MaxValue) RawValue() interface{} {
        return v.val.RawValue()
}

func (v *MaxValue) Compare(val TypedValue) (int, error) {
        return v.val.Compare(val)
}

func (v *MaxValue) updateWith(val TypedValue) error {
        if val.IsNull() {
                // Skip NULL values
                return nil
        }

        if v.val.IsNull() {
                // First non-null value
                v.val = val
                return nil
        }

        cmp, err := v.val.Compare(val)
        if err != nil {
                return err
        }

        if cmp == -1 {
                v.val = val
        }

        return nil
}

// ValueExp

func (v *MaxValue) inferType(cols map[string]ColDescriptor, params map[string]SQLValueType, implicitTable string) (SQLValueType, error) {
        if v.val.IsNull() {
                return AnyType, ErrUnexpected
        }

        return v.val.Type(), nil
}

func (v *MaxValue) requiresType(t SQLValueType, cols map[string]ColDescriptor, params map[string]SQLValueType, implicitTable string) error {
        if v.val.IsNull() {
                return ErrUnexpected
        }

        if t != v.val.Type() {
                return ErrNotComparableValues
        }

        return nil
}

func (v *MaxValue) jointColumnTo(col *Column, tableAlias string) (*ColSelector, error) {
        return nil, ErrUnexpected
}

func (v *MaxValue) substitute(params map[string]interface{}) (ValueExp, error) {
        return nil, ErrUnexpected
}

func (v *MaxValue) reduce(tx *SQLTx, row *Row, implicitTable string) (TypedValue, error) {
        return nil, ErrUnexpected
}

func (v *MaxValue) selectors() []Selector {
        return nil
}

func (v *MaxValue) reduceSelectors(row *Row, implicitTable string) ValueExp {
        return nil
}

func (v *MaxValue) isConstant() bool {
        return false
}

func (v *MaxValue) selectorRanges(table *Table, asTable string, params map[string]interface{}, rangesByColID map[uint32]*typedValueRange) error {
        return nil
}

type AVGValue struct {
        s   TypedValue
        c   int64
        sel string
}

func (v *AVGValue) Selector() string {
        return v.sel
}

func (v *AVGValue) ColBounded() bool {
        return true
}

func (v *AVGValue) Type() SQLValueType {
        return v.s.Type()
}

func (v *AVGValue) IsNull() bool {
        return v.s.IsNull()
}

func (v *AVGValue) String() string {
        return v.calculate().String()
}

func (v *AVGValue) calculate() TypedValue {
        if v.s.IsNull() {
                return nil
        }

        val, err := applyNumOperator(DIVOP, v.s, &Integer{val: v.c})
        if err != nil {
                return &NullValue{t: AnyType}
        }

        return val
}

func (v *AVGValue) RawValue() interface{} {
        return v.calculate().RawValue()
}

func (v *AVGValue) Compare(val TypedValue) (int, error) {
        return v.calculate().Compare(val)
}

func (v *AVGValue) updateWith(val TypedValue) error {
        if val.IsNull() {
                // Skip NULL values
                return nil
        }

        if !IsNumericType(val.Type()) {
                return ErrNumericTypeExpected
        }

        if v.s.IsNull() {
                // First non-null value
                v.s = val
                v.c++
                return nil
        }

        newVal, err := applyNumOperator(ADDOP, v.s, val)
        if err != nil {
                return err
        }

        v.s = newVal
        v.c++
        return nil
}

// ValueExp

func (v *AVGValue) inferType(cols map[string]ColDescriptor, params map[string]SQLValueType, implicitTable string) (SQLValueType, error) {
        return IntegerType, nil
}

func (v *AVGValue) requiresType(t SQLValueType, cols map[string]ColDescriptor, params map[string]SQLValueType, implicitTable string) error {
        if t != IntegerType {
                return ErrNotComparableValues
        }

        return nil
}

func (v *AVGValue) jointColumnTo(col *Column, tableAlias string) (*ColSelector, error) {
        return nil, ErrUnexpected
}

func (v *AVGValue) substitute(params map[string]interface{}) (ValueExp, error) {
        return nil, ErrUnexpected
}

func (v *AVGValue) reduce(tx *SQLTx, row *Row, implicitTable string) (TypedValue, error) {
        return nil, ErrUnexpected
}

func (v *AVGValue) selectors() []Selector {
        return nil
}

func (v *AVGValue) reduceSelectors(row *Row, implicitTable string) ValueExp {
        return nil
}

func (v *AVGValue) isConstant() bool {
        return false
}

func (v *AVGValue) selectorRanges(table *Table, asTable string, params map[string]interface{}, rangesByColID map[uint32]*typedValueRange) error {
        return nil
}

// StringAggValue implements STRING_AGG(col, separator)
type StringAggValue struct {
        parts []string
        sep   string
        sel   string
}

func (v *StringAggValue) Selector() string {
        return v.sel
}

func (v *StringAggValue) ColBounded() bool {
        return true
}

func (v *StringAggValue) Type() SQLValueType {
        return VarcharType
}

func (v *StringAggValue) IsNull() bool {
        return len(v.parts) == 0
}

func (v *StringAggValue) String() string {
        return strings.Join(v.parts, v.sep)
}

func (v *StringAggValue) RawValue() interface{} {
        if len(v.parts) == 0 {
                return ""
        }
        return strings.Join(v.parts, v.sep)
}

func (v *StringAggValue) Compare(val TypedValue) (int, error) {
        if val.Type() != VarcharType {
                return 0, ErrNotComparableValues
        }
        s1 := v.String()
        s2 := val.RawValue().(string)
        if s1 == s2 {
                return 0, nil
        }
        if s1 > s2 {
                return 1, nil
        }
        return -1, nil
}

func (v *StringAggValue) updateWith(val TypedValue) error {
        if val != nil && !val.IsNull() {
                // Strip surrounding quotes from varchar values
                s := val.RawValue().(string)
                v.parts = append(v.parts, s)
        }
        return nil
}

func (v *StringAggValue) inferType(cols map[string]ColDescriptor, params map[string]SQLValueType, implicitTable string) (SQLValueType, error) {
        return VarcharType, nil
}

func (v *StringAggValue) requiresType(t SQLValueType, cols map[string]ColDescriptor, params map[string]SQLValueType, implicitTable string) error {
        if t != VarcharType {
                return ErrNotComparableValues
        }
        return nil
}

func (v *StringAggValue) substitute(params map[string]interface{}) (ValueExp, error) {
        return nil, ErrUnexpected
}

func (v *StringAggValue) reduce(tx *SQLTx, row *Row, implicitTable string) (TypedValue, error) {
        return nil, ErrUnexpected
}

func (v *StringAggValue) jointColumnTo(col *Column, tableAlias string) (*ColSelector, error) {
        return nil, nil
}

func (v *StringAggValue) selectors() []Selector {
        return nil
}

func (v *StringAggValue) reduceSelectors(row *Row, implicitTable string) ValueExp {
        return nil
}

func (v *StringAggValue) isConstant() bool {
        return false
}

func (v *StringAggValue) selectorRanges(table *Table, asTable string, params map[string]interface{}, rangesByColID map[uint32]*typedValueRange) error {
        return nil
}

1	/*
2	Copyright 2026 Codenotary Inc. All rights reserved.
3
4	SPDX-License-Identifier: BUSL-1.1
5	you may not use this file except in compliance with the License.
6	You may obtain a copy of the License at
7
8	https://mariadb.com/bsl11/
9
10	Unless required by applicable law or agreed to in writing, software
11	distributed under the License is distributed on an "AS IS" BASIS,
12	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	See the License for the specific language governing permissions and
14	limitations under the License.
15	*/
16
17	package sql
18
19	import (
20	"strconv"
21	"strings"
22	)
23
24	type AggregatedValue interface {
25	TypedValue
26	updateWith(val TypedValue) error
27	Selector() string
28	ColBounded() bool
29	}
30
31	type CountValue struct {
32	c int64
33	sel string
34	distinct bool
35	// allRows is true for COUNT(*) — every row counts including NULLs.
36	// false for COUNT(col) — NULL values are skipped per SQL semantics.
37	allRows bool
38	seen map[string]bool // for DISTINCT tracking
39	}
40
41	func (v *CountValue) Selector() string {	5✔
42	return v.sel	5✔
43	}	5✔
44
45	func (v *CountValue) ColBounded() bool {	1,515✔
46	return v.distinct	1,515✔
47	}	1,515✔
48
49	func (v *CountValue) Type() SQLValueType {	31✔
50	return IntegerType	31✔
51	}	31✔
52
53	func (v *CountValue) IsNull() bool {	52✔
54	return false	52✔
55	}	52✔
56
57	func (v *CountValue) String() string {	1✔
58	return strconv.FormatInt(v.c, 10)	1✔
59	}	1✔
60
61	func (v *CountValue) RawValue() interface{} {	271✔
62	return v.c	271✔
63	}	271✔
64
65	func (v *CountValue) Compare(val TypedValue) (int, error) {	25✔
66	if val.Type() != IntegerType {	26✔
67	return 0, ErrNotComparableValues	1✔
68	}	1✔
69
70	nv := val.RawValue().(int64)	24✔
71		24✔
72	if v.c == nv {	35✔
73	return 0, nil	11✔
74	}	11✔
75
76	if v.c > nv {	20✔
77	return 1, nil	7✔
78	}	7✔
79
80	return -1, nil	6✔
81	}
82
83	func (v *CountValue) updateWith(val TypedValue) error {	759✔
84	if v.distinct {	763✔
85	if val == nil \|\| val.IsNull() {	6✔
86	return nil // NULL values are not counted in DISTINCT	2✔
87	}	2✔
88	key := val.String()	2✔
89	if v.seen == nil {	2✔
NEW 90	v.seen = make(map[string]bool)	×
NEW 91	}	×
92	if v.seen[key] {	2✔
NEW 93	return nil // already seen this value	×
NEW 94	}	×
95	v.seen[key] = true	2✔
96	} else if !v.allRows {	763✔
97	// COUNT(col) — skip NULL values per SQL semantics. Only	8✔
98	// COUNT(*) counts every row regardless of value.	8✔
99	if val == nil \|\| val.IsNull() {	14✔
100	return nil	6✔
101	}	6✔
102	}
103	v.c++	751✔
104	return nil	751✔
105	}
106
107	// ValueExp
108
109	func (v *CountValue) inferType(cols map[string]ColDescriptor, params map[string]SQLValueType, implicitTable string) (SQLValueType, error) {	1✔
110	return IntegerType, nil	1✔
111	}	1✔
112
113	func (v *CountValue) requiresType(t SQLValueType, cols map[string]ColDescriptor, params map[string]SQLValueType, implicitTable string) error {	3✔
114	if t != IntegerType {	4✔
115	return ErrNotComparableValues	1✔
116	}	1✔
117	return nil	2✔
118	}
119
120	func (v CountValue) jointColumnTo(col Column, tableAlias string) (*ColSelector, error) {	1✔
121	return nil, ErrUnexpected	1✔
122	}	1✔
123
124	func (v *CountValue) substitute(params map[string]interface{}) (ValueExp, error) {	1✔
125	return nil, ErrUnexpected	1✔
126	}	1✔
127
128	func (v CountValue) reduce(tx SQLTx, row *Row, implicitTable string) (TypedValue, error) {	1✔
129	return nil, ErrUnexpected	1✔
130	}	1✔
131
132	func (v *CountValue) selectors() []Selector {	×
133	return nil	×
134	}	×
135
136	func (v CountValue) reduceSelectors(row Row, implicitTable string) ValueExp {	1✔
137	return nil	1✔
138	}	1✔
139
140	func (v *CountValue) isConstant() bool {	1✔
141	return false	1✔
142	}	1✔
143
144	func (v CountValue) selectorRanges(table Table, asTable string, params map[string]interface{}, rangesByColID map[uint32]*typedValueRange) error {	1✔
145	return nil	1✔
146	}	1✔
147
148	type SumValue struct {
149	val TypedValue
150	sel string
151	}
152
153	func (v *SumValue) Selector() string {	147✔
154	return v.sel	147✔
155	}	147✔
156
157	func (v *SumValue) ColBounded() bool {	293✔
158	return true	293✔
159	}	293✔
160
161	func (v *SumValue) Type() SQLValueType {	145✔
162	return v.val.Type()	145✔
163	}	145✔
164
165	func (v *SumValue) IsNull() bool {	139✔
166	return v.val.IsNull()	139✔
167	}	139✔
168
169	func (v *SumValue) String() string {	1✔
170	return v.val.String()	1✔
171	}	1✔
172
173	func (v *SumValue) RawValue() interface{} {	72✔
174	return v.val.RawValue()	72✔
175	}	72✔
176
177	func (v *SumValue) Compare(val TypedValue) (int, error) {	51✔
178	return v.val.Compare(val)	51✔
179	}	51✔
180
181	func (v *SumValue) updateWith(val TypedValue) error {	149✔
182	if val.IsNull() {	152✔
183	// Skip NULL values	3✔
184	return nil	3✔
185	}	3✔
186
187	if !IsNumericType(val.Type()) {	147✔
188	return ErrNumericTypeExpected	1✔
189	}	1✔
190
191	if v.val.IsNull() {	170✔
192	// First non-null value	25✔
193	v.val = val	25✔
194	return nil	25✔
195	}	25✔
196
197	newVal, err := applyNumOperator(ADDOP, v.val, val)	120✔
198	if err != nil {	120✔
199	return err	×
200	}	×
201
202	v.val = newVal	120✔
203		120✔
204	return nil	120✔
205	}
206
207	// ValueExp
208
209	func (v *SumValue) inferType(cols map[string]ColDescriptor, params map[string]SQLValueType, implicitTable string) (SQLValueType, error) {	1✔
210	return IntegerType, nil	1✔
211	}	1✔
212
213	func (v *SumValue) requiresType(t SQLValueType, cols map[string]ColDescriptor, params map[string]SQLValueType, implicitTable string) error {	2✔
214	if t != IntegerType {	3✔
215	return ErrNotComparableValues	1✔
216	}	1✔
217	return nil	1✔
218	}
219
220	func (v SumValue) jointColumnTo(col Column, tableAlias string) (*ColSelector, error) {	1✔
221	return nil, ErrUnexpected	1✔
222	}	1✔
223
224	func (v *SumValue) substitute(params map[string]interface{}) (ValueExp, error) {	1✔
225	return nil, ErrUnexpected	1✔
226	}	1✔
227
228	func (v SumValue) reduce(tx SQLTx, row *Row, implicitTable string) (TypedValue, error) {	1✔
229	return nil, ErrUnexpected	1✔
230	}	1✔
231
232	func (v *SumValue) selectors() []Selector {	×
233	return nil	×
234	}	×
235
236	func (v SumValue) reduceSelectors(row Row, implicitTable string) ValueExp {	1✔
237	return v	1✔
238	}	1✔
239
240	func (v *SumValue) isConstant() bool {	1✔
241	return false	1✔
242	}	1✔
243
244	func (v SumValue) selectorRanges(table Table, asTable string, params map[string]interface{}, rangesByColID map[uint32]*typedValueRange) error {	1✔
245	return nil	1✔
246	}	1✔
247
248	type MinValue struct {
249	val TypedValue
250	sel string
251	}
252
253	func (v *MinValue) Selector() string {	82✔
254	return v.sel	82✔
255	}	82✔
256
257	func (v *MinValue) ColBounded() bool {	163✔
258	return true	163✔
259	}	163✔
260
261	func (v *MinValue) Type() SQLValueType {	7✔
262	return v.val.Type()	7✔
263	}	7✔
264
265	func (v *MinValue) IsNull() bool {	3✔
266	return v.val.IsNull()	3✔
267	}	3✔
268
269	func (v *MinValue) String() string {	1✔
270	return v.val.String()	1✔
271	}	1✔
272
273	func (v *MinValue) RawValue() interface{} {	16✔
274	return v.val.RawValue()	16✔
275	}	16✔
276
277	func (v *MinValue) Compare(val TypedValue) (int, error) {	6✔
278	return v.val.Compare(val)	6✔
279	}	6✔
280
281	func (v *MinValue) updateWith(val TypedValue) error {	84✔
282	if val.IsNull() {	87✔
283	// Skip NULL values	3✔
284	return nil	3✔
285	}	3✔
286
287	if v.val.IsNull() {	96✔
288	// First non-null value	15✔
289	v.val = val	15✔
290	return nil	15✔
291	}	15✔
292
293	cmp, err := v.val.Compare(val)	66✔
294	if err != nil {	67✔
295	return err	1✔
296	}	1✔
297
298	if cmp == 1 {	76✔
299	v.val = val	11✔
300	}	11✔
301
302	return nil	65✔
303	}
304
305	// ValueExp
306
307	func (v *MinValue) inferType(cols map[string]ColDescriptor, params map[string]SQLValueType, implicitTable string) (SQLValueType, error) {	2✔
308	if v.val.IsNull() {	3✔
309	return AnyType, ErrUnexpected	1✔
310	}	1✔
311
312	return v.val.Type(), nil	1✔
313	}
314
315	func (v *MinValue) requiresType(t SQLValueType, cols map[string]ColDescriptor, params map[string]SQLValueType, implicitTable string) error {	3✔
316	if v.val.IsNull() {	4✔
317	return ErrUnexpected	1✔
318	}	1✔
319
320	if t != v.val.Type() {	3✔
321	return ErrNotComparableValues	1✔
322	}	1✔
323
324	return nil	1✔
325	}
326
327	func (v MinValue) jointColumnTo(col Column, tableAlias string) (*ColSelector, error) {	1✔
328	return nil, ErrUnexpected	1✔
329	}	1✔
330
331	func (v *MinValue) substitute(params map[string]interface{}) (ValueExp, error) {	1✔
332	return nil, ErrUnexpected	1✔
333	}	1✔
334
335	func (v MinValue) reduce(tx SQLTx, row *Row, implicitTable string) (TypedValue, error) {	1✔
336	return nil, ErrUnexpected	1✔
337	}	1✔
338
339	func (v *MinValue) selectors() []Selector {	×
340	return nil	×
341	}	×
342
343	func (v MinValue) reduceSelectors(row Row, implicitTable string) ValueExp {	1✔
344	return nil	1✔
345	}	1✔
346
347	func (v *MinValue) isConstant() bool {	1✔
348	return false	1✔
349	}	1✔
350
351	func (v MinValue) selectorRanges(table Table, asTable string, params map[string]interface{}, rangesByColID map[uint32]*typedValueRange) error {	1✔
352	return nil	1✔
353	}	1✔
354
355	type MaxValue struct {
356	val TypedValue
357	sel string
358	}
359
360	func (v *MaxValue) Selector() string {	149✔
361	return v.sel	149✔
362	}	149✔
363
364	func (v *MaxValue) ColBounded() bool {	297✔
365	return true	297✔
366	}	297✔
367
368	func (v *MaxValue) Type() SQLValueType {	23✔
369	return v.val.Type()	23✔
370	}	23✔
371
372	func (v *MaxValue) IsNull() bool {	9✔
373	return v.val.IsNull()	9✔
374	}	9✔
375
376	func (v *MaxValue) String() string {	1✔
377	return v.val.String()	1✔
378	}	1✔
379
380	func (v *MaxValue) RawValue() interface{} {	24✔
381	return v.val.RawValue()	24✔
382	}	24✔
383
384	func (v *MaxValue) Compare(val TypedValue) (int, error) {	7✔
385	return v.val.Compare(val)	7✔
386	}	7✔
387
388	func (v *MaxValue) updateWith(val TypedValue) error {	151✔
389	if val.IsNull() {	154✔
390	// Skip NULL values	3✔
391	return nil	3✔
392	}	3✔
393
394	if v.val.IsNull() {	169✔
395	// First non-null value	21✔
396	v.val = val	21✔
397	return nil	21✔
398	}	21✔
399
400	cmp, err := v.val.Compare(val)	127✔
401	if err != nil {	128✔
402	return err	1✔
403	}	1✔
404
405	if cmp == -1 {	194✔
406	v.val = val	68✔
407	}	68✔
408
409	return nil	126✔
410	}
411
412	// ValueExp
413
414	func (v *MaxValue) inferType(cols map[string]ColDescriptor, params map[string]SQLValueType, implicitTable string) (SQLValueType, error) {	2✔
415	if v.val.IsNull() {	3✔
416	return AnyType, ErrUnexpected	1✔
417	}	1✔
418
419	return v.val.Type(), nil	1✔
420	}
421
422	func (v *MaxValue) requiresType(t SQLValueType, cols map[string]ColDescriptor, params map[string]SQLValueType, implicitTable string) error {	3✔
423	if v.val.IsNull() {	4✔
424	return ErrUnexpected	1✔
425	}	1✔
426
427	if t != v.val.Type() {	3✔
428	return ErrNotComparableValues	1✔
429	}	1✔
430
431	return nil	1✔
432	}
433
434	func (v MaxValue) jointColumnTo(col Column, tableAlias string) (*ColSelector, error) {	1✔
435	return nil, ErrUnexpected	1✔
436	}	1✔
437
438	func (v *MaxValue) substitute(params map[string]interface{}) (ValueExp, error) {	1✔
439	return nil, ErrUnexpected	1✔
440	}	1✔
441
442	func (v MaxValue) reduce(tx SQLTx, row *Row, implicitTable string) (TypedValue, error) {	1✔
443	return nil, ErrUnexpected	1✔
444	}	1✔
445
446	func (v *MaxValue) selectors() []Selector {	×
447	return nil	×
448	}	×
449
450	func (v MaxValue) reduceSelectors(row Row, implicitTable string) ValueExp {	1✔
451	return nil	1✔
452	}	1✔
453
454	func (v *MaxValue) isConstant() bool {	1✔
455	return false	1✔
456	}	1✔
457
458	func (v MaxValue) selectorRanges(table Table, asTable string, params map[string]interface{}, rangesByColID map[uint32]*typedValueRange) error {	1✔
459	return nil	1✔
460	}	1✔
461
462	type AVGValue struct {
463	s TypedValue
464	c int64
465	sel string
466	}
467
468	func (v *AVGValue) Selector() string {	82✔
469	return v.sel	82✔
470	}	82✔
471
472	func (v *AVGValue) ColBounded() bool {	163✔
473	return true	163✔
474	}	163✔
475
476	func (v *AVGValue) Type() SQLValueType {	1✔
477	return v.s.Type()	1✔
478	}	1✔
479
480	func (v *AVGValue) IsNull() bool {	1✔
481	return v.s.IsNull()	1✔
482	}	1✔
483
484	func (v *AVGValue) String() string {	1✔
485	return v.calculate().String()	1✔
486	}	1✔
487
488	func (v *AVGValue) calculate() TypedValue {	21✔
489	if v.s.IsNull() {	21✔
490	return nil	×
491	}	×
492
493	val, err := applyNumOperator(DIVOP, v.s, &Integer{val: v.c})	21✔
494	if err != nil {	21✔
495	return &NullValue{t: AnyType}	×
496	}	×
497
498	return val	21✔
499	}
500
501	func (v *AVGValue) RawValue() interface{} {	12✔
502	return v.calculate().RawValue()	12✔
503	}	12✔
504
505	func (v *AVGValue) Compare(val TypedValue) (int, error) {	8✔
506	return v.calculate().Compare(val)	8✔
507	}	8✔
508
509	func (v *AVGValue) updateWith(val TypedValue) error {	84✔
510	if val.IsNull() {	87✔
511	// Skip NULL values	3✔
512	return nil	3✔
513	}	3✔
514
515	if !IsNumericType(val.Type()) {	82✔
516	return ErrNumericTypeExpected	1✔
517	}	1✔
518
519	if v.s.IsNull() {	94✔
520	// First non-null value	14✔
521	v.s = val	14✔
522	v.c++	14✔
523	return nil	14✔
524	}	14✔
525
526	newVal, err := applyNumOperator(ADDOP, v.s, val)	66✔
527	if err != nil {	66✔
528	return err	×
529	}	×
530
531	v.s = newVal	66✔
532	v.c++	66✔
533	return nil	66✔
534	}
535
536	// ValueExp
537
538	func (v *AVGValue) inferType(cols map[string]ColDescriptor, params map[string]SQLValueType, implicitTable string) (SQLValueType, error) {	1✔
539	return IntegerType, nil	1✔
540	}	1✔
541
542	func (v *AVGValue) requiresType(t SQLValueType, cols map[string]ColDescriptor, params map[string]SQLValueType, implicitTable string) error {	2✔
543	if t != IntegerType {	3✔
544	return ErrNotComparableValues	1✔
545	}	1✔
546
547	return nil	1✔
548	}
549
550	func (v AVGValue) jointColumnTo(col Column, tableAlias string) (*ColSelector, error) {	1✔
551	return nil, ErrUnexpected	1✔
552	}	1✔
553
554	func (v *AVGValue) substitute(params map[string]interface{}) (ValueExp, error) {	1✔
555	return nil, ErrUnexpected	1✔
556	}	1✔
557
558	func (v AVGValue) reduce(tx SQLTx, row *Row, implicitTable string) (TypedValue, error) {	1✔
559	return nil, ErrUnexpected	1✔
560	}	1✔
561
562	func (v *AVGValue) selectors() []Selector {	×
563	return nil	×
564	}	×
565
566	func (v AVGValue) reduceSelectors(row Row, implicitTable string) ValueExp {	1✔
567	return nil	1✔
568	}	1✔
569
570	func (v *AVGValue) isConstant() bool {	1✔
571	return false	1✔
572	}	1✔
573
574	func (v AVGValue) selectorRanges(table Table, asTable string, params map[string]interface{}, rangesByColID map[uint32]*typedValueRange) error {	1✔
575	return nil	1✔
576	}	1✔
577
578	// StringAggValue implements STRING_AGG(col, separator)
579	type StringAggValue struct {
580	parts []string
581	sep string
582	sel string
583	}
584
NEW 585	func (v *StringAggValue) Selector() string {	×
NEW 586	return v.sel	×
NEW 587	}	×
588
NEW 589	func (v *StringAggValue) ColBounded() bool {	×
NEW 590	return true	×
NEW 591	}	×
592
NEW 593	func (v *StringAggValue) Type() SQLValueType {	×
NEW 594	return VarcharType	×
NEW 595	}	×
596
NEW 597	func (v *StringAggValue) IsNull() bool {	×
NEW 598	return len(v.parts) == 0	×
NEW 599	}	×
600
NEW 601	func (v *StringAggValue) String() string {	×
NEW 602	return strings.Join(v.parts, v.sep)	×
NEW 603	}	×
604
NEW 605	func (v *StringAggValue) RawValue() interface{} {	×
NEW 606	if len(v.parts) == 0 {	×
NEW 607	return ""	×
NEW 608	}	×
NEW 609	return strings.Join(v.parts, v.sep)	×
610	}
611
NEW 612	func (v *StringAggValue) Compare(val TypedValue) (int, error) {	×
NEW 613	if val.Type() != VarcharType {	×
NEW 614	return 0, ErrNotComparableValues	×
NEW 615	}	×
NEW 616	s1 := v.String()	×
NEW 617	s2 := val.RawValue().(string)	×
NEW 618	if s1 == s2 {	×
NEW 619	return 0, nil	×
NEW 620	}	×
NEW 621	if s1 > s2 {	×
NEW 622	return 1, nil	×
NEW 623	}	×
NEW 624	return -1, nil	×
625	}
626
NEW 627	func (v *StringAggValue) updateWith(val TypedValue) error {	×
NEW 628	if val != nil && !val.IsNull() {	×
NEW 629	// Strip surrounding quotes from varchar values	×
NEW 630	s := val.RawValue().(string)	×
NEW 631	v.parts = append(v.parts, s)	×
NEW 632	}	×
NEW 633	return nil	×
634	}
635
NEW 636	func (v *StringAggValue) inferType(cols map[string]ColDescriptor, params map[string]SQLValueType, implicitTable string) (SQLValueType, error) {	×
NEW 637	return VarcharType, nil	×
NEW 638	}	×
639
NEW 640	func (v *StringAggValue) requiresType(t SQLValueType, cols map[string]ColDescriptor, params map[string]SQLValueType, implicitTable string) error {	×
NEW 641	if t != VarcharType {	×
NEW 642	return ErrNotComparableValues	×
NEW 643	}	×
NEW 644	return nil	×
645	}
646
NEW 647	func (v *StringAggValue) substitute(params map[string]interface{}) (ValueExp, error) {	×
NEW 648	return nil, ErrUnexpected	×
NEW 649	}	×
650
NEW 651	func (v StringAggValue) reduce(tx SQLTx, row *Row, implicitTable string) (TypedValue, error) {	×
NEW 652	return nil, ErrUnexpected	×
NEW 653	}	×
654
NEW 655	func (v StringAggValue) jointColumnTo(col Column, tableAlias string) (*ColSelector, error) {	×
NEW 656	return nil, nil	×
NEW 657	}	×
658
NEW 659	func (v *StringAggValue) selectors() []Selector {	×
NEW 660	return nil	×
NEW 661	}	×
662
NEW 663	func (v StringAggValue) reduceSelectors(row Row, implicitTable string) ValueExp {	×
NEW 664	return nil	×
NEW 665	}	×
666
NEW 667	func (v *StringAggValue) isConstant() bool {	×
NEW 668	return false	×
NEW 669	}	×
670
NEW 671	func (v StringAggValue) selectorRanges(table Table, asTable string, params map[string]interface{}, rangesByColID map[uint32]*typedValueRange) error {	×
NEW 672	return nil	×
NEW 673	}	×

codenotary / immudb / 24841644892

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous