keyFieldReferenceToSQL method

FutureOr<MapEntry<Type, String>> keyFieldReferenceToSQL(KeyCondition c, EncodingContext context)

Implementation

FutureOr<MapEntry<Type, String>> keyFieldReferenceToSQL(
  KeyCondition<dynamic, dynamic> c,
  EncodingContext context,
) {
  var schemeProvider = this.schemeProvider;
  var tableName = context.tableNameOrEntityName;

  if (schemeProvider == null) {
    throw ConditionEncodingError(
        'No SchemeProvider> tableName: $tableName > $this');
  }

  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 fieldName = key0.name;
    var fieldRef = tableScheme.getFieldReferencedTable(fieldName);

    if (fieldRef != null) {
      context.addFieldReference(fieldRef, c);

      var entityAlias = context.resolveEntityAlias(fieldRef.targetTable);

      var key1 = keys[1];

      if (key1 is ConditionKeyField) {
        var targetTableSchemeRet =
            schemeProvider.getTableScheme(fieldRef.targetTable);

        return targetTableSchemeRet.resolveMapped((targetTableScheme) {
          if (targetTableScheme == null) {
            var errorMsg =
                "Can't find `TableScheme` for target table: $fieldRef";
            _log.severe(errorMsg);
            throw StateError(errorMsg);
          }

          var q = sqlElementQuote;
          var targetFieldName =
              targetTableScheme.resolveTableFieldName(key1.name);
          var targetFieldType =
              targetTableScheme.fieldsTypes[targetFieldName]!;
          return MapEntry(
              targetFieldType, '$q$entityAlias$q.$q$targetFieldName$q');
        });
      } else {
        throw ConditionEncodingError('Key: $c');
      }
    }

    var retFieldType = schemeProvider.getFieldType(fieldName,
        entityName: context.entityName, tableName: context.tableName);

    return retFieldType.resolveMapped((refFieldType) {
      if (refFieldType == null) {
        throw ConditionEncodingError(
            'No field type for key[0]> keys: $key0 $keys ; entityName: ${context.entityName} ; tableName: ${context.tableName} > $this ; tableScheme: $tableScheme');
      }

      var retTableNameRef = schemeProvider.getTableForType(refFieldType);

      return retTableNameRef.resolveMapped((tableNameRef) {
        if (tableNameRef == null) {
          throw ConditionEncodingError(
              'No referenced table or relationship table for key[0]> keys: $key0 $keys ; tableName: $tableName ; fieldType: $refFieldType> $this ; tableScheme: $tableScheme');
        }

        var relationship = tableScheme.getTableRelationshipReference(
            sourceTable: tableName,
            sourceField: fieldName,
            targetTable: tableNameRef);

        if (relationship == null) {
          throw ConditionEncodingError(
              'No relationship table with target table $tableNameRef> keys: $key0 $keys ; tableName: $tableName ; fieldType: $refFieldType> $this ; tableScheme: $tableScheme');
        }

        context.addRelationshipTable(tableNameRef, relationship, c);

        var targetAlias =
            context.resolveEntityAlias(relationship.targetTable);

        var key1 = keys[1];

        if (key1 is ConditionKeyField) {
          var targetTableSchemeRet =
              schemeProvider.getTableScheme(relationship.targetTable);

          return targetTableSchemeRet.resolveMapped((targetTableScheme) {
            if (targetTableScheme == null) {
              var errorMsg =
                  "Can't find `TableScheme` for target table: $fieldRef";
              _log.severe(errorMsg);
              throw StateError(errorMsg);
            }

            var q = sqlElementQuote;
            var targetFieldName =
                targetTableScheme.resolveTableFieldName(key1.name);

            if (targetFieldName == null) {
              var errorMsg =
                  "Can't find field `${key1.name}` for target `${targetTableScheme.name}`. relationship: $relationship";
              _log.severe(errorMsg);
              throw StateError(errorMsg);
            }

            var targetFieldType =
                targetTableScheme.fieldsTypes[targetFieldName]!;
            return MapEntry(
                targetFieldType, '$q$targetAlias$q.$q$targetFieldName$q');
          });
        } else {
          throw ConditionEncodingError('Key: $c');
        }
      });
    });
  });
}