带选择的 HQL 插入查询，（意外标记：第 11 行附近的订单））

Question

我正在尝试使用 select 编写插入查询。 但我收到了这个错误 原因：org.hibernate.hql.ast.QuerySyntaxException：意外令牌：第 11 行第 23 列附近的订单

Query query = hibSession.createQuery("""
              INSERT INTO
                  ProcessOrder(
                  version,
                  numberOfPeriods,
                  billingPeriodStart,
                  billingPeriodEnd,
                  invoice,
                  billingRun,
                  org,
                  order)
              SELECT
                  1L AS version,
                  1 AS numberOfPeriods,
                  ilt.billingStartDate AS billingPeriodStart,
                  ilt.billingEndDate AS billingPeriodEnd,
                  i AS invoice,
                  i.billingRun as billingRun,
                  i.org as org,
                  soi as order
              from
                  Invoice as i
                  join i.ordersIncluded as soi
                  join i.invoiceLineItems as ilt
              where
                  i.billingRun = 36 AND
                  i.status IN ('Outstanding','Paid')  AND
                  ilt.position = 1  """)

请帮助解决这个问题

Answer 1

order 是一个保留 sql 字。最好不要使用它作为别名。

在该行上，例如使用：soi as soiOrder 当然也可以通过 soiOrder 更改插入顺序

你也可以使用：

.setResultTransformer(
    AliasToMapTransformer.renameAlias("soiOrder", "order").build()
)

有了这个类（版权：original answer）：

public class AliasToMapTransformer extends BasicTransformerAdapter {

  private Map<String, String> renameAliasMap;


  public AliasToMapTransformer(Map<String, String> renameAliasMap) {
    this.renameAliasMap = (renameAliasMap == null) ? Collections.<String, String>emptyMap() : renameAliasMap;
  }


  @Override
  public Object transformTuple(Object[] tuple, String[] aliases) {
    Map<String, Object> result = new HashMap<String, Object>(tuple.length);
    for (int i = 0; i < tuple.length; i++) {
        String alias = aliases[i];
        if (alias != null) {
            String newAlias = renameAliasMap.get(alias);

            result.put((newAlias != null) ? newAlias : alias, tuple[i]);
        }
    }
    return result;
  }


  public static Builder renameAlias(String alias, String newAlias) {
    return new Builder().renameAlias(alias, newAlias);
  }


  public static class Builder {

    private Map<String, String> aliasConversionMap = new HashMap<String, String>();


    public Builder renameAlias(String alias, String newAlias) {
        aliasConversionMap.put(alias, newAlias);
        return this;
    }


    public AliasToMapTransformer build() {
        return new AliasToMapTransformer(aliasConversionMap);
    }
  }
}