keyFieldToSQL method

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

Implementation

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

  var tableName = context.tableNameOrEntityName;
  var tableAlias = context.resolveEntityAlias(tableName);

  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 q = sqlElementQuote;

    var fieldName = key0.name;
    var tableFieldName = tableScheme.resolveTableFieldName(fieldName);
    var tableFieldType = tableFieldName != null
        ? tableScheme.fieldsTypes[tableFieldName]
        : null;

    if (tableFieldType != null) {
      return MapEntry(tableFieldType, '$q$tableAlias$q.$q$tableFieldName$q');
    }

    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 relationshipAlias =
            context.resolveEntityAlias(relationship.relationshipTable);

        String relationshipTargetField;
        Type relationshipTargetFieldType;
        if (relationship.sourceTable == tableName) {
          relationshipTargetField = relationship.targetRelationshipField;
          relationshipTargetFieldType = relationship.targetFieldType;
        } else {
          relationshipTargetField = relationship.sourceRelationshipField;
          relationshipTargetFieldType = relationship.sourceFieldType;
        }

        return MapEntry(relationshipTargetFieldType,
            '$q$relationshipAlias$q.$q$relationshipTargetField$q');
      });
    });
  });
}