Manngo's questions

Tenho uma tabela com uma coluna de identidade definida por:

id INT GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,

Para começar, inseri algumas linhas manualmente, incluindo a idcoluna:

INSERT INTO things(id, …)
VALUES (…, …), (…, …), (…, …);

Agora quero usar IDs gerados automaticamente para o resto.

Eu tentei:

ALTER TABLE things ALTER COLUMN id RESTART WITH (SELECT max(id) FROM things);

mas isso não funciona.

Eu até tentei:

EXECUTE IMMEDIATE 'ALTER TABLE employees ALTER COLUMN id RESTART WITH ' || (SELECT MAX(id)+1 FROM employees);

Sei que posso reiniciar com um valor constante, mas isso não será útil se eu não puder prever o id final após as inserções.

Existe uma maneira de reiniciar dinamicamente a coluna de identidade?

Estou escrevendo um código para adicionar um menu a um aplicativo tkInter. Aqui está um exemplo funcional:

import tkinter

main = tkinter.Tk()
main.title('Menu Test')

menubar = tkinter.Menu(main)
main['menu'] = menubar

m = tkinter.Menu()
menubar.add_cascade(menu=m, label='First')
m.add_command(label='Thing', command=lambda: print('thing'))

m = tkinter.Menu()
menubar.add_cascade(menu=m, label='Second')
m.add_command(label='Whatever', command=lambda: print('whatever'))

#   How to add another menu before 'First' ?

main.mainloop()

É possível adicionar outro menu antes do primeiro menu ( First)?

Obviamente, neste caso simples, posso simplesmente defini-lo primeiro, mas quero escrever uma rotina que preencha um menu a partir de um dicionário.

Estou tentando criar um botão dropdown simples no SwiftUI no macOS. Normalmente eu esperaria usar algo assim:

MenuButton("☰") {
    Button(action: { print("Something") }) {
        HStack {
            Image(systemName: "questionmark.circle")
            Text("Something")
        }
    }
    Button(action: { print("Something Else") }) {
        HStack {
            Image(systemName: "exclamationmark.circle")
            Text("Something Else")
        }
    }
}
.menuButtonStyle(BorderlessButtonMenuButtonStyle())

O .menuButtonStyle(BorderlessButtonMenuButtonStyle())mostra apenas o ícone do menu (☰)

sem o menu suspenso

No entanto, MenuButtonfoi descontinuado em favor de Menu, o que é bom, mas preciso modificá-lo com .menuStyle, e não consigo encontrar o equivalente aBorderlessButtonMenuButtonStyle

Qual seria o equivalente para Menusuprimir a seta suspensa?

Estou escrevendo um MenuBarExtra que precisa saber o aplicativo atual. Tenho um código que quase faz o trabalho:

import SwiftUI

@main
struct XBApp: App {
    @State var bundleID: String = ""

    var body: some Scene {
        MenuBarExtra("Something", systemImage: "questionmark.bubble") {
            VStack {
                XBContent(bundleID: bundleID)
                    .padding(0)
            }
            .onAppear {
                bundleID = NSWorkspace.shared.frontmostApplication!.bundleIdentifier!
                print("\(#fileID):\(#line) - \(bundleID)")
            }
        }
        .menuBarExtraStyle(.window)
    }
}

struct XBContent: View {
    var bundleID: String = ""
    @State var data: String = ""

    init(bundleID: String) {
        self.bundleID = bundleID    //  store received value
    }
    
    var body: some View {
        VStack {
            Text(bundleID)          //  current value
            Text(data)              //  previous value
        }
        .onAppear {
            data = bundleID         //  copy value
            print("\(#fileID):\(#line) - \(bundleID) | \(data)")
        }
    }
}

O aplicativo principal define o Bundle id atual .onAppeare isso é então passado para a XBContentvisualização. Acho que essa parte está fazendo seu trabalho corretamente, mas estou aberto a correções.

A XBContentvisualização simplesmente exibe duas versões do ID do pacote passado:

• o init()método armazena o valor em uma propriedade.
• copia onAppear-o para outra variável para teste. Na vida real, ele supostamente usa esse valor para ler outros dados.
• exibe VStacko valor de init()e o valor copiado de onAppear.

Aqui está o problema: o valor copiado de onAppearestá sempre um passo atrás do outro. Quando o aplicativo é iniciado pela primeira vez e o extra da barra de menu é aberto, o primeiro valor está correto, enquanto o segundo é a string vazia padrão; isso é corrigido na próxima vez. Quando eu troco para outro aplicativo e abro o extra da barra de menu, o primeiro valor é o novo id do pacote correto, enquanto o segundo é o antigo, até que eu tente novamente e esteja OK.

Concluo que isso onAppearnão é acionado quando eu pensava que deveria.

Como posso fazer com que o segundo valor seja o correto?

Tenho um script que adicionará a um armazenamento SwiftData se os dados ainda não existirem. Tenho a lógica funcionando, para uma janela comum, mas não consigo fazê-la funcionar em um Menu Extra. Aqui está um exemplo:

import SwiftUI
import SwiftData

@main
struct XBApp: App {
    var bundleID: String = "whatever"

    
    var body: some Scene {
        MenuBarExtra("Something", systemImage: "questionmark.bubble") {
//      WindowGroup {
            VStack {
                XBContent(bundleID: bundleID)
                    .padding(0)
            }
            .modelContainer(for: XBData.self)
        }
    }
}

@Model
class XBData {
    @Attribute(.unique) var bundle: String
    var note: String
    
    init(bundle: String, note: String = "Note") {
        self.bundle = bundle
        self.note = note
    }
}

struct XBList: View {
    @Query(sort: \XBData.bundle, animation: .easeInOut) var allXBarData: [XBData]
    @Environment(\.modelContext) private var modelContext
    
    var body: some View {
        VStack {
            Text("Everything So Far …")
            List {
                ForEach(allXBarData) { xbd in
                    HStack {
                        Text(xbd.bundle)
                        Spacer()
                        Text(xbd.note)
                        Spacer()
                        Button("", systemImage: "trash", action: {
                            modelContext.delete(xbd)
                        })
                        .buttonStyle(.bordered)
                    }
                }
            }
        }
        .modelContainer(for: XBData.self)
    }
}

struct XBContent: View {
    var bundleID: String = ""
    @Environment(\.modelContext) private var modelContext
    @State var xBData: XBData?
    @Query(sort: \XBData.bundle, animation: .easeInOut) var allXBarData: [XBData]

    func loadData(bundleID: String) -> XBData? {
        print("\(#fileID):\(#line) - \(bundleID)")
//      let filter = FetchDescriptor<XBData>(predicate: #Predicate { $0.bundle == bundleID })
        let filter = FetchDescriptor<XBData>(predicate: #Predicate { $0.bundle == bundleID })
        do {
            var xbd = try modelContext.fetch(filter).first
            print("\(#fileID):\(#line) - \(xbd == nil)")
            if xbd == nil {
                print("\(#fileID):\(#line) - \(xbd!.note)")
                xbd = XBData(bundle: bundleID, note: "Newish Note: \(bundleID)")
                modelContext.insert(xbd!)
                try modelContext.save()
            }
            else {
                print("\(#fileID):\(#line) - \(xbd!.note)")
            }
            return xbd
        } catch {
            print("\(#line) oops")
            return nil
        }
    }
    
    init(bundleID: String) {
        self.bundleID = bundleID
    }
    
    var body: some View {
        VStack {
            Text(bundleID)
//          XBList()
            List {
                ForEach(allXBarData) { xbd in
                    HStack {
                        Text(xbd.bundle)
                        Spacer()
                        Text(xbd.note)
                        Spacer()
                        Button("", systemImage: "trash", action: {
                            modelContext.delete(xbd)
                        })
                        .buttonStyle(.bordered)
                    }
                }
            }
        }
        .modelContainer(for: XBData.self)
        .onAppear {
            xBData = loadData(bundleID: bundleID)!
            xBData!.note = "Newish Note: \(bundleID)"
            try? modelContext.save()
        }
    }
}

Desculpe pelo tamanho da amostra.

Presumindo que um item com id de whatevernão existe, ele deve ser adicionado e exibido na lista.

Na estrutura App, comentei o WindowGroup. Se eu alternar para isso e não para o MenuBarExtra, funciona como esperado.

Também recebo a mensagem muito útil:

Não é possível encontrar ou decodificar os motivos
Falha ao obter ou decodificar os motivos indisponíveis

No entanto, isso acontece com o WindowGroup ou o MenuBarExtra, então não sei se está relacionado.

Qual é o truque para fazer isso funcionar com um MenuBarExtra?

Estou trabalhando em um aplicativo macOS. Tenho uma lista de itens SwiftData. Algo assim:

struct TestDataList: View {
    @Query var allTestData: [TestData]

    var body: some View {
        VStack {
            Text("Everything")
            if allTestData.count > 0 {
                List {
                    ForEach(allTestData){ test in
                        HStack {
                            Text(test.id)
                            Spacer()
                            Text(test.value)
                            Spacer()
                            Button("", systemImage: "trash", action: {
                                //  ?
                            })
                        }
                    }
                }
            }
        }
        .modelContainer(for: TestData.self)
    }
}

Gostaria de adicionar um botão que excluirá o item atual.

Pesquisei, mas tudo é para iOS e não consigo ver como isso se aplicaria aqui.

Qual actioncódigo preciso para excluir o item atual, tanto da Lista quanto, mais importante, dos dados?

Estou tentando escrever um código que insira um novo item no SwiftData se ele ainda não existir. Estou recebendo erros sobre o ModelContextqual não consigo resolver.

O código a seguir é uma versão enxuta que é o suficiente para gerar os erros. Eu removi a lógica para testar um item existente até que eu possa superar esse problema.

Desculpe pela extensão:

import SwiftUI
import SwiftData

@Model
class TestData {
    @Attribute(.unique) var id: String
    var value: String
    init(id: String, value: String) {
        self.id = id
        self.value = value
    }
}

struct EditTestItem: View {
    @Bindable var testData: TestData
    var body: some View {
        VStack {
            HStack {
                Text($testData.id)
                TextField("Enter Data Here", text: $testData.value)
            }
        }
        .modelContainer(for: TestData.self)
    }
}

struct TestContent: View {
    var testIDValue: String = ""
    @Environment(\.modelContext) private var modelContext
    @Query var testData: [TestData]
    var testItem: TestData
        
    init(testID: String) {
        testItem = TestData(id: testID, value: "New value: \(testID)")

        let _ = modelContext.insert(testItem)
                    
        do {
            try modelContext.save()
        } catch {
            print("\(#line) oops")
        }
    }
        
    var body: some View {
        VStack {
            VStack {
                Text(testIDValue)
                Text("\(testData.count)")
                EditTestItem(testData: testItem)
            }
            Button("Save", action: {
                try? modelContext.save()
            })
        }
        .modelContainer(for: TestData.self)
        .onAppear {

        }
    }
}

#Preview {
    TestContent(testID: "b")
        .modelContainer(for: TestData.self)
        .frame(width: 400)
}

Os erros incluem:

Acessando o valor do Environment fora de ser instalado em uma View. Isso sempre lerá o valor padrão e não atualizará.

e

Defina um .modelContext no ambiente da visualização para usar a consulta

Certamente não é adicionar dados.

Qual é a maneira correta de fazer isso?

Estou tentando criar um costume ButtonStyleque responda a mudanças de estado. Não consigo atualizá-lo quando o estado muda.

Aqui está uma versão simplificada:

struct TestButton: ButtonStyle {
    @State var selected: Bool = true
    func makeBody(configuration: ButtonStyleConfiguration) -> some View {
        configuration.label
            .frame(width: 48)
            .padding(EdgeInsets(top: 3, leading: 4, bottom: 3, trailing: 4))
            .background(selected ? .green : .red)
            .cornerRadius(14)
    }
}

struct TestView: View {
    @AppStorage("test") var test = 1
    var body: some View {
        HStack {
            Button(test == 1 ? "Yes" : "No") { test = 1 }
                .buttonStyle(TestButton(selected: test == 1))
            Button(test == 2 ? "Yes" : "No") { test = 2 }
                .buttonStyle(TestButton(selected: test == 2))
            Button(test == 3 ? "Yes" : "No") { test = 3 }
                .buttonStyle(TestButton(selected: test == 3))
        }
//      .id(UUID())     //  trying to avoid this
        .padding()
    }
}

A variável testé definida pelos botões, e eu quero que ela altere a aparência do botão. O teste test == …funciona corretamente, pois o texto alterna entre Yese No. No entanto, quando eu o uso com o selectedparâmetro, ele não altera nada. Ele define o valor quando a visualização é carregada pela primeira vez, mas não atualiza.

A variável na exibição usa @AppStorage, mas tentei com @Statee obtive os mesmos resultados.

Sei que posso fingir adicionando .id(UUID()), mas não tenho certeza se é a melhor abordagem.

Como posso atualizar o ButtonStyle?

De acordo com a documentação, createDirectorypode gerar um erro se algo der errado. No entanto, o valor de retorno é:

true se o diretório foi criado, true se createIntermediates estiver configurado e o diretório já existir ou false se ocorreu um erro.

Quero testar se um diretório foi criado ou se já existe. Achei que algo como o seguinte serviria:

do {
    let dirOK = try fileManager.createDirectory(atPath: toDirectory, withIntermediateDirectories: true)
    if dirOK {
        print("ok")
    }
    else {
        print("no")
    }
}
catch let error as NSError {
    print(error)
}

No entanto, recebo a mensagem de erro:

Não é possível converter o valor do tipo '()' para o tipo de condição esperado 'Bool'

Como posso verificar se um diretório foi realmente criado?