问题[database](coding)

每当我尝试在 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 个函数（即创建）来绕过错误。谢谢

我正在使用 Power Query，并且有下表：

我想将类型 A 和类型 B 的值加在一起，以生成下表：

在 Power Query 中可以实现吗？我不想使用 Excel 中特定于单元格的公式“手动”执行此操作。我遇到的最大问题是无法根据特定单元格值引用其他行。

如果您知道如何做到这一点，用更复杂的函数代替简单的求和，则可以获得加分。

我的猜测

如果我能把第一个表处理成如下形式，我就能想出怎么做

这感觉像是一个支点，但不完全是。

我在 Docker 容器内安装了一个 DB2 实例。现在我尝试使用 Windows 11 x64 从一个简单的 Golang 应用程序连接到它，但出现此错误：

连接数据库时出错：无法 ping 数据库：SQLDriverConnect：{IM002} [Microsoft][Driver Manager ODBC] 未找到数据源名称且未指定默认驱动程序。

我尝试从 IBM 下载 DB2 驱动程序（https://www.ibm.com/support/pages/db2-odbc-cli-driver-download-and-installation-information），将其解压并安装在 C:/Program Files 中，将其添加到我的 PATH 环境变量中，然后重新启动我的电脑。之后，我仍然没有在“ODBC 数据源管理器”驱动程序列表中看到该驱动程序。

这是我的连接代码：

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
}

这是我的 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)
}