小编Luk*_*der的帖子

我试图了解使用JDBC从Oracle存储过程/函数获取表数据的不同方法.六种方式如下:

1. 过程将模式级表类型作为OUT参数返回
2. 过程将包级别表类型作为OUT参数返回
3. 过程将包级别的游标类型作为OUT参数返回
4. 函数返回模式级表类型
5. 函数返回包级表类型
6. 函数返回包级游标类型

以下是PL/SQL中的一些示例:

-- schema-level table type
CREATE TYPE t_type AS OBJECT (val VARCHAR(4));
CREATE TYPE t_table AS TABLE OF t_type;

CREATE OR REPLACE PACKAGE t_package AS
  -- package level table type
  TYPE t_table IS TABLE OF some_table%rowtype;
  -- package level cursor type
  TYPE t_cursor IS REF CURSOR;
END library_types;

-- and example procedures:
CREATE PROCEDURE p_1 (result OUT t_table);
CREATE PROCEDURE p_2 (result OUT t_package.t_table);
CREATE PROCEDURE p_3 (result OUT t_package.t_cursor);
CREATE FUNCTION f_4 …

我发现了JSON和XML之间的区别.因为,两者都用于系统之间的数据交换,但JSON和XML之间存在很大差异,JSON比XML更轻量级.但我无法找到为什么JSON重量轻的实际原因.是什么让JSON重量轻？

我发现一个答案是在JSON中没有很多额外的xml标记.它实际意味着什么.是否还有一些原因可以解释为什么JSON是轻量级的？

我可以知道数据库是否DELETE ON CASCADE包含查询吗？

当我运行此查询时:

START n1=node(7727), n2=node(7730)
MATCH n1-[r:SKILL]->n2 RETURN r

它给出了我在两个节点之间的重复关系列表.我将如何添加到cypher查询以迭代关系以保持一个关系并删除其余关系？

这段代码在Eclipse中编译,但不在javac中编译:

import java.util.function.Consumer;

public class Test {
    public static final void m1(Consumer<?> c) {
        m2(c);
    }
    private static final <T> void m2(Consumer<? super T> c) {
    }
}

javac输出:

C:\Users\lukas\workspace>javac -version
javac 1.8.0_92

C:\Users\lukas\workspace>javac Test.java
Test.java:5: error: method m2 in class Test cannot be applied to given types;
        m2(c);
        ^
  required: Consumer<? super T>
  found: Consumer<CAP#1>
  reason: cannot infer type-variable(s) T
    (argument mismatch; Consumer<CAP#1> cannot be converted to Consumer<? super T>)
  where T is a type-variable:
    T extends Object declared …

从Oracle 12c开始,我们最终可以像这样使用SQL标准行限制子句:

SELECT * FROM t FETCH FIRST 10 ROWS ONLY

现在,在Oracle 12.1中,加入表时存在一个非常烦人的限制.SELECT使用行限制子句时,子句中不可能有两列相同的列.例如,这会在Oracle 12.1中引发ORA-00918

SELECT t.id, u.id FROM t, u FETCH FIRST 10 ROWS ONLY

所有版本12.1,12.2,18.0的手册中都记录了这一限制:

解决方法显然是为列添加别名

SELECT t.id AS t_id, u.id AS u_id FROM t, u FETCH FIRST 10 ROWS ONLY

或者使用ROWNUM或窗口功能使用"经典"分页.

但奇怪的是,带有不明确ID列的原始查询从Oracle 12.2开始运行得很好.这是文档错误还是未记录的功能？

我可以在Scala中使用原语吗？

用例用于存储数十亿的整数,因此4个字节(对于int)和16个字节(对于整数)之间的差异很重要.

假设我有这样的记录（或任何其他记录）：

record X(int i, int j) {
    X(int i) {
        this(i, 0);
    }
    X() {
        this(0, 0);
    }
    X(String i, String j) {
        this(Integer.parseInt(i), Integer.parseInt(j));
    }
}

有没有办法通过反射找到这条记录的规范构造函数，即在RecordHeader?

在 jOOQ 中，很容易在表达式中使用绑定变量，例如：

MY_TABLE.COL.eq(1);
MY_TABLE.COL.in(1, 2, 3);
MY_TABLE.COL.between(1).and(10);

以上所有方法都接受T和Field<T>类型，例如Field.eq(T)or Field.eq(Field<T>)。但是如果我想把绑定变量放在表达式的左边怎么办？这些显然不起作用：

1.eq(MY_TABLE.COL);
1.in(MY_TABLE.COL1, MY_TABLE.COL2, MY_TABLE.COL3);
1.between(MY_TABLE.COL1).and(MY_TABLE.COL2);

我怎样才能把这些1or"xyz"变成Field<Integer>orField<String>等等？

（这是 jOOQ 邮件列表等上的一个热门问题，所以我在这里记录）

从Java 5开始,我们有了一个java.lang.Iterable可以在foreach循环中使用的新类型:

for (Object element : iterable);

该Iterable合同没有规定是否其iterator()方法可以在可迭代的处理之前被调用一次以上.即,不清楚以下是否可以为所有人工作Iterables:

for (Object element : iterable);
for (Object element : iterable);

例如,Iterator包装实现不能使用两次:

public class OneShotIterable<T> implements Iterable<T> {
    private final Iterator<T> it;

    public OneShotIterable(Iterator<T> it) {
        this.it = it;
    }

    @Override
    public Iterator<T> iterator() {
        return it;
    }
}

对于大多数Iterables,这是无关紧要的,因为它们实际上是改装收集API类型,例如List,Set,这已经为自己定义明确合同iterator()的方法.

我的问题是:我的OneShotIterable实施是否违反了我忽略的一些合同？换句话说,用户是否Iterable希望它可以重复使用？如果是这样,Java 5专家组是否有"官方"建议如何处理这样的"一次性" Iterables(例如,IllegalStateException在第二次通话时抛出)？