2

我正在开发一个 ORM 系统（对象关系映射，基本上是 java 类中的一个包装器，因此我不需要直接使用 SQL 代码）

这个问题是关于通过指定约束在表中搜索：

public final List<B> search(final AbstractConstraint... c) throws SearchException {
    if (c.length == 0) {
        throw new IllegalArgumentException("orm.Manager.search: c.length == 0");
    }
    try {
        List<B> beans = new ArrayList<>();

        for (AbstractConstraint constraint : c) {
            try (PreparedStatement ps = new QueryBuilder(connection, tableName(), getPaths(), searchQuery()).add(constraint).build();
                    ResultSet rs = ps.executeQuery()) {
                while (rs.next()) {
                    beans.add(createBean(rs));
                }
            }
        }

        if (c.length > 1) {
            boolean sorting = true;
            Field field = c[0].getField();
            Order order = c[0].getOrder();
            for (int i = 1; i < c.length; i++) {
                Field currentField = c[i].getField();
                Order currentOrder = c[i].getOrder();
                if (!field.equals(currentField) || !order.equals(currentOrder)) {
                    sorting = false;
                    break;
                }
            }
            if (sorting) {
                //sort on field with comparator of supertype
            }
        }

        return beans;
    } catch (SQLException ex) {
        Logger.getLogger(Manager.class.getName()).log(Level.SEVERE, null, ex);
        throw new SearchException(ex);
    }
}

通常， AbstractConstraint 本身会处理顺序。但是，如果您使用多个 AbstractConstraints （基本上是我的 SQL 对应项OR），则存在一种特殊情况。如果这些单独的 AbstractConstraints 中的两个（已经排序）共享相同的排序，那么结果List<B>应该也是排序的，并且不包含堆叠在彼此顶部的两个有序列表。

我该怎么做呢？这是我所知道的：

  • Field对象，指定应搜索的字段，这是对 SQL 数据库中表中列的直接引用。
  • Order对象_

所以我认为（在我当前的实现中），列（因此字段）可以具有以下值：

  • 字符串（在 SQL varchar 中）
  • 整数（在 SQL 整数中）
  • 日期（在 SQL 日期时间中）
  • BigInteger（SQL 十进制）

并且排序将是升序或降序。

我需要如何扩展我的Field类来捕获列的类型？这就是 Field 当前的全部内容：

public interface Field {
    public String getFieldName();
}

我将如何写Comparator？实际上，我什至必须编写Comparator还是应该以某种方式Field实现？Comparable

我希望这个问题是可以理解的，并期待任何答复。

编辑：添加具体实现示例Field：

public enum InvoiceFields implements Field {
    invoiceId("invoices.invoiceId"),
    businessPartnerId("invoices.businessPartnerId"),
    invoiceNumber("invoices.invoiceNumber"),
    invoiceDate("invoices.invoiceDate"),
    priceExclVAT("invoices.priceExclVAT"),
    VAT("invoices.VAT"),
    priceInclVAT("invoices.priceInclVAT"),
    paymentDiscount("invoices.paymentDiscount"),
    status("invoices.status");

    private final String enumName;

    private InvoiceFields(final String enumName) {
        this.enumName = enumName;
    }

    @Override
    public String getFieldName() {
        return enumName;
    }
}
4

1 回答 1

0

我想你想要一个抽象类。即然后为每个不同类型的字段创建子类。

public abstract class Field implements Comparable<Field> {

public abstract String getFieldName();

public int compareTo(Field field) {
return 0;
}
}
于 2013-07-22T13:39:51.977 回答