From 0151728191020a5b95c42d674668418d904f9c99 Mon Sep 17 00:00:00 2001 From: "Graciliano M. P." Date: Sun, 8 Nov 2026 05:13:39 -0300 Subject: [PATCH 1/9] Refactor conditions: ordering comparisons written once, shared helpers - condition: a private `_Ordering` enum (gt, gte, lt, lte; `mirrored`, `test`) behind the ordering methods of `ConditionParameter` and `Condition` (public methods kept as one-line delegates; the unused `keyType` documented), and a private `_KeyConditionOrdering` base of the four `KeyCondition{GreaterThan,...}` classes (constructors, `cast` and symbols kept). `encodeValue` moved into `KeyCondition`. - `ConditionParameter.matchesIn`: the parameters among the values are resolved once, not once per element. - `KeyConditionRegExp._literalRegExp` -> `_literalRegExpCache`, documented. - encoder: `isReservedWord` by a const set; `TypeInfo.from(valueType)` computed once; `EncodingContext.parameterValue`. - condition SQL: `_encodeIDComparison`, `_requireTableScheme`, `_writeEmptySetMatch`, `qualifiedColumnSQL`. Co-Authored-By: Claude Opus 5.5 --- lib/src/bones_api_condition.dart | 649 +++++++++-------------- lib/src/bones_api_condition_encoder.dart | 89 ++-- lib/src/bones_api_condition_sql.dart | 130 ++--- 3 files changed, 358 insertions(+), 510 deletions(-) diff --git a/lib/src/bones_api_condition.dart b/lib/src/bones_api_condition.dart index b012697c..d25d9a5d 100644 --- a/lib/src/bones_api_condition.dart +++ b/lib/src/bones_api_condition.dart @@ -270,27 +270,14 @@ class ConditionParameter extends ConditionElement { List? positionalParameters, Map? namedParameters, EntityHandler? entityHandler, - }) { - var myValue = getValue( - parameters: parameters, - positionalParameters: positionalParameters, - namedParameters: namedParameters, - ); - - var otherValue = value is ConditionParameter - ? value.getValue( - parameters: parameters, - positionalParameters: positionalParameters, - namedParameters: namedParameters, - ) - : value; - - return EntityHandler.graterThanValue( - myValue, - otherValue, - entityHandler: entityHandler, - ); - } + }) => _compareOrdering( + _Ordering.gt, + value, + parameters, + positionalParameters, + namedParameters, + entityHandler, + ); bool greaterThanOrEqual( Object? value, { @@ -298,27 +285,14 @@ class ConditionParameter extends ConditionElement { List? positionalParameters, Map? namedParameters, EntityHandler? entityHandler, - }) { - var myValue = getValue( - parameters: parameters, - positionalParameters: positionalParameters, - namedParameters: namedParameters, - ); - - var otherValue = value is ConditionParameter - ? value.getValue( - parameters: parameters, - positionalParameters: positionalParameters, - namedParameters: namedParameters, - ) - : value; - - return EntityHandler.graterThanOrEqualValue( - myValue, - otherValue, - entityHandler: entityHandler, - ); - } + }) => _compareOrdering( + _Ordering.gte, + value, + parameters, + positionalParameters, + namedParameters, + entityHandler, + ); bool lessThan( Object? value, { @@ -326,27 +300,14 @@ class ConditionParameter extends ConditionElement { List? positionalParameters, Map? namedParameters, EntityHandler? entityHandler, - }) { - var myValue = getValue( - parameters: parameters, - positionalParameters: positionalParameters, - namedParameters: namedParameters, - ); - - var otherValue = value is ConditionParameter - ? value.getValue( - parameters: parameters, - positionalParameters: positionalParameters, - namedParameters: namedParameters, - ) - : value; - - return EntityHandler.lessThanValue( - myValue, - otherValue, - entityHandler: entityHandler, - ); - } + }) => _compareOrdering( + _Ordering.lt, + value, + parameters, + positionalParameters, + namedParameters, + entityHandler, + ); bool lessThanOrEqual( Object? value, { @@ -354,7 +315,28 @@ class ConditionParameter extends ConditionElement { List? positionalParameters, Map? namedParameters, EntityHandler? entityHandler, - }) { + }) => _compareOrdering( + _Ordering.lte, + value, + parameters, + positionalParameters, + namedParameters, + entityHandler, + ); + + /// Compares this parameter's value (the left side) with [value] (the right + /// side, itself resolved if it's a [ConditionParameter]) by [ordering]. + /// + /// The shared body of [greaterThan], [greaterThanOrEqual], [lessThan] and + /// [lessThanOrEqual], which only differ by the [ordering]. + bool _compareOrdering( + _Ordering ordering, + Object? value, + Object? parameters, + List? positionalParameters, + Map? namedParameters, + EntityHandler? entityHandler, + ) { var myValue = getValue( parameters: parameters, positionalParameters: positionalParameters, @@ -369,11 +351,7 @@ class ConditionParameter extends ConditionElement { ) : value; - return EntityHandler.lessThanOrEqualValue( - myValue, - otherValue, - entityHandler: entityHandler, - ); + return ordering.test(myValue, otherValue, entityHandler); } bool matchesIn( @@ -391,18 +369,25 @@ class ConditionParameter extends ConditionElement { checkNotRegExpValue(myValue); - if (myValue is List) { - for (var v1 in myValue) { - checkNotRegExpValue(v1); - for (var v2 in values) { - var otherValue = v2 is ConditionParameter + // Resolve the parameters among [values] once, not once per element of + // `myValue` (`getValue` is pure, but it may convert the `parameters` + // object with `Json.toJson` on every call): + var otherValues = values + .map( + (v2) => v2 is ConditionParameter ? v2.getValue( parameters: parameters, positionalParameters: positionalParameters, namedParameters: namedParameters, ) - : v2; + : v2, + ) + .toList(); + if (myValue is List) { + for (var v1 in myValue) { + checkNotRegExpValue(v1); + for (var otherValue in otherValues) { var match = EntityHandler.equalsValuesBasic( v1, otherValue, @@ -414,15 +399,7 @@ class ConditionParameter extends ConditionElement { return false; } else { - for (var v2 in values) { - var otherValue = v2 is ConditionParameter - ? v2.getValue( - parameters: parameters, - positionalParameters: positionalParameters, - namedParameters: namedParameters, - ) - : v2; - + for (var otherValue in otherValues) { var match = EntityHandler.equalsValuesBasic( myValue, otherValue, @@ -472,6 +449,50 @@ class ConditionParameter extends ConditionElement { (contextPosition?.hashCode ?? 0); } +/// The four ordering comparisons of a condition (`>`, `>=`, `<`, `<=`). +/// +/// Written once here, instead of once per operator in [ConditionParameter], +/// [Condition] and the `KeyCondition` subclasses: used by +/// [ConditionParameter._compareOrdering], [Condition._orderingConditionValue] +/// and [_KeyConditionOrdering]. +enum _Ordering { + gt('>'), + gte('>='), + lt('<'), + lte('<='); + + /// The operator symbol, as encoded in a condition (see [Condition.encode]). + final String symbol; + + const _Ordering(this.symbol); + + /// The same comparison with its sides swapped: `a > b` is `b < a`. Used + /// when the [ConditionParameter] to resolve is the right side. + _Ordering get mirrored => switch (this) { + gt => lt, + gte => lte, + lt => gt, + lte => gte, + }; + + /// Compares [a] with [b] by the matching [EntityHandler] function. + bool test(Object? a, Object? b, EntityHandler? entityHandler) => + switch (this) { + gt => EntityHandler.graterThanValue(a, b, entityHandler: entityHandler), + gte => EntityHandler.graterThanOrEqualValue( + a, + b, + entityHandler: entityHandler, + ), + lt => EntityHandler.lessThanValue(a, b, entityHandler: entityHandler), + lte => EntityHandler.lessThanOrEqualValue( + a, + b, + entityHandler: entityHandler, + ), + }; +} + abstract class EntityMatcher { bool matchesEntity( O o, { @@ -558,6 +579,10 @@ abstract class Condition extends ConditionElement static bool _isToManyValues(Object? value1, Object? value2) => value1 is Iterable && value2 is! Iterable; + /// If [value1] `>` [value2] (see [_orderingConditionValue]). + /// + /// [keyType] is unused: kept for the API (and symmetry with + /// [equalsConditionValue]). bool greaterThanConditionValue( Object? value1, Object? value2, { @@ -566,47 +591,20 @@ abstract class Condition extends ConditionElement Map? namedParameters, TypeInfo? keyType, EntityHandler? keyEntityHandler, - }) { - if (_isToManyValues(value1, value2)) { - return (value1 as Iterable).any( - (v) => greaterThanConditionValue( - v, - value2, - parameters: parameters, - positionalParameters: positionalParameters, - namedParameters: namedParameters, - keyType: keyType, - keyEntityHandler: keyEntityHandler, - ), - ); - } - - if (value1 is ConditionParameter) { - return value1.greaterThan( - value2, - parameters: parameters, - positionalParameters: positionalParameters, - namedParameters: namedParameters, - entityHandler: keyEntityHandler, - ); - } else if (value2 is ConditionParameter) { - return value2.lessThan( - value1, - parameters: parameters, - positionalParameters: positionalParameters, - namedParameters: namedParameters, - entityHandler: keyEntityHandler, - ); - } else { - var match = EntityHandler.graterThanValue( - value1, - value2, - entityHandler: keyEntityHandler, - ); - return match; - } - } + }) => _orderingConditionValue( + _Ordering.gt, + value1, + value2, + parameters, + positionalParameters, + namedParameters, + keyEntityHandler, + ); + /// If [value1] `>=` [value2] (see [_orderingConditionValue]). + /// + /// [keyType] is unused: kept for the API (and symmetry with + /// [equalsConditionValue]). bool greaterThanOrEqualConditionValue( Object? value1, Object? value2, { @@ -615,47 +613,20 @@ abstract class Condition extends ConditionElement Map? namedParameters, TypeInfo? keyType, EntityHandler? keyEntityHandler, - }) { - if (_isToManyValues(value1, value2)) { - return (value1 as Iterable).any( - (v) => greaterThanOrEqualConditionValue( - v, - value2, - parameters: parameters, - positionalParameters: positionalParameters, - namedParameters: namedParameters, - keyType: keyType, - keyEntityHandler: keyEntityHandler, - ), - ); - } - - if (value1 is ConditionParameter) { - return value1.greaterThanOrEqual( - value2, - parameters: parameters, - positionalParameters: positionalParameters, - namedParameters: namedParameters, - entityHandler: keyEntityHandler, - ); - } else if (value2 is ConditionParameter) { - return value2.lessThanOrEqual( - value1, - parameters: parameters, - positionalParameters: positionalParameters, - namedParameters: namedParameters, - entityHandler: keyEntityHandler, - ); - } else { - var match = EntityHandler.graterThanOrEqualValue( - value1, - value2, - entityHandler: keyEntityHandler, - ); - return match; - } - } + }) => _orderingConditionValue( + _Ordering.gte, + value1, + value2, + parameters, + positionalParameters, + namedParameters, + keyEntityHandler, + ); + /// If [value1] `<` [value2] (see [_orderingConditionValue]). + /// + /// [keyType] is unused: kept for the API (and symmetry with + /// [equalsConditionValue]). bool lessThanConditionValue( Object? value1, Object? value2, { @@ -664,47 +635,20 @@ abstract class Condition extends ConditionElement Map? namedParameters, TypeInfo? keyType, EntityHandler? keyEntityHandler, - }) { - if (_isToManyValues(value1, value2)) { - return (value1 as Iterable).any( - (v) => lessThanConditionValue( - v, - value2, - parameters: parameters, - positionalParameters: positionalParameters, - namedParameters: namedParameters, - keyType: keyType, - keyEntityHandler: keyEntityHandler, - ), - ); - } - - if (value1 is ConditionParameter) { - return value1.lessThan( - value2, - parameters: parameters, - positionalParameters: positionalParameters, - namedParameters: namedParameters, - entityHandler: keyEntityHandler, - ); - } else if (value2 is ConditionParameter) { - return value2.greaterThan( - value1, - parameters: parameters, - positionalParameters: positionalParameters, - namedParameters: namedParameters, - entityHandler: keyEntityHandler, - ); - } else { - var match = EntityHandler.lessThanValue( - value1, - value2, - entityHandler: keyEntityHandler, - ); - return match; - } - } + }) => _orderingConditionValue( + _Ordering.lt, + value1, + value2, + parameters, + positionalParameters, + namedParameters, + keyEntityHandler, + ); + /// If [value1] `<=` [value2] (see [_orderingConditionValue]). + /// + /// [keyType] is unused: kept for the API (and symmetry with + /// [equalsConditionValue]). bool lessThanOrEqualConditionValue( Object? value1, Object? value2, { @@ -713,44 +657,69 @@ abstract class Condition extends ConditionElement Map? namedParameters, TypeInfo? keyType, EntityHandler? keyEntityHandler, - }) { + }) => _orderingConditionValue( + _Ordering.lte, + value1, + value2, + parameters, + positionalParameters, + namedParameters, + keyEntityHandler, + ); + + /// Compares [value1] (an entity's value) with [value2] by [ordering]: the + /// shared body of [greaterThanConditionValue], + /// [greaterThanOrEqualConditionValue], [lessThanConditionValue] and + /// [lessThanOrEqualConditionValue]. + /// + /// - The values of a to-many relationship: any of them (as a SQL join of + /// its rows). + /// - A [ConditionParameter] on the left is resolved and compared by + /// [ordering]; on the right, it's the left side of the [_Ordering.mirrored] + /// comparison (`a > ?` is `? < a`). + bool _orderingConditionValue( + _Ordering ordering, + Object? value1, + Object? value2, + Object? parameters, + List? positionalParameters, + Map? namedParameters, + EntityHandler? keyEntityHandler, + ) { if (_isToManyValues(value1, value2)) { return (value1 as Iterable).any( - (v) => lessThanOrEqualConditionValue( + (v) => _orderingConditionValue( + ordering, v, value2, - parameters: parameters, - positionalParameters: positionalParameters, - namedParameters: namedParameters, - keyType: keyType, - keyEntityHandler: keyEntityHandler, + parameters, + positionalParameters, + namedParameters, + keyEntityHandler, ), ); } if (value1 is ConditionParameter) { - return value1.lessThanOrEqual( + return value1._compareOrdering( + ordering, value2, - parameters: parameters, - positionalParameters: positionalParameters, - namedParameters: namedParameters, - entityHandler: keyEntityHandler, + parameters, + positionalParameters, + namedParameters, + keyEntityHandler, ); } else if (value2 is ConditionParameter) { - return value2.greaterThanOrEqual( + return value2._compareOrdering( + ordering.mirrored, value1, - parameters: parameters, - positionalParameters: positionalParameters, - namedParameters: namedParameters, - entityHandler: keyEntityHandler, + parameters, + positionalParameters, + namedParameters, + keyEntityHandler, ); } else { - var match = EntityHandler.lessThanOrEqualValue( - value1, - value2, - entityHandler: keyEntityHandler, - ); - return match; + return ordering.test(value1, value2, keyEntityHandler); } } @@ -1488,6 +1457,9 @@ abstract class KeyCondition extends Condition { } } + /// The [value] encoded as in a condition string (see [encode]). + String get encodeValue => Condition.encodeConditionValue(value); + /// If `true` this is a negated operator (`!=`, `!~`), that also matches a /// `null` field. bool get isNegated => false; @@ -2149,8 +2121,6 @@ class KeyConditionEQ extends KeyCondition { ); } - String get encodeValue => Condition.encodeConditionValue(value); - @override String encode() => '$encodeKey == $encodeValue'; } @@ -2262,21 +2232,20 @@ class KeyConditionNotEQ extends KeyCondition { return notEquals(keyValue); } - String get encodeValue => Condition.encodeConditionValue(value); - @override String encode() => '$encodeKey != $encodeValue'; } -class KeyConditionGreaterThan extends KeyCondition { - KeyConditionGreaterThan(super.keys, dynamic super.value); +/// The base of the ordering key conditions ([KeyConditionGreaterThan], +/// [KeyConditionGreaterThanOrEqual], [KeyConditionLessThan] and +/// [KeyConditionLessThanOrEqual]), which only differ by their [_ordering]: +/// matching and encoding are written once here. Each public subclass keeps +/// its own constructor and [cast]. +abstract class _KeyConditionOrdering extends KeyCondition { + _KeyConditionOrdering(super.keys, super.value); - @override - KeyConditionGreaterThan cast() => - this is KeyConditionGreaterThan - ? this as KeyConditionGreaterThan - : KeyConditionGreaterThan(keys, value) - .._markResolved(resolved, _parent); + /// The comparison of this condition. + _Ordering get _ordering; @override bool matchesEntity( @@ -2288,12 +2257,14 @@ class KeyConditionGreaterThan extends KeyCondition { }) { var keyValue = getEntityKeyValue(o, entityHandler); - return greaterThanConditionValue( + return _orderingConditionValue( + _ordering, keyValue, value, - parameters: parameters, - positionalParameters: positionalParameters, - namedParameters: namedParameters, + parameters, + positionalParameters, + namedParameters, + null, ); } @@ -2307,189 +2278,75 @@ class KeyConditionGreaterThan extends KeyCondition { }) { var keyValue = getEntityMapKeyValue(o, entityHandler); - return greaterThanConditionValue( + return _orderingConditionValue( + _ordering, keyValue?.value, value, - parameters: parameters, - positionalParameters: positionalParameters, - namedParameters: namedParameters, - keyType: keyValue?.type, - keyEntityHandler: keyValue?.entityHandler, + parameters, + positionalParameters, + namedParameters, + keyValue?.entityHandler, ); } - String get encodeValue => Condition.encodeConditionValue(value); - @override - String encode() => '$encodeKey > $encodeValue'; + String encode() => '$encodeKey ${_ordering.symbol} $encodeValue'; } -class KeyConditionGreaterThanOrEqual extends KeyCondition { - KeyConditionGreaterThanOrEqual(super.keys, dynamic super.value); +class KeyConditionGreaterThan extends _KeyConditionOrdering { + KeyConditionGreaterThan(super.keys, dynamic super.value); @override - KeyConditionGreaterThanOrEqual cast() => - this is KeyConditionGreaterThanOrEqual - ? this as KeyConditionGreaterThanOrEqual - : KeyConditionGreaterThanOrEqual(keys, value) - .._markResolved(resolved, _parent); + _Ordering get _ordering => _Ordering.gt; @override - bool matchesEntity( - O o, { - EntityHandler? entityHandler, - Object? parameters, - List? positionalParameters, - Map? namedParameters, - }) { - var keyValue = getEntityKeyValue(o, entityHandler); + KeyConditionGreaterThan cast() => + this is KeyConditionGreaterThan + ? this as KeyConditionGreaterThan + : KeyConditionGreaterThan(keys, value) + .._markResolved(resolved, _parent); +} - return greaterThanOrEqualConditionValue( - keyValue, - value, - parameters: parameters, - positionalParameters: positionalParameters, - namedParameters: namedParameters, - ); - } +class KeyConditionGreaterThanOrEqual extends _KeyConditionOrdering { + KeyConditionGreaterThanOrEqual(super.keys, dynamic super.value); @override - bool matchesEntityMap( - Map o, { - EntityHandler? entityHandler, - Object? parameters, - List? positionalParameters, - Map? namedParameters, - }) { - var keyValue = getEntityMapKeyValue(o, entityHandler); - - return greaterThanOrEqualConditionValue( - keyValue?.value, - value, - parameters: parameters, - positionalParameters: positionalParameters, - namedParameters: namedParameters, - keyType: keyValue?.type, - keyEntityHandler: keyValue?.entityHandler, - ); - } - - String get encodeValue => Condition.encodeConditionValue(value); + _Ordering get _ordering => _Ordering.gte; @override - String encode() => '$encodeKey >= $encodeValue'; + KeyConditionGreaterThanOrEqual cast() => + this is KeyConditionGreaterThanOrEqual + ? this as KeyConditionGreaterThanOrEqual + : KeyConditionGreaterThanOrEqual(keys, value) + .._markResolved(resolved, _parent); } -class KeyConditionLessThan extends KeyCondition { +class KeyConditionLessThan extends _KeyConditionOrdering { KeyConditionLessThan(super.keys, dynamic super.value); + @override + _Ordering get _ordering => _Ordering.lt; + @override KeyConditionLessThan cast() => this is KeyConditionLessThan ? this as KeyConditionLessThan : KeyConditionLessThan(keys, value) .._markResolved(resolved, _parent); - - @override - bool matchesEntity( - O o, { - EntityHandler? entityHandler, - Object? parameters, - List? positionalParameters, - Map? namedParameters, - }) { - var keyValue = getEntityKeyValue(o, entityHandler); - - return lessThanConditionValue( - keyValue, - value, - parameters: parameters, - positionalParameters: positionalParameters, - namedParameters: namedParameters, - ); - } - - @override - bool matchesEntityMap( - Map o, { - EntityHandler? entityHandler, - Object? parameters, - List? positionalParameters, - Map? namedParameters, - }) { - var keyValue = getEntityMapKeyValue(o, entityHandler); - - return lessThanConditionValue( - keyValue?.value, - value, - parameters: parameters, - positionalParameters: positionalParameters, - namedParameters: namedParameters, - keyType: keyValue?.type, - keyEntityHandler: keyValue?.entityHandler, - ); - } - - String get encodeValue => Condition.encodeConditionValue(value); - - @override - String encode() => '$encodeKey < $encodeValue'; } -class KeyConditionLessThanOrEqual extends KeyCondition { +class KeyConditionLessThanOrEqual extends _KeyConditionOrdering { KeyConditionLessThanOrEqual(super.keys, dynamic super.value); + @override + _Ordering get _ordering => _Ordering.lte; + @override KeyConditionLessThanOrEqual cast() => this is KeyConditionLessThanOrEqual ? this as KeyConditionLessThanOrEqual : KeyConditionLessThanOrEqual(keys, value) .._markResolved(resolved, _parent); - - @override - bool matchesEntity( - O o, { - EntityHandler? entityHandler, - Object? parameters, - List? positionalParameters, - Map? namedParameters, - }) { - var keyValue = getEntityKeyValue(o, entityHandler); - - return lessThanOrEqualConditionValue( - keyValue, - value, - parameters: parameters, - positionalParameters: positionalParameters, - namedParameters: namedParameters, - ); - } - - @override - bool matchesEntityMap( - Map o, { - EntityHandler? entityHandler, - Object? parameters, - List? positionalParameters, - Map? namedParameters, - }) { - var keyValue = getEntityMapKeyValue(o, entityHandler); - - return lessThanOrEqualConditionValue( - keyValue?.value, - value, - parameters: parameters, - positionalParameters: positionalParameters, - namedParameters: namedParameters, - keyType: keyValue?.type, - keyEntityHandler: keyValue?.entityHandler, - ); - } - - String get encodeValue => Condition.encodeConditionValue(value); - - @override - String encode() => '$encodeKey <= $encodeValue'; } abstract class KeyConditionINBase extends KeyCondition> { @@ -2721,8 +2578,6 @@ abstract class KeyConditionINBase extends KeyCondition> { return inIDs(keyValue) != not; } - String get encodeValue => Condition.encodeConditionValue(value); - @override String encode() => '$encodeKey ${not ? '!' : '='}~ $encodeValue'; } @@ -2906,8 +2761,12 @@ class KeyConditionRegExp extends KeyCondition { } } - /// The [RegExp] of a literal pattern (without a parameter). - RegExp? _literalRegExp; + /// A cache of the [RegExp] of a literal [pattern] (without a parameter), + /// filled by [_resolveRegExp]. + /// + /// Why: a literal pattern never changes, and a condition is matched once + /// per entity (an in-memory select): compiled once, not once per entity. + RegExp? _literalRegExpCache; /// The [RegExp] of this condition, with its parameter's value, if any. /// @@ -2921,7 +2780,7 @@ class KeyConditionRegExp extends KeyCondition { ) { var pattern = this.pattern; if (pattern != null) { - return _literalRegExp ??= toDartRegExp( + return _literalRegExpCache ??= toDartRegExp( pattern, caseInsensitive: caseInsensitive, ); @@ -3066,6 +2925,8 @@ class KeyConditionRegExp extends KeyCondition { return s.toString(); } + /// A regexp is encoded as `/pattern/flags`, not as a JSON value. + @override String get encodeValue { var value = this.value; var body = value is String ? encodePatternLiteral(value) : value.toString(); diff --git a/lib/src/bones_api_condition_encoder.dart b/lib/src/bones_api_condition_encoder.dart index 89030052..6db422a9 100644 --- a/lib/src/bones_api_condition_encoder.dart +++ b/lib/src/bones_api_condition_encoder.dart @@ -1267,38 +1267,36 @@ class EncodingContext { return null; } - bool isValidAlias(String alias) { - if (isReservedWord(alias)) { - return false; - } - - return true; - } - - bool isReservedWord(String alias) { - return alias == 'as' || - alias == 'eq' || - alias == 'by' || - alias == 'null' || - alias == 'not' || - alias == 'def' || - alias == 'sum' || - alias == 'add' || - alias == 'from' || - alias == 'default' || - alias == 'alias' || - alias == 'equals' || - alias == 'count' || - alias == 'order' || - alias == 'table' || - alias == 'column' || - alias == 'select' || - alias == 'alter' || - alias == 'drop' || - alias == 'delete' || - alias == 'sql' || - alias == 'empty'; - } + bool isValidAlias(String alias) => !isReservedWord(alias); + + /// The words that can't be a generated table alias (see [isReservedWord]): + /// SQL keywords and function names an alias could collide with. + static const Set _reservedAliases = { + 'as', + 'eq', + 'by', + 'null', + 'not', + 'def', + 'sum', + 'add', + 'from', + 'default', + 'alias', + 'equals', + 'count', + 'order', + 'table', + 'column', + 'select', + 'alter', + 'drop', + 'delete', + 'sql', + 'empty', + }; + + bool isReservedWord(String alias) => _reservedAliases.contains(alias); String addEncodingParameter( String suggestedKey, @@ -1326,6 +1324,16 @@ class EncodingContext { throw StateError("Can't create encoding parameter: $suggestedKey = $value"); } + + /// The value of [parameter], resolved with all the parameters of this + /// context ([parameters], [positionalParameters], [namedParameters] and + /// [encodingParameters]). + Object? parameterValue(ConditionParameter parameter) => parameter.getValue( + parameters: parameters, + positionalParameters: positionalParameters, + namedParameters: namedParameters, + encodingParameters: encodingParameters, + ); } /// Base class to encode [Condition]. @@ -1732,12 +1740,7 @@ abstract class ConditionEncoder { Type? valueType, bool valueAsList, ) { - var paramValue = value.getValue( - parameters: context.parameters, - positionalParameters: context.positionalParameters, - namedParameters: context.namedParameters, - encodingParameters: context.encodingParameters, - ); + var paramValue = context.parameterValue(value); // Not a regexp pattern parameter (`/?/`), which `encodeKeyConditionRegExp` // resolves: a `RegExp` here would be compared as its text. @@ -1805,13 +1808,15 @@ abstract class ConditionEncoder { } FutureOr _resolveValueToTypeImpl(Object? value, Type valueType) { + // `late`: computed once, and only if needed (the early returns below + // don't need it). + late final valueTypeInfo = TypeInfo.from(valueType); + // A list as a single value (`== [x]` is `== x`), unless the field is a // list itself (a `List`, a `Uint8List`: compared as a whole): // first, so its element is resolved as a value (an enum by its name, an // entity by its ID), not the list as text. - if (value is Iterable && - value is! TypedData && - !TypeInfo.from(valueType).isIterable) { + if (value is Iterable && value is! TypedData && !valueTypeInfo.isIterable) { var list = value.toList(); if (list.isEmpty) return null; if (list.length == 1) value = list.first; @@ -1872,8 +1877,6 @@ abstract class ConditionEncoder { if (entityID != null) value = entityID; } - var valueTypeInfo = TypeInfo.from(valueType); - var valueParser = TypeParser.parserForTypeInfo(valueTypeInfo); if (valueParser != null) { if (value is Iterable && valueTypeInfo.isPrimitiveType) { diff --git a/lib/src/bones_api_condition_sql.dart b/lib/src/bones_api_condition_sql.dart index 1bbc614a..4cc96917 100644 --- a/lib/src/bones_api_condition_sql.dart +++ b/lib/src/bones_api_condition_sql.dart @@ -137,40 +137,42 @@ class ConditionSQLEncoder extends ConditionEncoder { FutureOr encodeIDCondition( ConditionID c, EncodingContext context, - ) { - var tableName = context.tableNameOrEntityName; - var tableAlias = context.resolveEntityAlias(tableName); + ) => _encodeIDComparison(context, c.idValue, isList: false); - // Never `null`: required by the constructor. - var tableSchemeRet = schemeProvider!.getTableScheme(tableName); + @override + FutureOr encodeIDConditionIN( + ConditionIdIN c, + EncodingContext context, + ) => _encodeIDComparison(context, c.idsValues, isList: true); - return tableSchemeRet.resolveMapped((tableScheme) { - if (tableScheme == null) { - var errorMsg = "Can't find `TableScheme` for entity/table: $tableName"; - _log.severe(errorMsg); - throw StateError(errorMsg); - } + /// The shared body of [encodeIDCondition] (`#ID == x`) and + /// [encodeIDConditionIN] (`#ID =~ [x, y]`, [isList]): resolves the ID + /// column of the [context]'s table and writes its comparison with + /// [idValue] (see [encodeIDValues]). + FutureOr _encodeIDComparison( + EncodingContext context, + Object? idValue, { + required bool isList, + }) { + var tableName = context.tableNameOrEntityName; + var tableAlias = context.resolveEntityAlias(tableName); + return _requireTableScheme(tableName).resolveMapped((tableScheme) { var idFieldName = tableScheme.idFieldName ?? 'id'; var idType = tableScheme.fieldsTypes[idFieldName] ?? int; - var idKey = context.addEncodingParameter(idFieldName, c.idValue); - var q = sqlElementQuote; + var idKey = context.addEncodingParameter(idFieldName, idValue); // The column, not `idKey` (renamed if a query parameter has its name): - var tableKey = '$q$tableAlias$q.$q$idFieldName$q'; + var tableKey = qualifiedColumnSQL(tableAlias, idFieldName); - return encodeIDValues(context, idType, idKey, tableKey, c.idValue, false); + return encodeIDValues(context, idType, idKey, tableKey, idValue, isList); }); } - @override - FutureOr encodeIDConditionIN( - ConditionIdIN c, - EncodingContext context, - ) { - var tableName = context.tableNameOrEntityName; - var tableAlias = context.resolveEntityAlias(tableName); - + /// The [TableScheme] of [tableName], or a [StateError] (logged) if there's + /// none. Used by the encoders that need the main table's scheme + /// ([_encodeIDComparison] and [keyFieldToSQL]). + FutureOr _requireTableScheme(String tableName) { // Never `null`: required by the constructor. var tableSchemeRet = schemeProvider!.getTableScheme(tableName); @@ -180,26 +182,18 @@ class ConditionSQLEncoder extends ConditionEncoder { _log.severe(errorMsg); throw StateError(errorMsg); } - - var idFieldName = tableScheme.idFieldName ?? 'id'; - var idType = tableScheme.fieldsTypes[idFieldName] ?? int; - - var idKey = context.addEncodingParameter(idFieldName, c.idsValues); - var q = sqlElementQuote; - // The column, not `idKey` (renamed if a query parameter has its name): - var tableKey = '$q$tableAlias$q.$q$idFieldName$q'; - - return encodeIDValues( - context, - idType, - idKey, - tableKey, - c.idsValues, - true, - ); + return tableScheme; }); } + /// A column qualified by its table alias, quoted with [sqlElementQuote]: + /// `"alias"."column"`. As `SQLDialect.qualifiedColumnSQL` (with the + /// dialect's quote). + String qualifiedColumnSQL(String tableAlias, String column) { + var q = sqlElementQuote; + return '$q$tableAlias$q.$q$column$q'; + } + /// Writes the comparison of the ID column ([tableKey]) with [idValue] (`=`) /// or with the [idValue] list (`IN`), as parameters (placeholders) rather /// than values written into the SQL: the statement text is the same for @@ -385,12 +379,7 @@ class ConditionSQLEncoder extends ConditionEncoder { var patternParameter = c.patternParameter; if (patternParameter != null) { - var paramValue = patternParameter.getValue( - parameters: context.parameters, - positionalParameters: context.positionalParameters, - namedParameters: context.namedParameters, - encodingParameters: context.encodingParameters, - ); + var paramValue = context.parameterValue(patternParameter); (pattern, caseInsensitive) = KeyConditionRegExp.resolvePatternValue( paramValue, @@ -486,14 +475,19 @@ class ConditionSQLEncoder extends ConditionEncoder { var values = c.value; if (values is! List || values.length != 1) return false; var p = values.first; - return p is ConditionParameter && - p.getValue( - parameters: context.parameters, - positionalParameters: context.positionalParameters, - namedParameters: context.namedParameters, - encodingParameters: context.encodingParameters, - ) == - null; + return p is ConditionParameter && context.parameterValue(p) == null; + } + + /// Writes the match of an empty set of values (`x =~ []`): `IN` matches + /// nothing (`FALSE`) and `NOT IN` everything (`TRUE`, also a `NULL`). + /// Used by [encodeConditionValuesWithOperator] for an empty list, and for a + /// relationship's list with only `null`s. + EncodingContext _writeEmptySetMatch( + EncodingContext context, + String operator, + ) { + context.write(operator == 'IN' ? ' FALSE ' : ' TRUE '); + return context; } /// If [c]'s key is a single relationship field of the main entity: its `IN` @@ -601,8 +595,7 @@ class ConditionSQLEncoder extends ConditionEncoder { // as a list with a `null`), except for a relationship // ([nullsAsAbsent], below). if (elements.isEmpty) { - context.write(operator == 'IN' ? ' FALSE ' : ' TRUE '); - return context; + return _writeEmptySetMatch(context, operator); } var nonNulls = elements @@ -620,8 +613,7 @@ class ConditionSQLEncoder extends ConditionEncoder { // A relationship's set of IDs ([_isRelationshipKey]): its `null`s // aren't IDs. Without any other, an empty set (as `[]`). if (nonNulls.isEmpty) { - context.write(operator == 'IN' ? ' FALSE ' : ' TRUE '); - return context; + return _writeEmptySetMatch(context, operator); } value = EncodingValueList( value.key, @@ -801,17 +793,7 @@ class ConditionSQLEncoder extends ConditionEncoder { var keys = c.keys; var key0 = keys.first as ConditionKeyField; - var tableSchemeRet = schemeProvider.getTableScheme(tableName); - - return tableSchemeRet.resolveMapped((tableScheme) { - if (tableScheme == null) { - var errorMsg = "Can't find `TableScheme` for entity/table: $tableName"; - _log.severe(errorMsg); - throw StateError(errorMsg); - } - - var q = sqlElementQuote; - + return _requireTableScheme(tableName).resolveMapped((tableScheme) { var fieldName = key0.name; var tableFieldName = tableScheme.resolveTableFieldName(fieldName); var tableFieldType = tableFieldName != null @@ -819,7 +801,10 @@ class ConditionSQLEncoder extends ConditionEncoder { : null; if (tableFieldType != null) { - return MapEntry(tableFieldType, '$q$tableAlias$q.$q$tableFieldName$q'); + return MapEntry( + tableFieldType, + qualifiedColumnSQL(tableAlias, tableFieldName!), + ); } var retFieldType = schemeProvider.getFieldType( @@ -874,7 +859,7 @@ class ConditionSQLEncoder extends ConditionEncoder { return MapEntry( relationshipTargetFieldType, - '$q$relationshipAlias$q.$q$relationshipTargetField$q', + qualifiedColumnSQL(relationshipAlias, relationshipTargetField), ); }); }); @@ -952,9 +937,8 @@ class ConditionSQLEncoder extends ConditionEncoder { final alias = context.resolveEntityAlias(targetTable); final type = scheme.fieldsTypes[fieldName]!; - final q = sqlElementQuote; - return MapEntry(type, '$q$alias$q.$q$fieldName$q'); + return MapEntry(type, qualifiedColumnSQL(alias, fieldName)); }); } From c213c07732cdc9ce364e311a783525e66fa13b8a Mon Sep 17 00:00:00 2001 From: "Graciliano M. P." Date: Sun, 8 Nov 2026 05:13:39 -0300 Subject: [PATCH 2/9] Refactor SQL builder: index/constraint names in one place, cache fields - `SQLGenerator.uniqueConstraintName`, `indexName`, `foreignKeyName` and `relationshipTableName` (byte-identical names), also used by the scheme check and the in-memory adapter's relationship table. - Locals `constrain*Name` -> `constraint*Name`. - `SQLDialect.qualifiedColumnSQL` (used by `orderBySQL`). - `CreateTableSQL`/`AlterTableSQL` table caches named `*Cache`, documented. Co-Authored-By: Claude Opus 5.5 --- lib/src/bones_api_entity_db_memory.dart | 5 +- lib/src/bones_api_entity_db_sql.dart | 2 +- lib/src/bones_api_sql_builder.dart | 147 +++++++++++++++++------- 3 files changed, 112 insertions(+), 42 deletions(-) diff --git a/lib/src/bones_api_entity_db_memory.dart b/lib/src/bones_api_entity_db_memory.dart index 22f9cd06..922b2fd0 100644 --- a/lib/src/bones_api_entity_db_memory.dart +++ b/lib/src/bones_api_entity_db_memory.dart @@ -1660,7 +1660,10 @@ class DBSQLMemoryAdapter extends DBSQLAdapter ?.type ?? int; - var relTable = '${sourceTable}__${sourceField}__rel'; + var relTable = SQLGenerator.relationshipTableName( + sourceTable, + sourceField, + ); var relSourceField = '${sourceTable}__$sourceFieldId'; var relTargetField = '${targetTable}__$targetField'; diff --git a/lib/src/bones_api_entity_db_sql.dart b/lib/src/bones_api_entity_db_sql.dart index d2f54cf7..c13f96de 100644 --- a/lib/src/bones_api_entity_db_sql.dart +++ b/lib/src/bones_api_entity_db_sql.dart @@ -4465,7 +4465,7 @@ class _DBTableCheck { var column = sqlGenerator.normalizeColumnName(f.name); return sqlGenerator.generateAddUniqueConstraintSQL( table, - '${table}__${column}__unique', + SQLGenerator.uniqueConstraintName(table, column), [column], comment: '${f.type.toString(withT: false)} ${f.name} UNIQUE', ); diff --git a/lib/src/bones_api_sql_builder.dart b/lib/src/bones_api_sql_builder.dart index 758d9c87..6f8c517a 100644 --- a/lib/src/bones_api_sql_builder.dart +++ b/lib/src/bones_api_sql_builder.dart @@ -201,6 +201,13 @@ class SQLDialect extends DBDialect { this.subqueryAsDerivedTable = false, }); + /// A [column] qualified by its [tableAlias], quoted with [elementQuote]: + /// `"alias"."column"`. + String qualifiedColumnSQL(String tableAlias, String column) { + var q = elementQuote; + return '$q$tableAlias$q.$q$column$q'; + } + /// Builds the ` ORDER BY . ASC|DESC` clause /// of this dialect. String orderBySQL( @@ -208,9 +215,8 @@ class SQLDialect extends DBDialect { String column, { OrderDirection? direction, }) { - var q = elementQuote; var keyword = OrderDirection.resolve(direction).sqlKeyword; - return ' ORDER BY $q$tableAlias$q.$q$column$q $keyword'; + return ' ORDER BY ${qualifiedColumnSQL(tableAlias, column)} $keyword'; } /// Builds the ` LIMIT OFFSET ` clause of this dialect. @@ -480,27 +486,39 @@ class CreateTableSQL extends TableSQL { this.entityRepository, }); - List? _referenceTables; + /// A cache of [referenceTables], filled on its first call. + /// + /// Why: it's called repeatedly while sorting the tables by their + /// dependencies, and it's derived from the [entries]. Reset by + /// [_disposeCache]. + List? _referenceTablesCache; @override - List get referenceTables => _referenceTables ??= { + List get referenceTables => _referenceTablesCache ??= { ...entries.expand((e) => e.referenceTables ?? []), }.toList(); - List? _relationshipsTables; + /// A cache of [relationshipsTables], filled on its first call. As + /// [_referenceTablesCache], derived from the [relationships]. Reset by + /// [_disposeCache]. + List? _relationshipsTablesCache; /// Returns the tables of the [relationships]. - List get relationshipsTables => _relationshipsTables ??= { - ...?relationships?.expand( - (e) => e.referenceTables.where((t) => t != table), - ), - }.toList(); + List get relationshipsTables => + _relationshipsTablesCache ??= { + ...?relationships?.expand( + (e) => e.referenceTables.where((t) => t != table), + ), + }.toList(); - List? _referenceAndRelationshipTables; + /// A cache of [referenceAndRelationshipTables] (the [dependentTables]), + /// filled on its first call. As [_referenceTablesCache]. Reset by + /// [_disposeCache]. + List? _referenceAndRelationshipTablesCache; /// Returns the tables in [referenceTables] and [relationshipsTables]. List get referenceAndRelationshipTables => - _referenceAndRelationshipTables ??= { + _referenceAndRelationshipTablesCache ??= { ...referenceTables, ...relationshipsTables, }.toList(); @@ -520,9 +538,9 @@ class CreateTableSQL extends TableSQL { entries.where((e) => e.type == 'CONSTRAINT').toList(); void _disposeCache() { - _referenceTables = null; - _relationshipsTables = null; - _referenceAndRelationshipTables = null; + _referenceTablesCache = null; + _relationshipsTablesCache = null; + _referenceAndRelationshipTablesCache = null; } /// Converts the [constraints] to [AlterTableSQL]. @@ -685,10 +703,14 @@ class AlterTableSQL extends TableSQL { super.parentTable, }); - List? _referenceTables; + /// A cache of [referenceTables], filled on its first call. + /// + /// Why: it's called repeatedly while sorting the tables by their + /// dependencies, and it's derived from the [entries]. + List? _referenceTablesCache; @override - List get referenceTables => _referenceTables ??= { + List get referenceTables => _referenceTablesCache ??= { ...entries.expand((e) => e.referenceTables ?? []).nonNulls, }.toList(); @@ -1429,6 +1451,36 @@ extension SQLBuilderListExtension on List { /// Base class for a `SQL` generator. abstract mixin class SQLGenerator { + /// The name of the `UNIQUE` constraint (or unique index, where a + /// constraint can't be added) of [column] of [table]: + /// `____unique`. Without a [column], of the whole [table] + /// (a relationship table's `UNIQUE (source, target)`): + /// `
__unique`. + /// + /// The single source of these names: the `CREATE TABLE`, the `ALTER TABLE` + /// that adds a missing one, and the scheme check that looks for it must + /// agree on it. + static String uniqueConstraintName(String table, [String? column]) => + column == null ? '${table}__unique' : '${table}__${column}__unique'; + + /// The name of the (non-unique) index of [column] of [table]: + /// `
____idx`. + static String indexName(String table, String column) => + '${table}__${column}__idx'; + + /// The name of the `FOREIGN KEY` constraint of [column] of [table]: + /// `
____fkey`. + static String foreignKeyName(String table, String column) => + '${table}__${column}__fkey'; + + /// The name of the relationship table of the to-many field [column] of + /// [table]: `
____rel`. + /// + /// Also used to find it in the in-memory adapter, which must match the + /// name of the SQL adapters' tables. + static String relationshipTableName(String table, String column) => + '${table}__${column}__rel'; + /// The generated SQL dialect. SQLDialect get dialect; @@ -1753,7 +1805,10 @@ abstract mixin class SQLGenerator { if (entityFieldAnnotations != null && entityFieldAnnotations.isNotEmpty) { if (entityFieldAnnotations.hasUnique && !alterTableAddConstraint) { - var uniqueIndexName = '${table}__${columnName}__unique'; + var uniqueIndexName = SQLGenerator.uniqueConstraintName( + table, + columnName, + ); indexes = [ CreateIndexSQL.columns( dialect, @@ -1765,11 +1820,14 @@ abstract mixin class SQLGenerator { ), ]; } else if (entityFieldAnnotations.hasUnique) { - var constrainUniqueName = '${table}__${columnName}__unique'; + var constraintUniqueName = SQLGenerator.uniqueConstraintName( + table, + columnName, + ); var uniqueEntry = SQLEntry( 'CONSTRAINT', - ' ADD CONSTRAINT $q$constrainUniqueName$q UNIQUE ($q$columnName$q)', + ' ADD CONSTRAINT $q$constraintUniqueName$q UNIQUE ($q$columnName$q)', columns: [ SQLColumn( table, @@ -1784,7 +1842,7 @@ abstract mixin class SQLGenerator { AlterTableSQL(dialect, table, [uniqueEntry]), ]; } else if (entityFieldAnnotations.hasIndexed) { - var indexName = '${table}__${columnName}__idx'; + var indexName = SQLGenerator.indexName(table, columnName); indexes = [CreateIndexSQL(dialect, table, columnName, indexName)]; } } @@ -1798,13 +1856,13 @@ abstract mixin class SQLGenerator { // (Without `ADD CONSTRAINT`: in the column, above.) if (alterTableAddConstraint) { - var constrainName = '${table}__${columnName}__fkey'; + var constraintName = SQLGenerator.foreignKeyName(table, columnName); constraints ??= []; var constraintEntry = SQLEntry( 'CONSTRAINT', - ' ADD CONSTRAINT $q$constrainName$q FOREIGN KEY ($q$columnName$q) REFERENCES $q$refTableName$q($q$refField$q)', + ' ADD CONSTRAINT $q$constraintName$q FOREIGN KEY ($q$columnName$q) REFERENCES $q$refTableName$q($q$refField$q)', comment: '$fieldName @ $refTableName.$refField', columns: [ SQLColumn( @@ -1820,7 +1878,7 @@ abstract mixin class SQLGenerator { } if (!dialect.foreignKeyCreatesImplicitIndex) { - var indexName = '${table}__${columnName}__idx'; + var indexName = SQLGenerator.indexName(table, columnName); indexes ??= []; indexes.add( @@ -1850,7 +1908,7 @@ abstract mixin class SQLGenerator { var columnName = normalizeColumnName(fieldName); // The same name as in the `CREATE TABLE`: - var constraintName = '${table}__${columnName}__unique'; + var constraintName = SQLGenerator.uniqueConstraintName(table, columnName); var comment = '${fieldType.toString(withT: false)} $fieldName UNIQUE'; @@ -2139,12 +2197,15 @@ abstract mixin class SQLGenerator { if (entityFieldAnnotations != null) { if (entityFieldAnnotations.hasUnique) { - var constrainUniqueName = '${table}__${columnName}__unique'; + var constraintUniqueName = SQLGenerator.uniqueConstraintName( + table, + columnName, + ); sqlEntries.add( SQLEntry( 'CONSTRAINT', - ' CONSTRAINT $q$constrainUniqueName$q UNIQUE ($q$columnName$q)', + ' CONSTRAINT $q$constraintUniqueName$q UNIQUE ($q$columnName$q)', columns: [ SQLColumn( table, @@ -2157,11 +2218,11 @@ abstract mixin class SQLGenerator { ); uniqueConstraints.add(( - name: constrainUniqueName, + name: constraintUniqueName, columns: [columnName], )); } else if (entityFieldAnnotations.hasIndexed) { - var indexName = '${table}__${columnName}__idx'; + var indexName = SQLGenerator.indexName(table, columnName); indexSQLs.add( CreateIndexSQL(dialect, table, columnName, indexName, q: q), ); @@ -2178,12 +2239,12 @@ abstract mixin class SQLGenerator { var refTableName = ref.key; var refField = ref.value.key.toLowerCase(); - var constrainName = '${table}__${columnName}__fkey'; + var constraintName = SQLGenerator.foreignKeyName(table, columnName); sqlEntries.add( SQLEntry( 'CONSTRAINT', - ' CONSTRAINT $q$constrainName$q FOREIGN KEY ($q$columnName$q) REFERENCES $q$refTableName$q($q$refField$q)', + ' CONSTRAINT $q$constraintName$q FOREIGN KEY ($q$columnName$q) REFERENCES $q$refTableName$q($q$refField$q)', comment: '$fieldName @ $refTableName.$refField', columns: [ SQLColumn( @@ -2197,7 +2258,7 @@ abstract mixin class SQLGenerator { ); if (!dialect.foreignKeyCreatesImplicitIndex) { - var indexName = '${table}__${columnName}__idx'; + var indexName = SQLGenerator.indexName(table, columnName); indexSQLs.add( CreateIndexSQL(dialect, table, columnName, indexName, q: q), ); @@ -2308,11 +2369,17 @@ abstract mixin class SQLGenerator { var dstFieldName = normalizeColumnName(relDstTable); - var relName = '${table}__${columnName}__rel'; + var relName = SQLGenerator.relationshipTableName(table, columnName); - var constrainUniqueName = '${relName}__unique'; - var constrainSrcName = '${relName}__${srcFieldName}__fkey'; - var constrainDstName = '${relName}__${dstFieldName}__fkey'; + var constraintUniqueName = SQLGenerator.uniqueConstraintName(relName); + var constraintSrcName = SQLGenerator.foreignKeyName( + relName, + srcFieldName, + ); + var constraintDstName = SQLGenerator.foreignKeyName( + relName, + dstFieldName, + ); var sqlRelEntries = [ SQLEntry( @@ -2344,7 +2411,7 @@ abstract mixin class SQLGenerator { ), SQLEntry( 'CONSTRAINT', - ' CONSTRAINT $q$constrainUniqueName$q UNIQUE ($q$srcFieldName$q, $q$dstFieldName$q)', + ' CONSTRAINT $q$constraintUniqueName$q UNIQUE ($q$srcFieldName$q, $q$dstFieldName$q)', columns: [ SQLColumn(relName, srcFieldName), SQLColumn(relName, dstFieldName), @@ -2352,7 +2419,7 @@ abstract mixin class SQLGenerator { ), SQLEntry( 'CONSTRAINT', - ' CONSTRAINT $q$constrainSrcName$q FOREIGN KEY ($q$srcFieldName$q) REFERENCES $q$table$q($q$idColumnName$q) ON DELETE CASCADE', + ' CONSTRAINT $q$constraintSrcName$q FOREIGN KEY ($q$srcFieldName$q) REFERENCES $q$table$q($q$idColumnName$q) ON DELETE CASCADE', comment: ' $srcFieldName @ $table.$idColumnName', columns: [ SQLColumn( @@ -2365,7 +2432,7 @@ abstract mixin class SQLGenerator { ), SQLEntry( 'CONSTRAINT', - ' CONSTRAINT $q$constrainDstName$q FOREIGN KEY ($q$dstFieldName$q) REFERENCES $q$relDstTable$q($q$relDstTableId$q) ON DELETE CASCADE', + ' CONSTRAINT $q$constraintDstName$q FOREIGN KEY ($q$dstFieldName$q) REFERENCES $q$relDstTable$q($q$relDstTableId$q) ON DELETE CASCADE', comment: ' $dstFieldName @ $relDstTable.$relDstTableId', columns: [ SQLColumn( @@ -2385,7 +2452,7 @@ abstract mixin class SQLGenerator { // the target column needs its own index (another one on the source // would just be updated on every write). if (!dialect.foreignKeyCreatesImplicitIndex) { - var indexName2 = '${relName}__${dstFieldName}__idx'; + var indexName2 = SQLGenerator.indexName(relName, dstFieldName); relIndexes.add( CreateIndexSQL(dialect, relName, dstFieldName, indexName2, q: q), From 5068dab8b69f0670c636384c547b0a997a9be0ee Mon Sep 17 00:00:00 2001 From: "Graciliano M. P." Date: Sun, 8 Nov 2026 05:18:44 -0300 Subject: [PATCH 3/9] Refactor DB SQL adapter: table check helpers, relationship SQLs, JOINs - `_checkDBTableScheme` split into helpers named after its sections (`_findMissingReferenceConstraints`, `_findMissingRelationshipIndexes`, `_findMissingEnumConstraints`, `_dedupeMissingEntityIndexes`, `_findEntityIndexesNameConflicts`, `_tableCheckErrorLine`), with `_sameManagerEntityTypes` for the identical to-one/to-many blocks, a local `columnsOf`, and the "No scheme" message written once. - Relationship generators: `_requireTableScheme`, `_requireRelationship`; `_generateConstrainRelationshipSQL` takes the resolved relationship; `_selectRelationshipSQLText` and `_executeSelectRelationshipSQL` shared by the single/multiple relationship selects. - JOINs: `SQLDialect.qualifiedColumnSQL` and `_joinKeyword` (same SQL). - `SQL`: `_positionalCache` declared before the method that fills it; the lazy positional fields documented. - Typo locals (`colum`, `constrainSQL`). Co-Authored-By: Claude Opus 5.5 --- lib/src/bones_api_entity_db_sql.dart | 911 ++++++++++++++------------- 1 file changed, 477 insertions(+), 434 deletions(-) diff --git a/lib/src/bones_api_entity_db_sql.dart b/lib/src/bones_api_entity_db_sql.dart index c13f96de..528e81a9 100644 --- a/lib/src/bones_api_entity_db_sql.dart +++ b/lib/src/bones_api_entity_db_sql.dart @@ -192,6 +192,14 @@ class SQL implements SQLWrapper { static final RegExp _defaultPlaceholderRegexp = RegExp(r'@(\w+)'); + // The lazily computed [sqlPositional], [parametersKeysByPosition] and + // [parametersValuesByPosition] (`null`: not computed yet), filled together + // by [_computeSQLPositional] on the first access of any of them: only an + // adapter with positional placeholders (`?`) needs them. They can also be + // given to the constructor (a [copy]). Not named `*Cache` because they're + // also private named constructor parameters (`sqlPositional:` ...), whose + // public names would change. + String? _sqlPositional; List? _parametersKeysByPosition; @@ -290,6 +298,17 @@ class SQL implements SQLWrapper { return _parametersValuesByPosition!; } + /// A cache of [sqlPositional] and [parametersKeysByPosition] by SQL text + /// (default placeholder only), filled by [_computeSQLPositional]. + /// + /// Why: the same statements repeat, and converting their placeholders is a + /// regexp replace per statement: only the values are resolved per + /// instance. Cleared when it reaches [_positionalCacheLimit] (e.g. SQLs + /// with inlined values, all different). + static final Map)> _positionalCache = {}; + + static const int _positionalCacheLimit = 2000; + void _computeSQLPositional() { var keys = []; var values = []; @@ -339,13 +358,6 @@ class SQL implements SQLWrapper { _parametersValuesByPosition ??= values; } - /// [sqlPositional] and [parametersKeysByPosition] by SQL text (default - /// placeholder only). Cleared when it reaches [_positionalCacheLimit] - /// (e.g. SQLs with inlined values, all different). - static final Map)> _positionalCache = {}; - - static const int _positionalCacheLimit = 2000; - @override String toString() { var s = StringBuffer(); @@ -1242,13 +1254,10 @@ abstract class DBSQLAdapter extends DBRelationalAdapter var repoType = repository.type; if (scheme == null) { - _log.severe( - 'No scheme for repository `${repository.name}` (`$repoType`) in this adapter> generateTables: $_generateTables @ $this', - ); - - return _DBTableCheck.error( - 'No scheme for repository `${repository.name}` (`$repoType`) in this adapter> generateTables: $_generateTables @ $this', - ); + var errorMsg = + 'No scheme for repository `${repository.name}` (`$repoType`) in this adapter> generateTables: $_generateTables @ $this'; + _log.severe(errorMsg); + return _DBTableCheck.error(errorMsg); } var schemeTableName = scheme.name; @@ -1389,108 +1398,16 @@ abstract class DBSQLAdapter extends DBRelationalAdapter if (capability.constraintSupport) { // REF CONSTRAINTS // - var fieldEntityTypes = entityHandler - .getFieldsEntityTypes() - .entries - .map((e) { - var entityType = e.value.entityType; - if (entityType == null) return null; - - var refRepository = repository.provider.getEntityRepositoryByType( - entityType, - ); - - if (refRepository == null || - !refRepository.isSameEntityManager(repository)) { - return null; - } - - return MapEntry(e.key, entityType); - }) - .nonNulls - .toMapFromEntries(); - - if (fieldEntityTypes.isNotEmpty) { - var fieldsReferencedTables = scheme.fieldsReferencedTables; - - var fieldsReferences = fieldsReferencedTables.entries - .map((e) { - var colum = e.key; - var field = schemeToRepoMap[colum] ?? colum; - - var entityType = fieldEntityTypes[field]; - if (entityType == null) return null; - - var refTable = e.value.targetTable; - return MapEntry(field, refTable); - }) - .nonNulls - .toMapFromEntries(); - - missingFieldReferenceConstraints = fieldEntityTypes.keys - .where((f) => !fieldsReferences.containsKey(f)) - .toSet(); - - if (!dialect.foreignKeyCreatesImplicitIndex) { - missingFieldReferenceIndexes = fieldsReferencedTables.entries - .where((e) => e.value.indexName == null) - .map((e) => e.key) - .toSet(); - } - } + (missingFieldReferenceConstraints, missingFieldReferenceIndexes) = + _findMissingReferenceConstraints(repository, scheme, schemeToRepoMap); // RELATIONSHIP CONSTRAINTS // - var fieldListEntityTypes = entityHandler - .getFieldsListEntityTypes() - .entries - .map((e) { - var entityType = e.value.entityType; - if (entityType == null) return null; - - var refRepository = repository.provider.getEntityRepositoryByType( - entityType, - ); - - if (refRepository == null || - !refRepository.isSameEntityManager(repository)) { - return null; - } - - return MapEntry(e.key, entityType); - }) - .nonNulls - .toMapFromEntries(); - - if (fieldListEntityTypes.isNotEmpty) { - if (!dialect.foreignKeyCreatesImplicitIndex) { - missingRelationshipFieldReferenceIndexes = collectionReferenceFields - .entries - .expand((e) { - var relFieldRef = e.value; - if (relFieldRef == null) { - return <(String, String, TypeInfo)>[]; - } - - return [ - if (relFieldRef.sourceRelationshipFieldIndex == null) - ( - relFieldRef.relationshipTable, - relFieldRef.sourceRelationshipField, - relFieldRef.sourceFieldEntityType, - ), - if (relFieldRef.targetRelationshipFieldIndex == null) - ( - relFieldRef.relationshipTable, - relFieldRef.targetRelationshipField, - relFieldRef.targetFieldEntityType, - ), - ]; - }) - .nonNulls - .toSet(); - } - } + missingRelationshipFieldReferenceIndexes = + _findMissingRelationshipIndexes( + repository, + collectionReferenceFields, + ); // UNIQUE CONSTRAINTS (unique indexes unknown) // @@ -1510,49 +1427,11 @@ abstract class DBSQLAdapter extends DBRelationalAdapter // ENUM CONSTRAINTS // - var enumConstraints = scheme.constraints - .whereType() - .toList(); - - var enumConstraintsFields = enumConstraints.toFields( - fieldMap: schemeToRepoMap, + (missingEnumConstraints, missingEnumValues) = _findMissingEnumConstraints( + entityHandler, + scheme, + schemeToRepoMap, ); - - var entityEnumFields = entityHandler.getFieldsEnumTypes().keys.toList(); - - missingEnumConstraints = entityEnumFields - .whereNotIn(enumConstraintsFields) - .toSet(); - - // A column's enum values are missing only if no `CHECK` over it has - // them all: with a duplicated `CHECK` (an old one never dropped), the - // current one has them, and the duplicate is warned - // (`findTableDuplicates`). - var columnsWithAllValues = {}; - var columnsMissingValues = >{}; - - for (var e in enumConstraints) { - var valuesNames = _columnEnumValues( - entityHandler, - e.field, - schemeToRepoMap, - ); - if (valuesNames == null) continue; - - var missingValues = valuesNames.whereNotIn(e.values).toList(); - - if (missingValues.isEmpty) { - columnsWithAllValues.add(e.field); - } else { - columnsMissingValues.putIfAbsent(e.field, () => missingValues); - } - } - - for (var e in columnsMissingValues.entries) { - if (!columnsWithAllValues.contains(e.key)) { - missingEnumValues[e.key] = e.value; - } - } } // The entity's indexes (`@EntityIndex`) without an index over their @@ -1579,51 +1458,17 @@ abstract class DBSQLAdapter extends DBRelationalAdapter (f) => missingColumns.contains(f) || missingReferenceColumns.contains(f), ); - // As in the `CREATE TABLE`, not one over the same columns as another - // missing one: a unique field's constraint (reported with the field), a - // unique `@EntityIndex` (also serving a non-unique one), or the same - // index twice. - var missingUniqueColumns = [ - for (var f in missingUniqueConstraints) [fieldColumn(f)], - ]; - var missingEntityIndexesKept = []; - for (var sql in [ - ...missingEntityIndexes.where((e) => e.unique), - ...missingEntityIndexes.where((e) => !e.unique), - ]) { - var columns = sql.columns; - if (missingUniqueColumns.any((c) => c.equals(columns))) continue; - if (missingEntityIndexesKept.any( - (e) => e.columns.equals(columns) && (e.unique || !sql.unique), - )) { - continue; - } - missingEntityIndexesKept.add(sql); - } - // In the declared order: - missingEntityIndexes = missingEntityIndexes - .where(missingEntityIndexesKept.contains) - .toList(); - - // A missing index whose name is in use by another index (other - // columns, or not unique): `CREATE INDEX IF NOT EXISTS` would do - // nothing; it must be dropped first. By index name, where it's in use - // (other tables: [findIndexesNamesInUse], in `_checkDBTablesImpl`). - var entityIndexesNameConflicts = { - for (var sql in missingEntityIndexes) - if (sql.indexName case var indexName?) - if (scheme.indexes?[indexName] case var columns?) - indexName: - 'over (${columns.join(', ')})' - '${sql.unique && !(scheme.uniqueIndexes?.contains(indexName) ?? false) ? ', not unique' : ''}', - }; + missingEntityIndexes = _dedupeMissingEntityIndexes( + missingEntityIndexes, + missingUniqueColumns: [ + for (var f in missingUniqueConstraints) [fieldColumn(f)], + ], + ); - if (entityIndexesNameConflicts.isNotEmpty) { - _log.severe( - "Table `$schemeTableName`: `@EntityIndex` names in use by other " - "indexes (drop them first): $entityIndexesNameConflicts", - ); - } + var entityIndexesNameConflicts = _findEntityIndexesNameConflicts( + scheme, + missingEntityIndexes, + ); if (missingColumns.isNotEmpty || missingReferenceColumns.isNotEmpty || @@ -1637,45 +1482,36 @@ abstract class DBSQLAdapter extends DBRelationalAdapter missingEntityIndexes.isNotEmpty) { _log.severe( "ERROR Checking table `$schemeTableName`> entityType: `$repoType`\n" - "${missingEntityIndexes.isNotEmpty ? '-- missingEntityIndexes: ${missingEntityIndexes.map((e) => e.indexName).toList()}\n' : ''}" - "${missingColumns.isNotEmpty ? '-- missingColumns: $missingColumns\n' : ''}" - "${missingReferenceColumns.isNotEmpty ? '-- missingReferenceColumns: $missingReferenceColumns\n' : ''}" - "${missingCollectionReferenceColumns.isNotEmpty ? '-- missingCollectionReferenceColumns: $missingCollectionReferenceColumns\n' : ''}" - "${missingFieldReferenceConstraints.isNotEmpty ? '-- missingFieldReferenceConstraints: $missingFieldReferenceConstraints\n' : ''}" - "${missingFieldReferenceIndexes.isNotEmpty ? '-- missingFieldReferenceIndexes: $missingFieldReferenceIndexes\n' : ''}" - "${missingRelationshipFieldReferenceIndexes.isNotEmpty ? '-- missingRelationshipFieldReferenceIndexes: $missingRelationshipFieldReferenceIndexes\n' : ''}" - "${missingUniqueConstraints.isNotEmpty ? '-- missingUniqueConstraints: $missingUniqueConstraints\n' : ''}" - "${missingEnumConstraints.isNotEmpty ? '-- missingEnumConstraints: $missingEnumConstraints\n' : ''}" - "${missingEnumValues.isNotEmpty ? '-- missingEnumValues: $missingEnumValues\n' : ''}", + "${_tableCheckErrorLine('missingEntityIndexes', missingEntityIndexes.map((e) => e.indexName).toList())}" + "${_tableCheckErrorLine('missingColumns', missingColumns)}" + "${_tableCheckErrorLine('missingReferenceColumns', missingReferenceColumns)}" + "${_tableCheckErrorLine('missingCollectionReferenceColumns', missingCollectionReferenceColumns)}" + "${_tableCheckErrorLine('missingFieldReferenceConstraints', missingFieldReferenceConstraints)}" + "${_tableCheckErrorLine('missingFieldReferenceIndexes', missingFieldReferenceIndexes)}" + "${_tableCheckErrorLine('missingRelationshipFieldReferenceIndexes', missingRelationshipFieldReferenceIndexes)}" + "${_tableCheckErrorLine('missingUniqueConstraints', missingUniqueConstraints)}" + "${_tableCheckErrorLine('missingEnumConstraints', missingEnumConstraints)}" + "${_tableCheckErrorLine('missingEnumValues', missingEnumValues)}", ); + // The columns of [fields], as reported by the [_DBTableCheck]: + List<_DBTableColumn> columnsOf(Iterable fields) => fields + .map((f) => _DBTableColumn.fromEntityHandler(entityHandler, f)) + .toList(); + return _DBTableCheck.missing( repository, scheme, - missingColumns - .map((f) => _DBTableColumn.fromEntityHandler(entityHandler, f)) - .toList(), - missingReferenceColumns - .map((f) => _DBTableColumn.fromEntityHandler(entityHandler, f)) - .toList(), - missingCollectionReferenceColumns - .map((f) => _DBTableColumn.fromEntityHandler(entityHandler, f)) - .toList(), - missingFieldReferenceConstraints - .map((f) => _DBTableColumn.fromEntityHandler(entityHandler, f)) - .toList(), - missingFieldReferenceIndexes - .map((f) => _DBTableColumn.fromEntityHandler(entityHandler, f)) - .toList(), + columnsOf(missingColumns), + columnsOf(missingReferenceColumns), + columnsOf(missingCollectionReferenceColumns), + columnsOf(missingFieldReferenceConstraints), + columnsOf(missingFieldReferenceIndexes), missingRelationshipFieldReferenceIndexes .map((f) => _DBRelationshipTableColumn(f.$1, f.$2, f.$3, [])) .toList(), - missingUniqueConstraints - .map((f) => _DBTableColumn.fromEntityHandler(entityHandler, f)) - .toList(), - missingEnumConstraints - .map((f) => _DBTableColumn.fromEntityHandler(entityHandler, f)) - .toList(), + columnsOf(missingUniqueConstraints), + columnsOf(missingEnumConstraints), missingEnumValues.entries .map( (e) => MapEntry( @@ -1694,6 +1530,252 @@ abstract class DBSQLAdapter extends DBRelationalAdapter return _DBTableCheck.ok(); } + /// A line of the table check's error log (see [_checkDBTableScheme]): + /// `--
` of the selected entities ([list]) of + /// [entityRepository], with links to the related entities, and to edit, + /// delete and insert. Used by [select]. + List _buildSelectTableHTML( + EntityRepository entityRepository, + List entityRepositoryProviders, + List list, + ) { + var content = []; + + var entityType = entityRepository.type; var entityHandler = entityRepository.entityHandler; @@ -534,10 +628,28 @@ class APIDBModule extends APIModule { content.add('
'); + return content; + } + + /// The HTML of the pagination of a select of [repoName] (when it has a + /// [limit]): the range of the selected entities ([list]) and the links to + /// the previous and next pages; and the link to this page as JSON. The + /// links keep the select's [query] and directives. Used by [select]. + List _buildPaginationHTML( + String repoName, + List list, { + required String query, + required bool eager, + required int? limit, + required int? offset, + required OrderDirection? orderDirection, + }) { + var content = []; + // The query `String` of a page (`OFFSET`) of this select: String pageQuery(int? pageOffset) => [ if (query.isNotEmpty) Uri.encodeQueryComponent(query), - if (eager!) 'EAGER=true', + if (eager) 'EAGER=true', if (orderDirection != null) 'ORDER=${orderDirection.name}', 'LIMIT=${limit ?? 0}', if (pageOffset != null && pageOffset > 0) 'OFFSET=$pageOffset', @@ -568,11 +680,7 @@ class APIDBModule extends APIModule { '
', ); - htmlDoc.content = content; - - var html = htmlDoc.build(); - - return APIResponse.ok(html, mimeType: 'html'); + return content; } static const _fieldsNamesOrder = [ From 0f5c2fe4f331235f46df641438a02a5146e2eccc Mon Sep 17 00:00:00 2001 From: "Graciliano M. P." Date: Sun, 8 Nov 2026 05:22:11 -0300 Subject: [PATCH 6/9] Fix: `\'` in a single-quoted condition string `characterEscapeValue2` used `characterEscape`, whose pattern excludes `'`, so `Condition.parse("name == 'a\\'b'")` failed (`"\'" expected`); the unused `jsonEscapeCharsString2` was meant for it. Now `characterEscape2`. Test in bones_api_condition_test.dart. Co-Authored-By: Claude Opus 5.5 --- lib/src/bones_api_condition_parser.dart | 9 ++++++++- test/bones_api_condition_test.dart | 9 +++++++++ 2 files changed, 17 insertions(+), 1 deletion(-) diff --git a/lib/src/bones_api_condition_parser.dart b/lib/src/bones_api_condition_parser.dart index 27be55ff..2e33f91b 100644 --- a/lib/src/bones_api_condition_parser.dart +++ b/lib/src/bones_api_condition_parser.dart @@ -96,11 +96,18 @@ abstract class JsonGrammarLexer extends GrammarDefinition { Parser characterEscape() => char('\\') & pattern(jsonEscapeCharsString); + /// The escapes of a single-quoted string: also `\'` + /// ([jsonEscapeCharsString2]). + Parser characterEscape2() => + char('\\') & pattern(jsonEscapeCharsString2); + Parser characterEscapeValue() => characterEscape().map((each) => jsonEscapeChars[each[1]]!); + // With [characterEscape2]: [characterEscape] doesn't accept `\'`, so a + // single-quoted string with an escaped quote (`'a\'b'`) didn't parse. Parser characterEscapeValue2() => - characterEscape().map((each) => jsonEscapeChars2[each[1]]!); + characterEscape2().map((each) => jsonEscapeChars2[each[1]]!); Parser characterUnicode() => string('\\u') & pattern('0-9A-Fa-f').times(4); diff --git a/test/bones_api_condition_test.dart b/test/bones_api_condition_test.dart index 31dce907..06a29e01 100644 --- a/test/bones_api_condition_test.dart +++ b/test/bones_api_condition_test.dart @@ -65,6 +65,15 @@ void main() { group('ConditionParser', () { setUp(() {}); + test(r"escaped quote in a single-quoted string (\')", () { + var c = Condition.parse(r"name == 'a\'b'") as KeyConditionEQ; + expect(c.value, equals("a'b")); + + // The other escapes, as in a double-quoted string: + var c2 = Condition.parse(r'''name == 'a\"b\\c\nd' ''') as KeyConditionEQ; + expect(c2.value, equals('a"b\\c\nd')); + }); + test('key op value', () async { var conditionParser = ConditionParser(); From 4d78ba18ee6fba40eef10705e7c9fac1809a23f1 Mon Sep 17 00:00:00 2001 From: "Graciliano M. P." Date: Sun, 8 Nov 2026 05:22:42 -0300 Subject: [PATCH 7/9] Fix: SQLDialect.toString lists all its fields It lacked a space after `name: $name,` and omitted `acceptsVarcharWithoutMaximumSize`, `intParameterTypeSuffix`, `maxIDsAsParameters`, `regExpSyntax` and `subqueryAsDerivedTable`. Tests in bones_api_cov_sql_builder_test.dart. Co-Authored-By: Claude Opus 5.5 --- lib/src/bones_api_sql_builder.dart | 9 ++++++-- test/bones_api_cov_sql_builder_test.dart | 29 ++++++++++++++++++++++-- 2 files changed, 34 insertions(+), 4 deletions(-) diff --git a/lib/src/bones_api_sql_builder.dart b/lib/src/bones_api_sql_builder.dart index 6f8c517a..bd9eb5d2 100644 --- a/lib/src/bones_api_sql_builder.dart +++ b/lib/src/bones_api_sql_builder.dart @@ -258,7 +258,7 @@ class SQLDialect extends DBDialect { @override String toString() { return 'SQLDialect{' - 'name: $name,' + 'name: $name, ' 'elementQuote: $elementQuote, ' 'acceptsOutputSyntax: $acceptsOutputSyntax, ' 'acceptsReturningSyntax: $acceptsReturningSyntax, ' @@ -267,6 +267,7 @@ class SQLDialect extends DBDialect { 'acceptsInsertDefaultValues: $acceptsInsertDefaultValues, ' 'acceptsInsertIgnore: $acceptsInsertIgnore, ' 'acceptsInsertOnConflict: $acceptsInsertOnConflict, ' + 'acceptsVarcharWithoutMaximumSize: $acceptsVarcharWithoutMaximumSize, ' 'foreignKeyCreatesImplicitIndex: $foreignKeyCreatesImplicitIndex, ' 'createIndexIfNotExists: $createIndexIfNotExists, ' 'alterTableAddConstraint: $alterTableAddConstraint, ' @@ -274,7 +275,11 @@ class SQLDialect extends DBDialect { 'dropIndexOnTable: $dropIndexOnTable, ' 'offsetRequiresLimit: $offsetRequiresLimit, ' 'offsetMaxLimitValue: $offsetMaxLimitValue, ' - 'maxIdentifierLength: $maxIdentifierLength' + 'maxIdentifierLength: $maxIdentifierLength, ' + 'intParameterTypeSuffix: $intParameterTypeSuffix, ' + 'maxIDsAsParameters: $maxIDsAsParameters, ' + 'regExpSyntax: ${regExpSyntax.name}, ' + 'subqueryAsDerivedTable: $subqueryAsDerivedTable' '}'; } } diff --git a/test/bones_api_cov_sql_builder_test.dart b/test/bones_api_cov_sql_builder_test.dart index da2dccb6..1e780ee4 100644 --- a/test/bones_api_cov_sql_builder_test.dart +++ b/test/bones_api_cov_sql_builder_test.dart @@ -240,8 +240,33 @@ void main() { expect(d1, equals(d2)); expect(d1.hashCode, equals(d2.hashCode)); expect(d1, isNot(equals(d3))); - expect(d1.toString(), startsWith('SQLDialect{name: X,elementQuote: ", ')); - expect(d1.toString(), endsWith('maxIdentifierLength: null}')); + expect( + d1.toString(), + startsWith('SQLDialect{name: X, elementQuote: ", '), + ); + expect(d1.toString(), endsWith('subqueryAsDerivedTable: false}')); + }); + + test('SQLDialect: toString with all the fields', () { + const d = SQLDialect( + 'Z', + elementQuote: '`', + acceptsVarcharWithoutMaximumSize: true, + maxIdentifierLength: 64, + intParameterTypeSuffix: ':int8', + maxIDsAsParameters: 0, + regExpSyntax: SQLRegExpSyntax.dart, + subqueryAsDerivedTable: true, + ); + + var s = d.toString(); + expect(s, contains('name: Z, elementQuote: `, ')); + expect(s, contains('acceptsVarcharWithoutMaximumSize: true, ')); + expect(s, contains('maxIdentifierLength: 64, ')); + expect(s, contains('intParameterTypeSuffix: :int8, ')); + expect(s, contains('maxIDsAsParameters: 0, ')); + expect(s, contains('regExpSyntax: dart, ')); + expect(s, endsWith('subqueryAsDerivedTable: true}')); }); test('CreateTableSQL: constraints as ALTER TABLE', () { From 45bc448a50d58ca5eafd40cc6450cb519dc8d362 Mon Sep 17 00:00:00 2001 From: "Graciliano M. P." Date: Sun, 8 Nov 2026 05:23:53 -0300 Subject: [PATCH 8/9] Fix: APIDBModule.select escapes the entities values in its HTML The values (and IDs in links) were written into the HTML as is: a value with `<` or `&` broke the page and could inject markup or scripts. Now escaped with `HtmlEscape` (element text; attribute for the links). Test in bones_api_cov_db_module_test.dart. Co-Authored-By: Claude Opus 5.5 --- lib/src/bones_api_db_module.dart | 37 ++++++++++++++++++++------ test/bones_api_cov_db_module_test.dart | 30 +++++++++++++++++++++ 2 files changed, 59 insertions(+), 8 deletions(-) diff --git a/lib/src/bones_api_db_module.dart b/lib/src/bones_api_db_module.dart index 3d1f3393..dda0f8ec 100644 --- a/lib/src/bones_api_db_module.dart +++ b/lib/src/bones_api_db_module.dart @@ -1,3 +1,4 @@ +import 'dart:convert' show HtmlEscape, HtmlEscapeMode; import 'dart:typed_data'; import 'package:archive/archive.dart'; @@ -591,29 +592,36 @@ class APIDBModule extends APIModule { content.add(''); + // A related entity's ID (also a `String` one) is escaped as any + // value, in the link and its text: + String idLink(Object? id) => + '' + '${_escapeHTML(id)}'; + if (v2 is List) { - var ids = v2 - .map((e) => '$e') - .join(' , '); - content.add(ids); + content.add(v2.map(idLink).join(' , ')); } else { - content.add('$v2'); + content.add(idLink(v2)); } content.add(''); } else { - content.add('$v2'); + content.add('${_escapeHTML(v2)}'); } } var id = entityHandler.getID(o); if (id != null) { + var idAttr = _escapeHTMLAttribute(id); + content.add('   [ '); - content.add('edit'); + content.add('edit'); - content.add('  |  del'); + content.add( + '  |  del', + ); content.add(' ]  '); } @@ -631,6 +639,19 @@ class APIDBModule extends APIModule { return content; } + /// [value] (its `toString`) escaped as HTML text (`&`, `<`, `>`): an + /// entity's value (e.g. a name with `<`) would otherwise be read as HTML + /// (and could inject markup or scripts in the page). Used by + /// [_buildSelectTableHTML]. + static String _escapeHTML(Object? value) => + const HtmlEscape(HtmlEscapeMode.element).convert('$value'); + + /// [value] (its `toString`) escaped for an HTML attribute value between + /// `"` (as [_escapeHTML], also `"`): an entity's ID in a link. Used by + /// [_buildSelectTableHTML]. + static String _escapeHTMLAttribute(Object? value) => + const HtmlEscape(HtmlEscapeMode.attribute).convert('$value'); + /// The HTML of the pagination of a select of [repoName] (when it has a /// [limit]): the range of the selected entities ([list]) and the links to /// the previous and next pages; and the link to this page as JSON. The diff --git a/test/bones_api_cov_db_module_test.dart b/test/bones_api_cov_db_module_test.dart index daf7b93d..d97415e1 100644 --- a/test/bones_api_cov_db_module_test.dart +++ b/test/bones_api_cov_db_module_test.dart @@ -247,6 +247,36 @@ void main() { expect({...stores, ...closedStores}, equals({1, 2, 3})); }); + test('select (HTML) escapes the entities values', () async { + var repository = provider.getEntityRepository()!; + + var info = UserInfo(' & bold'); + var id = await repository.store(info); + + try { + var tables = (await get('/db/tables/json')).payload as Map; + var table = tables['UserInfo'] as String; + + var response = await get('/db/select/$table'); + expect(response.isOK, isTrue); + + var html = response.payload as String; + expect(html, isNot(contains('