generateCreateTableSQL method

CreateTableSQL generateCreateTableSQL({ EntityRepository<Object>? entityRepository, Object? obj, Type? type, String? name, String? tableName, bool ifNotExists = true, bool sortColumns = true, })

Implementation

CreateTableSQL generateCreateTableSQL({
  EntityRepository? entityRepository,
  Object? obj,
  Type? type,
  String? name,
  String? tableName,
  bool ifNotExists = true,
  bool sortColumns = true,
}) {
  entityRepository ??= getEntityRepository(
    type: type,
    obj: obj,
    name: name,
    tableName: name,
  );
  if (entityRepository == null) {
    throw ArgumentError(
      "Can't resolve `EntityRepository`> obj: $obj ; type: $type ; name: $name ; tableName: $tableName",
    );
  }

  var q = dialect.elementQuote;

  var entityType = entityRepository.type;
  var entityHandler = entityRepository.entityHandler;

  var table = getTableForEntityRepository(entityRepository);

  var idFieldName = entityHandler.idFieldName();
  var idType = entityHandler.idType();

  var idColumnName = normalizeColumnName(idFieldName);
  var idAnnotations =
      entityHandler
          .getFieldEntityAnnotations(null, idFieldName)
          ?.whereType<EntityField>()
          .toList();

  var idTypeSQL = primaryKeyTypeToSQLType(
    idType,
    entityFieldAnnotations: idAnnotations,
  );

  var sqlEntries = <SQLEntry>[
    SQLEntry(
      'COLUMN',
      ' $q$idColumnName$q $idTypeSQL',
      comment: '$idType $idFieldName',
      columns: [SQLColumn(table, idColumnName)],
    ),
  ];

  var indexSQLs = <CreateIndexSQL>[];

  var fieldsEntries =
      entityHandler
          .fieldsTypes()
          .entries
          .where((e) => !e.value.isListEntityOrReference)
          .toList();

  if (sortColumns) {
    fieldsEntries.sort((a, b) => a.key.compareTo(b.key));
  }

  var referenceFields =
      <String, MapEntry<String, MapEntry<String, String>>>{};

  for (var e in fieldsEntries) {
    var fieldName = e.key;
    var fieldType = e.value;
    if (fieldName == idFieldName) continue;

    var entityFieldAnnotations =
        entityHandler
            .getFieldEntityAnnotations(null, fieldName)
            ?.whereType<EntityField>()
            .toList();

    if (entityFieldAnnotations != null && entityFieldAnnotations.hasHidden) {
      continue;
    }

    var columnName = normalizeColumnName(fieldName);
    var comment = '${fieldType.toString(withT: false)} $fieldName';

    String? refTable;
    String? refColumn;

    var fieldSQLType = typeToSQLType(
      fieldType,
      columnName,
      entityFieldAnnotations: entityFieldAnnotations,
    );

    if (fieldSQLType == null) {
      var entityType = entityTypeToSQLType(
        fieldType,
        columnName,
        entityFieldAnnotations: entityFieldAnnotations,
      );
      if (entityType != null) {
        var fieldEntityType = fieldType.entityType;
        if (fieldEntityType != null &&
            isSiblingEntityType(entityRepository, fieldEntityType)) {
          referenceFields[columnName] = entityType;
        }

        fieldSQLType = entityType.value.value;

        refTable = entityType.key;
        refColumn = entityType.value.key;

        comment += ' @ $refTable.$refColumn';
      }
    }

    if (fieldSQLType == null) {
      var enumType = enumTypeToSQLType(
        fieldType.type,
        columnName,
        entityFieldAnnotations: entityFieldAnnotations,
      );
      if (enumType != null) {
        var type = enumType.key;
        var values = enumType.value;

        fieldSQLType = _buildEnumSQLType(
          type,
          fieldSQLType,
          values,
          q,
          columnName,
        );

        comment += ' enum(${values.join(', ')})';
      }
    }

    if (fieldSQLType == null) {
      _log.warning("Can't define field SQL type: `$table`.`$fieldName`");
      continue;
    }

    sqlEntries.add(
      SQLEntry(
        'COLUMN',
        ' $q$columnName$q $fieldSQLType',
        comment: comment,
        columns: [
          SQLColumn(
            table,
            columnName,
            referenceTable: refTable,
            referenceColumn: refColumn,
          ),
        ],
      ),
    );

    if (entityFieldAnnotations != null) {
      if (entityFieldAnnotations.hasUnique) {
        var constrainUniqueName = '${table}__${columnName}__unique';

        sqlEntries.add(
          SQLEntry(
            'CONSTRAINT',
            ' CONSTRAINT $q$constrainUniqueName$q UNIQUE ($q$columnName$q)',
            columns: [
              SQLColumn(
                table,
                columnName,
                referenceTable: refTable,
                referenceColumn: refColumn,
              ),
            ],
          ),
        );
      } else if (entityFieldAnnotations.hasIndexed) {
        var indexName = '${table}__${columnName}__idx';
        indexSQLs.add(
          CreateIndexSQL(dialect, table, columnName, indexName, q: q),
        );
      }
    }
  }

  for (var e in referenceFields.entries) {
    var fieldName = e.key;
    var ref = e.value;

    var columnName = normalizeColumnName(fieldName);

    var refTableName = ref.key;
    var refField = ref.value.key.toLowerCase();

    var constrainName = '${table}__${columnName}__fkey';

    sqlEntries.add(
      SQLEntry(
        'CONSTRAINT',
        ' CONSTRAINT $q$constrainName$q FOREIGN KEY ($q$columnName$q) REFERENCES $q$refTableName$q($q$refField$q)',
        comment: '$fieldName @ $refTableName.$refField',
        columns: [
          SQLColumn(
            table,
            columnName,
            referenceTable: refTableName,
            referenceColumn: refField,
          ),
        ],
      ),
    );
  }

  sqlEntries.sort((a, b) {
    var c1 = a.type == 'CONSTRAINT';
    var c2 = b.type == 'CONSTRAINT';

    if (c1) {
      return c2 ? 0 : 1;
    } else {
      return c2 ? -1 : 0;
    }
  });

  var createSQL = CreateTableSQL(
    dialect,
    table,
    sqlEntries,
    q: q,
    entityRepository: entityRepository,
    indexes: indexSQLs,
  );

  var relationshipSQLs = <CreateTableSQL>[];

  var relationshipEntries =
      entityHandler
          .fieldsTypes()
          .entries
          .where((e) => e.value.isListEntityOrReference)
          .toList();

  for (var e in relationshipEntries) {
    var fieldName = e.key;
    var fieldType = e.value.arguments0!;

    var entityFieldAnnotations =
        entityHandler
            .getFieldEntityAnnotations(null, fieldName)
            ?.whereType<EntityField>()
            .toList();

    var columnName = normalizeColumnName(fieldName);

    var srcFieldName = normalizeColumnName(table);
    var relSrcType = foreignKeyTypeToSQLType(
      TypeInfo.fromType(idType),
      srcFieldName,
      entityFieldAnnotations: entityFieldAnnotations,
    );

    var relDstType = entityTypeToSQLType(fieldType, null);
    if (relDstType == null) continue;

    var relDstTable = relDstType.key;
    var relDstTableId = relDstType.value.key;
    var relDstTypeSQL = relDstType.value.value;

    var dstFieldName = normalizeColumnName(relDstTable);

    var relName = '${table}__${columnName}__rel';

    var constrainUniqueName = '${relName}__unique';
    var constrainSrcName = '${relName}__${srcFieldName}__fkey';
    var constrainDstName = '${relName}__${dstFieldName}__fkey';

    var sqlRelEntries = <SQLEntry>[
      SQLEntry(
        'COLUMN',
        ' $q$srcFieldName$q $relSrcType NOT NULL',
        comment: '$entityType.${e.key}',
        columns: [
          SQLColumn(
            relName,
            srcFieldName,
            referenceTable: table,
            referenceColumn: idColumnName,
          ),
        ],
      ),
      SQLEntry(
        'COLUMN',
        ' $q$dstFieldName$q $relDstTypeSQL NOT NULL',
        comment:
            '${e.value.toString(withT: false)} @ $relDstTable.$relDstTableId',
        columns: [
          SQLColumn(
            relName,
            dstFieldName,
            referenceTable: relDstTable,
            referenceColumn: relDstTableId,
          ),
        ],
      ),
      SQLEntry(
        'CONSTRAINT',
        ' CONSTRAINT $q$constrainUniqueName$q UNIQUE ($q$srcFieldName$q, $q$dstFieldName$q)',
        columns: [
          SQLColumn(relName, srcFieldName),
          SQLColumn(relName, dstFieldName),
        ],
      ),
      SQLEntry(
        'CONSTRAINT',
        ' CONSTRAINT $q$constrainSrcName$q FOREIGN KEY ($q$srcFieldName$q) REFERENCES $q$table$q($q$idColumnName$q) ON DELETE CASCADE',
        comment: ' $srcFieldName @ $table.$idColumnName',
        columns: [
          SQLColumn(
            relName,
            srcFieldName,
            referenceTable: table,
            referenceColumn: idColumnName,
          ),
        ],
      ),
      SQLEntry(
        'CONSTRAINT',
        ' CONSTRAINT $q$constrainDstName$q FOREIGN KEY ($q$dstFieldName$q) REFERENCES $q$relDstTable$q($q$relDstTableId$q) ON DELETE CASCADE',
        comment: ' $dstFieldName @ $relDstTable.$relDstTableId',
        columns: [
          SQLColumn(
            relName,
            dstFieldName,
            referenceTable: relDstTable,
            referenceColumn: relDstTableId,
          ),
        ],
      ),
    ];

    var relSQL = CreateTableSQL(
      dialect,
      relName,
      sqlRelEntries,
      q: q,
      parentTable: table,
    );
    relationshipSQLs.add(relSQL);
  }

  createSQL.relationships = relationshipSQLs;

  return createSQL;
}