diff --git a/CHANGELOG.md b/CHANGELOG.md index b9a562f9..7502da9c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,31 @@ +## 1.35.0 + +Conditions and SQL generation clean-up (behavior-preserving, the same SQL): + +- `Condition`: the ordering comparisons (`>`, `>=`, `<`, `<=`) written once + (a private enum and a private base of the `KeyCondition{GreaterThan,...}` + classes; public API unchanged); `KeyCondition.encodeValue` in the base + class; `ConditionParameter.matchesIn` resolves its parameters once. +- `EncodingContext.parameterValue`; `isReservedWord` by a set; + `ConditionSQLEncoder.qualifiedColumnSQL` and shared ID/empty-set helpers. +- `SQLDialect.qualifiedColumnSQL`; `SQLGenerator.uniqueConstraintName`, + `indexName`, `foreignKeyName` and `relationshipTableName` (the names of + the generated indexes, constraints and relationship tables, in one place). +- `DBSQLAdapter`: the table check (`_checkDBTableScheme`), the relationship + SQL generators and the `JOIN`s split into documented helpers. +- `DBSQLMemoryAdapter`: one select matcher; shared delete helpers. +- `APIDBModule.select`: directives, table and pagination helpers. +- Cache fields named `*Cache` and documented. + +Fixes: + +- `Condition.parse`: an escaped quote in a single-quoted string + (`name == 'a\'b'`) failed to parse. +- `SQLDialect.toString`: lists all its fields (and a missing space). +- `APIDBModule.select`: the entities' values are HTML-escaped in its page + (they were written as is: a `<` or `&` broke the page, and could inject + markup). + ## 1.34.0 `null` and `[]` mean the same in a condition: an empty set for `=~`/`!~`, a diff --git a/lib/src/bones_api_base.dart b/lib/src/bones_api_base.dart index 92c6ec26..db14dbd8 100644 --- a/lib/src/bones_api_base.dart +++ b/lib/src/bones_api_base.dart @@ -52,7 +52,7 @@ typedef APILogger = void Function( /// Bones API Library class. class BonesAPI { // ignore: constant_identifier_names - static const String VERSION = '1.34.0'; + static const String VERSION = '1.35.0'; static bool _boot = false; 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_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/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)); }); } diff --git a/lib/src/bones_api_db_module.dart b/lib/src/bones_api_db_module.dart index b72c66cd..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'; @@ -345,43 +346,21 @@ class APIDBModule extends APIModule { return APIResponse.error(error: "Can't find table: $table"); } - var query = Uri.decodeQueryComponent(requestedUri.query); - - // See [selectQueryDirectives]. The arguments passed to this method take - // precedence over the query `String` directives. - { - var extracted = _extractQueryDirective(query, 'EAGER'); - query = extracted.query; - if (extracted.value == 'true') eager = true; - } - - { - var extracted = _extractQueryDirective(query, 'LIMIT'); - query = extracted.query; - limit ??= int.tryParse(extracted.value?.trim() ?? ''); - - // A page of `defaultSelectLimit` by default (`LIMIT=0`: no limit). - limit ??= defaultSelectLimit; - if (limit <= 0) limit = null; - } - - { - var extracted = _extractQueryDirective(query, 'OFFSET'); - query = extracted.query; - offset ??= int.tryParse(extracted.value?.trim() ?? ''); - } - - { - var extracted = _extractQueryDirective(query, 'PAGE'); - query = extracted.query; - page ??= int.tryParse(extracted.value?.trim() ?? ''); - } + var directives = _parseSelectDirectives( + Uri.decodeQueryComponent(requestedUri.query), + eager: eager, + limit: limit, + offset: offset, + page: page, + orderDirection: orderDirection, + ); - { - var extracted = _extractQueryDirective(query, 'ORDER'); - query = extracted.query; - orderDirection ??= OrderDirection.parse(extracted.value); - } + var query = directives.query; + eager = directives.eager; + limit = directives.limit; + offset = directives.offset; + page = directives.page; + orderDirection = directives.orderDirection; // Resolved here (and not by the repository) so an invalid `PAGE` becomes an // error response instead of an uncaught `ArgumentError`: @@ -453,7 +432,123 @@ class APIDBModule extends APIModule { footer: _buildFooter(), ); - var content = []; + var repoName = entityRepository.name; + + var content = [ + ..._buildSelectTableHTML( + entityRepository, + entityRepositoryProviders, + list, + ), + ..._buildPaginationHTML( + repoName, + list, + query: query, + eager: eager, + limit: limit, + offset: offset, + orderDirection: orderDirection, + ), + ]; + + htmlDoc.content = content; + + var html = htmlDoc.build(); + + return APIResponse.ok(html, mimeType: 'html'); + } + + /// Parses the directives of a select's [query] `String` (see + /// [selectQueryDirectives]), returning the [query] without them. The + /// arguments given (of [select]) take precedence over the directives. + /// + /// Without an explicit `LIMIT`, a page of [defaultSelectLimit] (`LIMIT=0`: + /// no limit, `null`). Used by [select]. + ({ + String query, + bool? eager, + int? limit, + int? offset, + int? page, + OrderDirection? orderDirection, + }) + _parseSelectDirectives( + String query, { + bool? eager, + int? limit, + int? offset, + int? page, + OrderDirection? orderDirection, + }) { + { + var extracted = _extractQueryDirective(query, 'EAGER'); + query = extracted.query; + if (extracted.value == 'true') eager = true; + } + + { + var extracted = _extractIntDirective(query, 'LIMIT'); + query = extracted.query; + limit ??= extracted.value; + + // A page of `defaultSelectLimit` by default (`LIMIT=0`: no limit). + limit ??= defaultSelectLimit; + if (limit <= 0) limit = null; + } + + { + var extracted = _extractIntDirective(query, 'OFFSET'); + query = extracted.query; + offset ??= extracted.value; + } + + { + var extracted = _extractIntDirective(query, 'PAGE'); + query = extracted.query; + page ??= extracted.value; + } + + { + var extracted = _extractQueryDirective(query, 'ORDER'); + query = extracted.query; + orderDirection ??= OrderDirection.parse(extracted.value); + } + + return ( + query: query, + eager: eager, + limit: limit, + offset: offset, + page: page, + orderDirection: orderDirection, + ); + } + + /// As [_extractQueryDirective], with the value parsed as an `int` (`null` + /// if absent or not an `int`). Used for the `LIMIT`, `OFFSET` and `PAGE` + /// directives by [_parseSelectDirectives]. + static ({String query, int? value}) _extractIntDirective( + String query, + String key, + ) { + var extracted = _extractQueryDirective(query, key); + return ( + query: extracted.query, + value: int.tryParse(extracted.value?.trim() ?? ''), + ); + } + + /// The HTML `` 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; @@ -497,29 +592,36 @@ class APIDBModule extends APIModule { content.add(''); } else { - content.add(''); + content.add(''); } } var id = entityHandler.getID(o); if (id != null) { + var idAttr = _escapeHTMLAttribute(id); + content.add(''); } @@ -534,10 +636,41 @@ 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('$v2${_escapeHTML(v2)}   [ '); - content.add('edit'); + content.add('edit'); - content.add('  |  del'); + content.add( + '  |  del', + ); content.add(' ]  
'); + 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 + /// 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 +701,7 @@ class APIDBModule extends APIModule { '
', ); - htmlDoc.content = content; - - var html = htmlDoc.build(); - - return APIResponse.ok(html, mimeType: 'html'); + return content; } static const _fieldsNamesOrder = [ diff --git a/lib/src/bones_api_entity_db_memory.dart b/lib/src/bones_api_entity_db_memory.dart index 22f9cd06..82dcb859 100644 --- a/lib/src/bones_api_entity_db_memory.dart +++ b/lib/src/bones_api_entity_db_memory.dart @@ -238,14 +238,20 @@ class DBSQLMemoryAdapter extends DBSQLAdapter >>{}; void _onTablesModification() { - _tablesVersions = null; - _tablesIndexesVersions = null; + _tablesVersionsCache = null; + _tablesIndexesVersionsCache = null; } - Map? _tablesVersions; + /// A cache of [tablesVersions], filled on its first call and reset by + /// [_onTablesModification]. + /// + /// Why: each new connection ([DBSQLMemoryAdapterContext]) snapshots the + /// versions (to roll the tables back to them), usually more often than + /// the tables change: the map isn't rebuilt for each one. + Map? _tablesVersionsCache; Map get tablesVersions => - _tablesVersions ??= UnmodifiableMapView( + _tablesVersionsCache ??= UnmodifiableMapView( _tables.map((table, map) => MapEntry(table, map.version)), ); @@ -609,10 +615,12 @@ class DBSQLMemoryAdapter extends DBSQLAdapter final _tablesIndexes = >>>{}; - Map>? _tablesIndexesVersions; + /// A cache of [tablesIndexesVersions], filled on its first call and reset + /// by [_onTablesModification]. As [_tablesVersionsCache]. + Map>? _tablesIndexesVersionsCache; Map> get tablesIndexesVersions => - _tablesIndexesVersions ??= UnmodifiableMapView( + _tablesIndexesVersionsCache ??= UnmodifiableMapView( _tablesIndexes.map( (table, fieldIndex) => MapEntry( table, @@ -1046,26 +1054,28 @@ class DBSQLMemoryAdapter extends DBSQLAdapter // Resolved by ID or by an index. } else if (condition == null) { itr = map.values; - } else if (tableScheme == null || - (tableScheme.fieldsReferencedTablesLength == 0 && - tableScheme.tableRelationshipReferenceLength == 0) || - condition.isIDCondition) { - itr = map.values.where((e) { - return condition.matchesEntityMap( - e, - positionalParameters: sql.positionalParameters, - namedParameters: sql.namedParameters ?? sql.parametersByPlaceholder, - entityHandler: entityHandler, - ); - }); } else { + // The table's scheme to resolve each row's references with before + // matching it (`null`: matched as stored): not needed without + // references, nor by an ID condition (the row's own ID). + var resolveReferencesScheme = + _hasNoReferences(tableScheme) || condition.isIDCondition + ? null + : tableScheme; + + // A select prefers the SQL's `namedParameters` (a delete only uses the + // `parametersByPlaceholder`: see `doDeleteSQL`). + var namedParameters = sql.namedParameters ?? sql.parametersByPlaceholder; + itr = map.values.where((obj) { - obj = _resolveEntityMap(obj, entityHandler, tableScheme); + if (resolveReferencesScheme != null) { + obj = _resolveEntityMap(obj, entityHandler, resolveReferencesScheme); + } return condition.matchesEntityMap( obj, positionalParameters: sql.positionalParameters, - namedParameters: sql.namedParameters ?? sql.parametersByPlaceholder, + namedParameters: namedParameters, entityHandler: entityHandler, ); }); @@ -1136,10 +1146,7 @@ class DBSQLMemoryAdapter extends DBSQLAdapter // As a select: also a to-many relationship (a table without to-one // references) needs its references resolved to be matched. - final noReferences = - tableScheme == null || - (tableScheme.fieldsReferencedTablesLength == 0 && - tableScheme.tableRelationshipReferenceLength == 0); + final noReferences = _hasNoReferences(tableScheme); // A delete by ID needs neither a scan nor resolving every row (below): // only the deleted row. A miss falls back to the scan, as in a select. @@ -1150,13 +1157,11 @@ class DBSQLMemoryAdapter extends DBSQLAdapter ? byID : MapEntry( byID.key, - _resolveEntityMap(byID.value, entityHandler, tableScheme), + _resolveEntityMap(byID.value, entityHandler, tableScheme!), ), ]; - _checkNotReferencedEntities(entries, table, sql); - - return _removeEntries(table, entries, map); + return _deleteMatchedEntries(table, entries, map, sql); } // A relationship delete (e.g. the roles a user no longer has) only needs @@ -1172,6 +1177,10 @@ class DBSQLMemoryAdapter extends DBSQLAdapter if (byIndex != null) candidates = byIndex; } + // Unlike a select (`sql.namedParameters ?? sql.parametersByPlaceholder`, + // see `_selectEntries`), a delete matches with the + // `parametersByPlaceholder` only: intentionally not unified (it's the + // established behavior of each). if (noReferences) { var entries = candidates.where((e) { return sql.condition!.matchesEntityMap( @@ -1182,14 +1191,12 @@ class DBSQLMemoryAdapter extends DBSQLAdapter ); }).toList(); - _checkNotReferencedEntities(entries, table, sql); - - return _removeEntries(table, entries, map); + return _deleteMatchedEntries(table, entries, map, sql); } var entries = candidates .map((e) { - var obj = _resolveEntityMap(e.value, entityHandler, tableScheme); + var obj = _resolveEntityMap(e.value, entityHandler, tableScheme!); var match = sql.condition!.matchesEntityMap( obj, @@ -1203,9 +1210,30 @@ class DBSQLMemoryAdapter extends DBSQLAdapter .nonNulls .toList(growable: false); - _checkNotReferencedEntities(entries, table, sql); + return _deleteMatchedEntries(table, entries, map, sql); + } + + /// If [tableScheme] has no references (to-one fields referencing other + /// tables, or relationship tables), or is unknown: its rows are matched as + /// stored, without resolving their references ([_resolveEntityMap]). Used + /// by [_selectEntries] and [doDeleteSQL]. + static bool _hasNoReferences(TableScheme? tableScheme) => + tableScheme == null || + (tableScheme.fieldsReferencedTablesLength == 0 && + tableScheme.tableRelationshipReferenceLength == 0); - return _removeEntries(table, entries, map); + /// Deletes the matched [entries] of [table] (its [tableMap]), after + /// checking that no other table references them (see + /// [_checkNotReferencedEntities]). Returns the deleted rows. Used by the + /// branches of [doDeleteSQL]. + List> _deleteMatchedEntries( + String table, + List>> entries, + Map> tableMap, + SQL sql, + ) { + _checkNotReferencedEntities(entries, table, sql); + return _removeEntries(table, entries, tableMap); } void _checkNotReferencedEntities( @@ -1660,7 +1688,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..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]): + /// `--