问题[database](coding)

我正在尝试将完整的数据库转储导入impdp到不同的 Oracle 19c（标准版 2）环境中，但该REMAP_DATAFILE参数似乎不起作用。

我的目标是将转储从名为db_source的源数据库导入到名为db_target的目标数据库中，将所有数据文件重定向到不同的文件夹路径（/opt/oracle/oradata/oradata/DB_TARGET/pdb_target/），因为不同环境的文件系统结构不同。

.par这是我的文件中的内容：

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

但是，我不断收到如下错误：

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

我已确认我已pdb_target使用 连接到正确的 PDB ( ) SHOW CON_NAME;。

我还使用生成了 SQL 预览SQLFILE=preview.sql并注意到数据文件路径没有被重新映射，它们仍然指向/opt/oracle/oradata/oradata/DB_SOURCE/。

我发现有人在这里遇到同样的问题（仍未解决）：https://forums.oracle.com/ords/apexds/post/data-pump-datafile-remapping-does-not-work-5729

如何REMAP_DATAFILE在 Oracle 19c 上正常工作？是否有其他要求或已知错误？

我一直在从官方文档学习 GORM，当尝试使用 Create() 函数从地图创建记录时遇到了一些困惑。

官方文档展示了从地图创建记录的示例：

// 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},
})

但问题是——如果表没有定义主键 (PK)，这种方法可以正常工作。但是，如果我定义了一个主键字段（例如user_id），就会出错。据我所知，每个表都必须有一个主键才能进行规范化，那么为什么这种方法在没有主键的情况下也能正常工作呢？

如果表有主键，从 map 创建记录有什么有效的用例吗？在这种情况下，GORM 会自动处理主键吗？还是我遗漏了什么，导致它真的无法处理主键？

我还想知道文档中的示例是否真的写得很好，或者是否需要对带有主键的表进行修改。处理带有主键的表时，我应该使用结构体而不是映射吗？

每当我尝试在 Users 表中创建并插入新用户时（使用User.newDAO 方法或Users.insert方法），具有默认值且被描述为非空的枚举字段 accountstatus 会导致插入失败null value in column "accountstatus" violates not-null constraint。

以下是表定义和用户 DAO 的代码：

 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
 }

以下是引发异常的代码：

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

我正在使用 JavaScript 客户端库以多步骤过程对 Elasticsearch 进行重新索引：

• 将名为“old”的索引克隆到名为“new”的新索引
• 删除“旧”索引
• 将“新”索引重新索引为“旧”索引
• 删除“新”索引

我需要等待第一步完成后才能执行后续步骤。是否有一个 Elasticsearch 端点可以轮询以了解克隆何时完成？

我正在尝试使用 go 特别是 GORM 构建 REST API。

我的实体看起来像这样：

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"`
}

我的服务代码如下所示：

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)
}

我的存储如下所示：

// 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
}

但是当我尝试到达端点时出现此错误：

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

我该怎么办？我在 stackoverflow 上研究了一些有同样问题的其他问题，但都没有帮助我。

我的桌子是这样的

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
)

我打算根据 id 和订购时间对表 T1 进行分区，因此它在 id 和订购时间上具有复合主键。

如果我尝试删除 T1，postgres 会按预期给出错误“由于约束无法删除表，提示：使用 DROP ... CASCADE 也删除依赖对象。”

现在，如果我执行“drop table T1 cascade”，它会删除 T1 并只删除 T2 的外键约束。不会从 T1 中删除任何相应的行

我有一个问题。我的应用程序中有一个备份功能，下面是我进行转储的方法：

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)

我还有一个恢复功能：

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)

问题是我需要从转储中部分恢复数据。例如 - 我意外删除了一些数据库行，但我的表仍然充满内容。它不起作用。只有当表完全为空时它才有效。

我在创建数据转储时尝试了 --inserts 标志，我尝试在恢复之前清理数据库，它可以工作，但根据我的任务描述，它不应​​该这样工作

在 Go 中使用 sqlite 数据库时。在测试期间我收到错误：no such table: table_name。好吧，我知道错误来自哪里。

但我想知道是否有办法在 Go 中使用此错误消息来处理它（例如在我的代码中创建该表）。我试图做这样的事情：

_, 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
    }
}

我在基于 Docker 的集群设置中使用 GridDB 来管理大规模时间序列数据。用例涉及每天提取数百万条记录，同时确保实时分析的高效查询性能。

我从 Docker Hub 提取了 GridDB https://hub.docker.com/r/griddb/griddb镜像，并配置了一个包含 3 个节点的集群。但是，我遇到了以下挑战：

1. 高写入延迟：在高峰摄取期间，写入延迟会显著增加。
2. 查询性能：具有多种条件（例如时间范围、聚合）的复杂查询比预期的要慢。
3. 内存使用情况：各个节点的内存使用量不定期出现峰值，有时会导致节点故障。

当前设置：

• 集群配置：• 在 Docker 容器上运行 3 个节点。• 使用 gs_cluster.json 和 gs_node.json 中的默认配置。• 数据模型：• 时间序列数据存储在容器中，行键作为时间戳。• 常用查询参数的索引列。• 提取率：使用 GridDB Java SDK 约为每秒 50,000 条记录。

迄今采取的措施：

1. 调整gs_node.json中的storeMemoryLimit和notificationInterval来管理内存和写入性能。
2. 跨多个容器分区数据以减少写入期间的争用。
3. 尝试了不同批次大小的摄取以找到最佳配置。

问题：

1. 写入优化：改进 GridDB 中时间序列数据提取的最佳实践是什么？我是否应该调整 dataAffinity 或 checkpointInterval 等特定参数以获得更好的性能？

2. 内存管理：如何优化整个集群的内存使用情况以避免峰值和潜在的节点故障？

3. 查询性能：是否存在高级索引或分区技术可以提高时间范围和聚合查询的查询性能？

4. 监控和调试：是否有任何推荐的工具或技术来监控 GridDB 集群性能并有效识别瓶颈？

参考：

• GridDB 文档：https://docs.griddb.net/

如能得到关于解决这些问题的任何建议或指导，我们将不胜感激。

我是存储过程的新手，正在尝试创建一个简单的存储过程来从表中读取数据。我正在使用 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;                                                 

执行时出现以下错误。

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                                                    

我不知道我做错了什么，也不知道该如何解决。我很感激一些专家的建议。谢谢

更新 11/28/2024 我设法通过执行 1 个函数（即创建）来绕过错误。谢谢