Is it possible to assert that a column is not nil in a query?

[mertalev]

I want to do something like this:

@Table
struct LocalAsset: Identifiable {
  let id: String
  let checksum: String?
  @Column(as: Date.UnixTimeRepresentation.self)
  let createdAt: Date
  let durationInSeconds: Int?
  let height: Int?
  let isFavorite: Bool
  let name: String
  let orientation: String
  let type: Int
  @Column(as: Date.UnixTimeRepresentation.self)
  let updatedAt: Date
  let width: Int?
}

@Table
struct UploadTask: Identifiable {
  let id: Int64
  let attempts: Int
  @Column(as: Date.UnixTimeRepresentation.self)
  let createdAt: Date
  let filePath: String?
  let group: String
  var localId: LocalAsset.ID
  let remoteId: RemoteAsset.ID?
  var sessionId: String?
  let status: TaskStatus
}

@Selection
struct LocalAssetTaskData {
  let taskId: UploadTask.ID
  let checksum: String
  let isFavorite: Bool
  @Column(as: Date.UnixTimeRepresentation.self)
  let createdAt: Date
  @Column(as: Date.UnixTimeRepresentation.self)
  let updatedAt: Date
}

UploadTask.join(LocalAsset.all) { task, asset in task.localId.eq(asset.id) }
  .where { task, asset in asset.checksum.isNot(nil) }
  .order { task, asset in task.createdAt }
  .select { task, asset in
    LocalAssetTaskData.Columns(
      taskId: task.id,
      checksum: asset.checksum,
      isFavorite: asset.isFavorite,
      createdAt: asset.createdAt,
      updatedAt: asset.updatedAt
    )
  }

But the type inference doesn't realize that asset.checksum isn't optional in this query, and I haven't found a way to assert this in the query builder. There are workarounds like using ?? or accepting that it's an optional and asserting it later, but it feels like there should be a better way to handle it unless I'm missing something.

Edit: asset.checksum.cast(as: String.self) makes the typing happy, but it looks to be deprecated? Is there a non-deprecated API to use for this?

[stephencelis]

You can always cast things using the #sql macro:

LocalAssetTaskData.Columns(
  taskId: task.id,
  checksum: #sql("\(asset.checksum)"),
  isFavorite: #sql("\(asset.isFavorite)"),
  createdAt: #sql("\(asset.createdAt)"),
  updatedAt: #sql("\(asset.updatedAt)")
)

You could maybe even hoist that work up to do it a single time:

let asset = #sql("\(asset)", as: LocalAsset.self)
return LocalAssetTaskData.Columns(
  taskId: task.id,
  checksum: asset.checksum,
  isFavorite: asset.isFavorite,
  createdAt: asset.createdAt,
  updatedAt: asset.updatedAt
)

[mertalev]

Thanks, that does compile! It's a bit hard to type though. I wrote an extension to make it cleaner:

public protocol OptionalProtocol {
  associatedtype Wrapped
  var unsafelyUnwrapped: Wrapped { get }
}

extension Optional: OptionalProtocol {}

extension TableColumn
where
  Value: OptionalProtocol,
  Value.Wrapped: QueryRepresentable & QueryBindable,
  Value.QueryOutput: OptionalProtocol,
  Value.Wrapped.QueryOutput == Value.QueryOutput.Wrapped
{
  var required: TableColumn<Root, Value.Wrapped> {
    TableColumn<Root, Value.Wrapped>(
      name,
      keyPath: keyPath.appending(path: \.unsafelyUnwrapped)
    )
  }
}

LocalAssetTaskData.Columns(
  taskId: task.id,
  checksum: asset.checksum.required, // could also maybe define a postfix operator for this
  isFavorite: asset.isFavorite,
  createdAt: asset.createdAt,
  updatedAt: asset.updatedAt
)

Would there be interest in adding something like this to the library?

Edit: Fixed it so it actually works at runtime haha.

[stephencelis]

@mertalev You could maybe achieve the same with a single helper:

extension QueryExpression where QueryValue: _OptionalProtocol {
  var unsafelyUnwrapped: SQLQueryExpression<QueryValue.Wrapped> {
    SQLQueryExpression("\(self)", as: QueryValue.Wrapped.self)
  }
}

LocalAssetTaskData.Columns(
  taskId: task.id,
  checksum: asset.checksum.unsafelyUnwrapped,
  isFavorite: asset.isFavorite.unsafelyUnwrapped,
  createdAt: asset.createdAt.unsafelyUnwrapped,
  updatedAt: asset.updatedAt.unsafelyUnwrapped
)

We honestly might be down for a PR for this functionality, though we'd need to discuss and think through the details.

[mertalev]

Yup, that works! I just changed "\(self)" to self.queryFragment assuming it's a tiny bit better. Happy to make a PR for that