All perguntas(coding)

Digamos que eu tenha a seguinte estrutura:

Cursos

Estudantes

Quero fazer uma consulta que liste todos os alunos de um curso, mas filtre os cursos se um aluno específico estiver naquele curso.

Se eu usar a seguinte consulta, o aluno "Bob" não estará na lista de alunos separados por vírgulas.

SELECT 
  c.name, 
  GROUP_CONCAT(s.name separator ',') 
FROM 
  Courses as c 
  LEFT JOIN Students s ON s.courseID = c.ID 
WEHRE 
  s.name = 'Alice'
GROUP BY
  c.name

Sei que posso me juntar duas vezes e usar uma para fazer a filtragem e a outra para o GROUP_CONCAT, mas parece ineficiente porque estou me juntando duas vezes. Existe uma maneira mais eficiente e/ou direta de fazer isso?

var notes = ['do', 'do#', 're', 're#', 'mi', 'fa', 'fa#',
  'sol', 'sol#', 'la', 'la#', 'si'
];

function stepUp() {
  var text = document.getElementById('textarea');
  if (typeof text.count == 'undefined') {
    text.count = 0;
  } else {
    text.count++;
  }

  if (text.count == notes.length) {
    text.count = 0;
  }
  text.innerHTML = notes[text.count];
}

function stepDown() {
  var text = document.getElementById('textarea');
  text.count--;

  if (text.count == notes.length) {
    text.count = 0;
  }

  if (text.count < 0) {
    text.count = 11;
  }
  text.innerHTML = notes[text.count];
}

/* Load file*/
function load_song() {
  var fileToLoad = document.getElementById("load_button").files[0];
  var fileReader = new FileReader();
  fileReader.onload = function(fileLoadedEvent) {
    var textFromFileLoaded = fileLoadedEvent.target.result;
    document.getElementById("textarea").value = textFromFileLoaded;
  };
  fileReader.readAsText(fileToLoad, "UTF-8");
}

body {
  font-family: Arial, sans-serif;
  background-color: #333;
  color: #ddd;
  text-align: center;
}

container {
  display: flex;
  margin: 2vmin;
  position: relative;
  top: 3vmin;
}

<div class="container">
  <textarea id="textarea" rows="5" cols="50">---</textarea>
</div>

<button onclick="stepUp()" class="stepUp_Button">Up</button>
<button onclick="stepDown()" class="stepDown_Button">Down</button>

<!-- Load button -->
<span>Load File:&nbsp;</span>
<input type="file" id="load_button">
<button class="load_button" onclick="load_song()">Load</button>

Gostaria de escrever na textarea em ordem aleatória as notas

"do do# re re# mi fa fa# sol sol# la la# si"

(ou carregue um arquivo .txt com essas notas escritas em ordem aleatória sol mi do# fa sietc.)

e pressionando o botão para cima para aumentá-los todos +1, ou seja do => do# , e pressionando o botão para baixo para diminuí-los todos -1.do => si

Embora pareça funcionar para uma nota, se eu escrever na área de texto e pressionar o botão para cima, não funciona de jeito nenhum, assim como não funciona se eu carregar um arquivo .txt simples. Qualquer ideia seria extremamente útil. Obrigado!

Tenho dados meteorológicos em um dicionário Python que estou tentando converter para um arquivo DF do Pandas. (De lá, vou carregá-los no SQLServer, mas essa parte já está funcionando)

my_dict = {
'data.outdoor.temperature': {'unit': '℃', 'list': 
{'datetime.datetime(2025, 4, 23, 10, 0): 22.3', 
'datetime.datetime(2025, 4, 23, 14, 0): 21.3', 
'datetime.datetime(2025, 4, 23, 18, 0): 18.2', }}, 
'data.indoor.temperature': {'unit': '℃', 'list': 
{'datetime.datetime(2025, 4, 23, 10, 0): 23.2', 
'datetime.datetime(2025, 4, 23, 14, 0): 23.5', 
'datetime.datetime(2025, 4, 23, 18, 0): 22.9'}}}

O resultado que estou buscando é:

outdoor.temperature | 2025_04_20 | 14 | 28.1 | ℃  
outdoor.temperature | 2025_04_20 | 18 | 23.8 | ℃  
.....etc  
indoor.temperature | 2025_04_20 | 14 | 23.5 | ℃  
indoor.temperature | 2025_04_20 | 18 | 23.8 | ℃  
.....etc

A lista de datetime& temperaturespode ter centenas de registros

Eu tentei from_dict, concat/ unstack, normalize, flattene combinações de todos eles, mas estou derrotado

Estou tentando aprender Swift 6. O problema que tenho enfrentado é que não consigo ler (não tentar modificar) as propriedades de actorum UI class.

É possível ler sem adicionar propriedades armazenadas extras ou aguardar?

Você pode me dar alguma solução para isso?

final actor Logger: Sendable {
    
    static let current = Logger()
    
    private(set) final var logs: [Int] = []
    
    private init() { }
    
    nonisolated var count: Int {
        
        return self.logs.count
    }
}

final class ViewController: NSViewController, NSTableViewDataSource {
   
    @IBOutlet weak var tableView: NSTableView!
     
    func numberOfRows(in tableView: NSTableView) -> Int {
        
        return Logger.current.count
    }
}

Erro:

A propriedade 'logs' isolada do ator não pode ser referenciada a partir de um contexto não isolado

Obrigado!

Estou tentando entender a diferença entre dois serviços do Google que lidam com alertas de terremotos:

API de alertas públicos do Google — descrita como um sistema que mostra alertas de emergência (incluindo terremotos).

Sistema de alertas de terremotos do Android — um sistema integrado aos telefones Android para detectar e notificar usuários sobre terremotos usando sensores do telefone.

Minha pergunta principal é: esses dois serviços estão relacionados ou conectados de alguma forma? Ou são sistemas completamente separados?

Especificamente:

A API de Alertas Públicos fornece os mesmos alertas de terremoto mostrados em dispositivos Android?

A fonte de dados é a mesma para ambos (por exemplo, agências sísmicas oficiais)?

Os desenvolvedores podem acessar os dados do Alerta de Terremoto do Android por meio da API de Alertas Públicos?

Li que a API de Alertas Públicos "depende de dados de agências autorizadas", mas não consegui encontrar uma fonte definitiva que confirmasse isso. Se alguém puder esclarecer com documentação ou exemplos, eu agradeceria muito.

Desde já, obrigado.

Posso alternar entre comandos no Bash:

$ vim
CTRL-Z
# vim is in background now
# can resume it with:
$ fg

Estou tentando fazer o mesmo com um shell aninhado, mas não está funcionando:

# launch nested Bash shell:
$ bash
CTRL-Z
# still in nested shell...

É possível colocar um shell aninhado em segundo plano e retornar a um shell pai, semelhante ao vimexemplo?
Se não for possível, quais são os motivos?

Recentemente, refatorei um gerador de código-fonte para usar árvores de sintaxe em vez de interpolação de strings. O gerador de código-fonte pega um arquivo JSON e gera uma classe estática com strings públicas. A chave é o nome da propriedade e o valor da propriedade é o valor.

Notei que a saída não tem espaços entre os membros:

public static class TranslationKeys
{
    /// <summary>
    /// Looks up a localized string using key CurrentLocaleName.
    /// </summary>
    public const string CurrentLocaleName = "CurrentLocaleName";
    /// <summary>
    /// Looks up a localized string using key LocalizationCurrentProviderIs.
    /// </summary>
    public const string LocalizationCurrentProviderIs = "LocalizationCurrentProviderIs";
}

Anteriormente, ao usar um construtor de strings, eu tinha um belo espaço entre os membros:

public static class TranslationKeys
{
    /// <summary>
    /// Looks up a localized string using key CurrentLocaleName.
    /// </summary>
    public const string CurrentLocaleName = "CurrentLocaleName";

    /// <summary>
    /// Looks up a localized string using key LocalizationCurrentProviderIs.
    /// </summary>
    public const string LocalizationCurrentProviderIs = "LocalizationCurrentProviderIs";
}

Minha fonte é gerada da seguinte forma:

private static string GenerateSource(string generatedNamespace, Dictionary<string, string> keysToGenerate)
{
    var namespaceDeclaration = SyntaxFactory.NamespaceDeclaration(SyntaxFactory.ParseName(generatedNamespace))
        .AddUsings(SyntaxFactory.UsingDirective(SyntaxFactory.ParseName("System")))
        .AddMembers(
            SyntaxFactory.ClassDeclaration("TranslationKeys")
                .AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword), SyntaxFactory.Token(SyntaxKind.StaticKeyword))
                .AddMembers(keysToGenerate.Select(CreateConstantField).ToArray())
        );

    var compilationUnit = SyntaxFactory.CompilationUnit()
        .AddMembers(namespaceDeclaration)
        .NormalizeWhitespace("\t");

    return compilationUnit.ToFullString();
}

private static MemberDeclarationSyntax CreateConstantField(KeyValuePair<string, string> keyValuePair)
{
    return SyntaxFactory.FieldDeclaration(
            SyntaxFactory.VariableDeclaration(SyntaxFactory.ParseTypeName("string"))
                .AddVariables(SyntaxFactory.VariableDeclarator(keyValuePair.Key)
                    .WithInitializer(SyntaxFactory.EqualsValueClause(SyntaxFactory.LiteralExpression(
                        SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(keyValuePair.Value))))))
        .AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword), SyntaxFactory.Token(SyntaxKind.ConstKeyword))
        .WithLeadingTrivia(SyntaxFactory.TriviaList(
            SyntaxFactory.CarriageReturnLineFeed,
             SyntaxFactory.Comment("/// <summary>"),
             SyntaxFactory.Comment($"/// Looks up a localized string using key {keyValuePair.Value}."),
             SyntaxFactory.Comment("/// </summary>")
        ))
        .WithTrailingTrivia(SyntaxFactory.ElasticCarriageReturnLineFeed);
}

Tentei de tudo para CreateConstantFieldadicionar uma quebra de linha vazia. Adicionei espaços em branco com \n, todos os fins de linha imagináveis ​​e nada parece funcionar. Usei o gpt 4o e o claude 3.7 e eles me levaram a um círculo vicioso de WithTrailingTrivia que nunca funciona.

Estou verificando se o gerador está atualizado, reconstruindo-o e executando-o manualmente pelo Visual Studio (adiciono um comentário que altero para garantir que o código mais recente esteja sendo executado). Não tive sorte e não sei como posso obter essa funcionalidade (que eu consideraria básica) a partir de um código gerado!

Eu escrevi uma função http que funciona usando o switch map para obter o valor de uma solicitação http e usá-lo como um parâmetro na segunda, mas como faço para retornar não apenas a solicitação http final, mas também os dados da primeira?

Aqui está minha função:

      .post<RxObservable<unknown>>(
        `${this.nextApiEndpoint}ProgramReview/GetAssessmentQuestionNumber`,
        body,
        {}
      )
      .pipe(
        switchMap((data) => {
          return this.http.post<any>(
            `${this.nextApiEndpoint}ProgramReview/GetProgramReviewQuestion`,
            { studentId: args.studentId, questionId: data, programReviewId: args.programReviewId },
            {}
          );
        }),
        catchError((err) => {
          return err;
        })
      );
  }

Eu assino está no componente e obtenho os dados de retorno da solicitação http final, mas também quero passar os dados da primeira solicitação para assinar no componente.

O SQL Server tem uma DATEFIRSTconfiguração que determina o primeiro dia da semana para cálculos de data.

SELECT DATENAME(weekday, '2025-04-23') AS WeekdayName  -- Wednesday

SET DATEFIRST 7  -- Sunday
SELECT DATEPART(weekday, '2025-04-23') AS WeekdayNumber  -- 4

SET DATEFIRST 1  -- Monday
SELECT DATEPART(weekday, '2025-04-23') AS WeekdayNumber  -- 3

De acordo com a documentação da Microsoft , o valor padrão de DATEFIRSTem inglês dos EUA é 7 (domingo).

Se o SQL Server estiver configurado com um idioma diferente do inglês ou dos EUA, o valor padrão será DATEFIRSTdiferente de 7? Em caso afirmativo, como verifico os valores padrão para diferentes idiomas?

Gostaria de saber se posso usar comentários entre o nome da função do script de shell POSIX e seu corpo? Isso parece não causar problemas no shellcheck e roda em Dash/Bash, mas ao procurar por essa informação, não encontrei nada útil.

Exemplo de funções de shell:

is_int()
# POSIX [bool] function to test one variable for an integer.
{
    case "${1#[+-]}" in
        (*[!0123456789]*) return 1 ;;
        ('')              return 1 ;;
        (*)               return 0 ;;
    esac
}

is_uint()
# POSIX [bool] function to test one variable for an unsigned integer.
{
    case "$1" in
        ([+-]*) return 1 ;;
    esac
    is_int "$1"
}

Algum shell teria algum problema com isso? Eu não gostaria que isso prejudicasse a portabilidade de alguns dos meus scripts.

Atenção, eu só uso isso recentemente e como comecei a usar o VS Codium ele suporta blocos de função colapsando assim:

Obrigado.

PS: Gosto mais dos comentários descrevendo funções nos meus scripts de shell dessa forma do que de ter o comentário acima f()do nome do . É apenas uma questão cosmética e, portanto, por favor, evite discutir o "Por que não?" acima do nome da função. Obrigado!