Perguntas[database](coding)

Estou fazendo a reindexação do Elasticsearch como um processo de várias etapas usando a biblioteca de cliente JavaScript:

• Clonar índice chamado "antigo" para um novo índice chamado "novo"
• Excluir índice "antigo"
• Reindexar do índice "novo" de volta para o "antigo"
• Excluir o "novo" índice

Preciso esperar a conclusão do 1º passo antes de executar os próximos passos. Existe um endpoint do Elasticsearch que eu possa consultar para descobrir quando o clone estiver concluído?

Estou tentando construir uma API REST usando Go e especificamente GORM.

Minhas entidades se parecem com isto:

type Business struct {
    ID        string    `json:"id" gorm:"primaryKey;not null;type:uuid;default:gen_random_uuid()"`
    CreatedAt time.Time `json:"-"`
    UpdatedAt time.Time `json:"-"`

    Email    string `json:"email" gorm:"uniqueIndex;not null;"`
    Password []byte `json:"-"`
    Name     string `json:"name"`

    Promos []Promo `json:"promos" gorm:"foreignKey:CompanyID;constraint:OnUpdate:CASCADE,OnDelete:CASCADE"`
}

type Promo struct {
    PromoID   string    `json:"id" gorm:"primaryKey;not null;type:uuid;default:gen_random_uuid()"`
    CompanyID string    `json:"company_id" gorm:"not null;foreignKey:ID"`
    CreatedAt time.Time `json:"-"`
    UpdatedAt time.Time `json:"-"`

    Target      Target        `json:"target" gorm:"foreignKey:TargetID;constraint:OnUpdate:CASCADE,OnDelete:CASCADE;not null"`
    Active      bool          `json:"-" gorm:"default:true"`
    ActiveFrom  time.Time     `json:"active_from"`
    ActiveUntil time.Time     `json:"active_until"`
    Description string        `json:"description" gorm:"not null"`
    ImageURL    string        `json:"image_url"`
    MaxCount    int           `json:"max_count" gorm:"not null"`
    Mode        string        `json:"mode" gorm:"not null"`
    PromoCommon string        `json:"promo_common"`
    PromoUnique []PromoUnique `json:"promo_unique" gorm:"foreignKey:PromoUniqueID;constraint:OnUpdate:CASCADE,OnDelete:CASCADE"`
}

type PromoUnique struct {
    PromoUniqueID string `json:"-" gorm:"primaryKey;not null;type:uuid;default:gen_random_uuid()"`
    Body          string `json:"-" gorm:"not null"`
    Activated     bool   `json:"-" gorm:"default:false"`
}

type Target struct {
    TargetID   string                `json:"-" gorm:"primaryKey;not null;type:uuid;default:gen_random_uuid()"`
    AgeFrom    int                   `json:"age_from"`
    AgeUntil   int                   `json:"age_until"`
    Country    countries.CountryCode `json:"country"`
    Categories []Category            `json:"categories" gorm:"foreignKey:CategoryID;constraint:OnUpdate:CASCADE,OnDelete:CASCADE"`
}

type Category struct {
    CategoryID string `json:"id" gorm:"primaryKey;not null;type:uuid;default:gen_random_uuid()"`
    TargetID   string `json:"-" gorm:"not null"`
    Name       string `json:"name" gorm:"not null"`
}

O código do meu serviço se parece com isso:

func (s *promoService) Create(ctx context.Context, promoDTO dto.PromoCreate) (*entity.Promo, error) {

    activeFrom, _ := time.Parse("2006-01-02", promoDTO.ActiveFrom)
    activeUntil, _ := time.Parse("2006-01-02", promoDTO.ActiveUntil)
    var categories []entity.Category
    var promoUniques []entity.PromoUnique
    for _, category := range promoDTO.Target.Categories {
        categories = append(categories, entity.Category{
            Name: category,
        })
    }
    for _, promoUnique := range promoDTO.PromoUnique {
        promoUniques = append(promoUniques, entity.PromoUnique{
            Body: promoUnique,
        })
    }

    company, _ := s.businessStorage.GetByID(ctx, promoDTO.CompanyID)

    promo := entity.Promo{
        Target: entity.Target{
            AgeFrom:    promoDTO.Target.AgeFrom,
            AgeUntil:   promoDTO.Target.AgeUntil,
            Country:    countries.ByName(strings.ToUpper(promoDTO.Target.Country)),
            Categories: categories,
        },
        CompanyID:   company.ID,
        Active:      true,
        ActiveFrom:  activeFrom,
        ActiveUntil: activeUntil,
        Description: promoDTO.Description,
        ImageURL:    promoDTO.ImageURL,
        MaxCount:    promoDTO.MaxCount,
        Mode:        promoDTO.Mode,
        PromoCommon: promoDTO.PromoCommon,
        PromoUnique: promoUniques,
    }

    company.Promos = append(company.Promos, promo)
    _, err := s.businessStorage.Update(ctx, company)
    if err != nil {
        return nil, err
    }

    return s.promoStorage.Create(ctx, promo)
}

Meu armazenamento se parece com isso:

// Create is a method to create a new Promo in database.
func (s *promoStorage) Create(ctx context.Context, promo entity.Promo) (*entity.Promo, error) {
    err := s.db.Model(&promo).WithContext(ctx).Create(&promo).Error
    return &promo, err
}

Mas quando tento alcançar um ponto final recebo este erro:

/opt/internal/adapters/database/postgres/promo.go:22 ERROR: insert or update on table "promos" violates foreign key constraint "fk_businesses_promos" (SQLSTATE 23503)       

O que devo fazer? Pesquisei algumas outras perguntas no stackoverflow com o mesmo problema, mas nenhuma me ajudou.

É assim que minhas mesas se parecem

CREATE TABLE T1(
id uuid not null,
order_time timestamptz NOT NULL,
PRIMARY KEY (id, order_time),
)

CREATE TABLE T2(
id uuid not null PRIMARY KEY,
t1_id uuid not null,
t1_order_time timestamptz not null,
FOREIGN KEY (t1_id, t1_order_time) REFERENCES T1 (id, order_time) ON DELETE CASCADE
)

Pretendo particionar a Tabela T1 com base no ID e no tempo do pedido, portanto, ela tem uma chave primária composta com base no ID e no tempo do pedido.

Se eu tentar remover T1, o postgres, como esperado, dá o erro “não é possível remover a tabela devido à restrição. Dica: use DROP ... CASCADE para remover os objetos dependentes também”.

Agora, se eu fizer 'drop table T1 cascade', ele descarta T1 e apenas exclui as restrições de chave estrangeira de T2. Nenhuma linha correspondente é excluída de T1

Tenho um problema. Tenho uma funcionalidade de backup no meu aplicativo. Aqui está como eu faço dumps:

schema_command = (
            f'PGPASSWORD={os.environ["POSTGRES_PASSWORD"]} '
            f'pg_dump -U {os.environ["POSTGRES_USER"]} '
            f'--schema-only -h {os.environ["DB_HOST"]} {os.environ["DB_NAME"]} > {schema_backup_file}'
        )
        subprocess.run(schema_command, shell=True, check=True)

        data_command = (
            f'PGPASSWORD={os.environ["POSTGRES_PASSWORD"]} '
            f'pg_dump -U {os.environ["POSTGRES_USER"]} '
            f'--data-only -h {os.environ["DB_HOST"]} {os.environ["DB_NAME"]} > {data_backup_file}'
        )
        subprocess.run(data_command, shell=True, check=True)

Também tenho uma funcionalidade de restauração:

schema_restore_command = (
            f'PGPASSWORD={os.environ["POSTGRES_PASSWORD"]} '
            f'psql -U {os.environ["POSTGRES_USER"]} '
            f'-h {os.environ["DB_HOST"]} -d {os.environ["DB_NAME"]} < {schema_backup_file}'
        )
        print(schema_restore_command)
        subprocess.run(schema_restore_command, shell=True, check=True)

        data_restore_command = (
            f'PGPASSWORD={os.environ["POSTGRES_PASSWORD"]} '
            f'psql -U {os.environ["POSTGRES_USER"]} '
            f'-h {os.environ["DB_HOST"]} -d {os.environ["DB_NAME"]} < {data_backup_file}'
        )
        print(data_restore_command)
        subprocess.run(data_restore_command, shell=True, check=True)

O problema é que preciso restaurar parcialmente os dados do dump. Por exemplo - eu acidentalmente deletei algumas linhas do banco de dados, mas minha tabela ainda está cheia de conteúdo. Não funciona. Funciona apenas quando a tabela está completamente vazia.

Eu tentei o sinalizador --inserts ao criar um despejo de dados. Tentei limpar meu banco de dados antes de restaurar, funcionou, mas não é assim que deveria funcionar de acordo com minha descrição de tarefa.

Ao trabalhar com o banco de dados sqlite em Go. Durante o teste, obtive o erro: no such table: table_name. Bem, eu sei de onde o erro está vindo.

Mas eu quero saber se há uma maneira de usar essa mensagem de erro no Go, para fazer algum trabalho com ela (como criar essa tabela no meu código). Eu estava tentando fazer algo assim:

_, err := getState(dbconn) // This the function that retrieves the table that does not exists
if err != nil {
    if err == err.New("no such table: table_name") {
        // do the work
    }
}

Estou usando o GridDB em uma configuração de cluster baseada em Docker para gerenciar dados de séries temporais em larga escala. O caso de uso envolve ingerir milhões de registros por dia, ao mesmo tempo em que garante desempenho de consulta eficiente para análises em tempo real.

Eu puxei a imagem GridDB https://hub.docker.com/r/griddb/griddb do Docker Hub e configurei um cluster com 3 nós. No entanto, estou encontrando os seguintes desafios:

1. Alta latência de gravação: a latência de gravação aumenta significativamente durante os períodos de pico de ingestão.
2. Desempenho da consulta: consultas complexas com múltiplas condições (por exemplo, intervalos de tempo, agregações) são mais lentas do que o esperado.
3. Uso de memória: o uso de memória aumenta irregularmente entre os nós, às vezes causando falhas nos nós.

Configuração atual:

• Configuração do cluster: • 3 nós em execução em contêineres Docker. • Usando configurações padrão de gs_cluster.json e gs_node.json. • Modelo de dados: • Dados de séries temporais armazenados em contêineres com chaves de linha como carimbos de data/hora. • Colunas indexadas para parâmetros de consulta comuns. • Taxa de ingestão: ~50.000 registros/segundo usando o GridDB Java SDK.

Passos dados até agora:

1. StoreMemoryLimit e notificationInterval ajustados em gs_node.json para gerenciar memória e desempenho de gravação.
2. Dados particionados em vários contêineres para reduzir a contenção durante gravações.
3. Experimentou diferentes tamanhos de lote para ingestão para encontrar uma configuração ideal.

Questões:

1. Otimização de gravação: Quais são as melhores práticas para melhorar a ingestão de dados de séries temporais no GridDB? Devo ajustar parâmetros específicos como dataAffinity ou checkpointInterval para melhor desempenho?

2. Gerenciamento de memória: como posso otimizar o uso de memória no cluster para evitar picos e possíveis falhas de nós?

3. Desempenho da consulta: Existem técnicas avançadas de indexação ou particionamento que podem melhorar o desempenho da consulta para consultas de intervalo de tempo e agregadas?

4. Monitoramento e depuração: há alguma ferramenta ou técnica recomendada para monitorar o desempenho do cluster GridDB e identificar gargalos de forma eficaz?

Referências:

• Documentação do GridDB: https://docs.griddb.net/

Quaisquer sugestões ou orientações sobre como resolver esses problemas seriam muito apreciadas.

Sou novo em store procedure e estou tentando criar um store procedure simples para ler da tabela. Estou usando IBM DB2 SQL.

--#SET MAXERRORS 0                                  
--#SET TERMINATOR ~                                 
SET CURRENT SQLID = 'SIWRO1'~                       
CREATE OR REPLACE PROCEDURE DWR000A.SELECT_PSID_RIZ(
  IN P_CONN INT                                     
 ,IN P_PLNN INT                                     
)                                                   
LANGUAGE SQL                                        
RESULT SETS 1                                       
READS SQL DATA                                      
BEGIN                                               
  DECLARE C1 CURSOR FOR                             
  SELECT PSID,                                      
         JOBINFO                                    
  FROM DWR000A.TEST                               
  WHERE CONN = P_CONN                               
  AND PLNN = P_PLNN;                                
  OPEN C1;                                          
END         
 ~                 
--#SET TERMINATOR ;
COMMIT;                                                 

Estou recebendo o erro abaixo ao executá-lo.

SQLERROR ON   CREATE    COMMAND, PREPARE   FUNCTION                      
RESULT OF SQL STATEMENT:                                                
DSNT408I SQLCODE = -4743, ERROR:  ATTEMPT TO USE A FUNCTION WHEN THE APPLICATION COMPATIBILITY SETTING IS SET FOR A PREVIOUS LEVEL                                                 
DSNT418I SQLSTATE   = 56038 SQLSTATE RETURN CODE                        
DSNT415I SQLERRP    = DSNHSM5R SQL PROCEDURE DETECTING ERROR            
DSNT416I SQLERRD    = 50  0  0  -1  1  2721 SQL DIAGNOSTIC INFORMATION  
DSNT416I SQLERRD    = X'00000032'  X'00000000'  X'00000000'  X'FFFFFFFF'
         INFORMATION                                                    

Não consigo descobrir o que estou fazendo errado ou como consertar. Agradeço alguns conselhos de especialistas. Obrigado

Atualização 28/11/2024 consegui contornar o erro fazendo 1 função que é criar. Obrigado

Estou trabalhando no Power Query e tenho a seguinte tabela:

Gostaria de somar os valores do tipo A e do tipo B para produzir a seguinte tabela:

Isso é possível no Power Query? Eu preferiria não fazer isso "manualmente" usando fórmulas específicas de células no Excel. O maior problema que encontro é não conseguir referenciar outras linhas com base em um valor de célula específico.

Você ganhará pontos extras se souber como fazer isso, substituindo uma soma simples por uma função mais complicada.

Meu palpite

Eu poderia descobrir como fazer isso se eu fosse capaz de manipular a primeira tabela em algo que se parecesse com

Isso parece próximo de uma mudança radical, mas não é bem assim.

Eu instalei uma instância do DB2 dentro de um contêiner Docker. Agora estou tentando conectar a ele a partir de um aplicativo Golang simples, usando o Windows 11 x64, mas recebo este erro:

Erro ao conectar ao banco de dados: falha ao executar ping no banco de dados: SQLDriverConnect: {IM002} [Microsoft][Driver Manager ODBC] Nome da fonte de dados não encontrado e driver padrão não especificado.

Tentei baixar um driver DB2 da IBM ( https://www.ibm.com/support/pages/db2-odbc-cli-driver-download-and-installation-information ), descompactei/instalei em C:/Program Files, adicionei à minha variável env PATH, reiniciei meu pc. Depois disso, ainda não vejo o driver na lista de drivers do "ODBC Data Source Administrator".

Este é meu código para a conexão:

import (
"database/sql"
"fmt"
_ "github.com/alexbrainman/odbc"
)

func ConnectDB() (*sql.DB, error) {
    connStr :=     "DATABASE=TEST1;HOSTNAME=localhost;PORT=50000;PROTOCOL=TCPIP;UID=db2inst1;PWD=db2inst1;"

    db, err := sql.Open("odbc", connStr)
    if err != nil {
    return nil, fmt.Errorf("failed to open database: %v", err)
}

    if err = db.Ping(); err != nil {
    return nil, fmt.Errorf("failed to ping database: %v", err)
}

    fmt.Println("Connected to DB2 database!")
    return db, nil
}

E este é meu main.go:

import (
"database/sql"
"go-db-check/db"
"log"
)

func main() {
    database, err := db.ConnectDB()
    if err != nil {
    log.Fatalf("Error connecting to database: %v", err)
}
    defer func(database *sql.DB) {
    closeErr := database.Close()
    if closeErr != nil {
        log.Println("Error during connection shutdown: ", err)
    }
}(database)
}

No seguinte banco de dados do Planilhas Google, não consigo obter a escolha de registros corretos com vários critérios em três campos.

com esta matriz

e esta função

DSUM($A$1:$D$10;"Number";$I$16:$K$19)

Não consigo obter a soma correta (25) dos teixos porque a função calcula 108.

Então com o mesmo banco de dados e o seguinte array

Tentei obter a soma dos carvalhos, bordos, cerejeiras, olmos e pinheiros, nos campos A e B, com maturidade entre >=2026-04-24 a <=2031-10-22 com esta função:

DSUM($A$1:$D$10;"Number";$I$8:$K$13)

e o resultado obtido é 68 enquanto apenas 10 árvores atendem aos requisitos.

Caso seja mais conveniente para uma abordagem visual,

No link a seguir, informei na caixa amarela essas duas funções DSUM e mais uma que funcionam corretamente.

exemplo de banco de dados onde mostro os erros