Perguntas[database](coding)

Estou tentando importar um dump completo do banco de dados impdppara um ambiente diferente do Oracle 19c (Standard Edition 2), mas o REMAP_DATAFILEparâmetro parece não estar funcionando.

Meu objetivo é importar um dump de um banco de dados de origem chamado db_source para um destino chamado db_target , redirecionando todos os arquivos de dados para um caminho de pasta diferente ( /opt/oracle/oradata/oradata/DB_TARGET/pdb_target/), já que a estrutura do sistema de arquivos difere entre os ambientes.

Isso é o que tenho no meu .pararquivo:

REMAP_DATAFILE=/opt/oracle/oradata/oradata/DB_SOURCE/:/opt/oracle/oradata/oradata/DB_TARGET/pdb_target/

No entanto, continuo recebendo erros como:

ORA-39083: Object type TABLESPACE:"DATOSLOB" failed to create with error:
ORA-01119: error in creating database file '/opt/oracle/oradata/oradata/DB_SOURCE/DATOSLOB_01'
ORA-27038: created file already exists

Confirmei que estou conectado ao PDB correto ( pdb_target) usando SHOW CON_NAME;.

Também gerei uma visualização SQL usando SQLFILE=preview.sqle notei que os caminhos do arquivo de dados não estão sendo remapeados , eles ainda apontam para /opt/oracle/oradata/oradata/DB_SOURCE/.

Encontrei alguém enfrentando o mesmo problema aqui (ainda sem solução): https://forums.oracle.com/ords/apexds/post/data-pump-datafile-remapping-does-not-work-5729

Como posso REMAP_DATAFILEtrabalhar corretamente no Oracle 19c? Há algum requisito adicional ou bug conhecido?

Tenho aprendido GORM com a documentação oficial e estou tendo alguma confusão ao tentar criar registros de um mapa usando a função Create().

A documentação oficial mostra este exemplo de criação de registros a partir de um mapa:

// Single insert
db.Model(&User{}).Create(map[string]interface{}{
  "Name": "jinzhu", "Age": 18,
})

// Batch insert
db.Model(&User{}).Create([]map[string]interface{}{
  {"Name": "jinzhu_1", "Age": 18},
  {"Name": "jinzhu_2", "Age": 20},
})

Mas aqui está a questão: isso funciona bem se não houver uma chave primária (PK) definida para a tabela. No entanto, se eu definir um campo PK (como user_id), recebo um erro. Pelo que entendi, toda tabela precisa ter uma chave primária para normalização, então por que esse método funciona sem uma PK?

Existe algum caso de uso válido para criar registros a partir de um mapa se a tabela tiver uma PK? O GORM lida com PKs automaticamente neste caso? Ou há algo que não entendi e ele realmente não funciona com PKs?

Também estou me perguntando se o exemplo na documentação está realmente bem escrito ou se precisa de uma correção para lidar com tabelas com chaves primárias. Devo usar structs em vez de mapas ao trabalhar com tabelas que têm uma chave primária?

Sempre que tento criar e inserir um novo usuário na tabela Usuários (com o User.newmétodo DAO ou o Users.insertmétodo ), um campo de enumeração accountstatus que é descrito como não nulo, com um valor padrão, faz com que a inserção falhe a partir de null value in column "accountstatus" violates not-null constraint.

Aqui está o código para a definição da tabela e o DAO do usuário:

 object Users : UUIDTable() {
     val email = varchar("email", 255).uniqueIndex()
     val role = enumeration<Role>("role")
     val registrationDate =
         datetime("registrationDate").default(Clock.System.now().toLocalDateTime(TimeZone.currentSystemDefault()))
     val disabledDate = datetime("disabledDate").nullable()
     val accountStatus = enumeration<AccountStatus>("accountStatus").default(AccountStatus.ACTIVE)
 
     enum class Role {
         PROFESSOR, STUDENT
     }
 
     enum class AccountStatus {
         ACTIVE, DISABLED
     }
 }

 class User(id: EntityID<UUID>) : UUIDEntity(id), UserData {
     companion object : UUIDEntityClass<User>(Users)
 
     override var email by Users.email
     override var role by Users.role
     override val registrationDate by Users.registrationDate
     override var disabledDate by Users.disabledDate
     override var accountStatus by Users.accountStatus
     val sessions by Session referrersOn Sessions.userId
 }

Aqui está o código que gera a exceção:

 // ...
 transaction {
     User.new {
         email = email /* logic omitted */
         role = role /* logic omitted */
     }
 }

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