[#2848] Add support for infix-notation for bitwise operations
This commit is contained in:
Lukas Eder
parent
91d4b4fddb
commit
861d43980a
@ -833,6 +833,156 @@ public interface Field<T> extends GroupField {
|
||||
)
|
||||
Field<T> modulo(Field<? extends Number> value);
|
||||
|
||||
// ------------------------------------------------------------------------
|
||||
// Bitwise operations
|
||||
// ------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* The bitwise not operator.
|
||||
*
|
||||
* @see DSL#bitNot(Field)
|
||||
*/
|
||||
@Support({ CUBRID, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES, SQLITE })
|
||||
Field<T> bitNot();
|
||||
|
||||
/**
|
||||
* The bitwise and operator.
|
||||
*
|
||||
* @see DSL#bitAnd(Field, Field)
|
||||
*/
|
||||
@Support({ CUBRID, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES, SQLITE })
|
||||
Field<T> bitAnd(T value);
|
||||
|
||||
/**
|
||||
* The bitwise and operator.
|
||||
*
|
||||
* @see DSL#bitAnd(Field, Field)
|
||||
*/
|
||||
@Support({ CUBRID, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES, SQLITE })
|
||||
Field<T> bitAnd(Field<T> value);
|
||||
|
||||
/**
|
||||
* The bitwise not and operator.
|
||||
*
|
||||
* @see DSL#bitNand(Field, Field)
|
||||
* @see DSL#bitNot(Field)
|
||||
*/
|
||||
@Support({ CUBRID, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES, SQLITE })
|
||||
Field<T> bitNand(T value);
|
||||
|
||||
/**
|
||||
* The bitwise not and operator.
|
||||
*
|
||||
* @see DSL#bitNand(Field, Field)
|
||||
* @see DSL#bitNot(Field)
|
||||
*/
|
||||
@Support({ CUBRID, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES, SQLITE })
|
||||
Field<T> bitNand(Field<T> value);
|
||||
|
||||
/**
|
||||
* The bitwise or operator.
|
||||
*
|
||||
* @see DSL#bitOr(Field, Field)
|
||||
*/
|
||||
@Support({ CUBRID, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES, SQLITE })
|
||||
Field<T> bitOr(T value);
|
||||
|
||||
/**
|
||||
* The bitwise or operator.
|
||||
*
|
||||
* @see DSL#bitOr(Field, Field)
|
||||
*/
|
||||
@Support({ CUBRID, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES, SQLITE })
|
||||
Field<T> bitOr(Field<T> value);
|
||||
|
||||
/**
|
||||
* The bitwise not or operator.
|
||||
*
|
||||
* @see DSL#bitNor(Field, Field)
|
||||
* @see DSL#bitNot(Field)
|
||||
*/
|
||||
@Support({ CUBRID, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES, SQLITE })
|
||||
Field<T> bitNor(T value);
|
||||
|
||||
/**
|
||||
* The bitwise not or operator.
|
||||
*
|
||||
* @see DSL#bitNor(Field, Field)
|
||||
* @see DSL#bitNot(Field)
|
||||
*/
|
||||
@Support({ CUBRID, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES, SQLITE })
|
||||
Field<T> bitNor(Field<T> value);
|
||||
|
||||
/**
|
||||
* The bitwise xor operator.
|
||||
*
|
||||
* @see DSL#bitXor(Field, Field)
|
||||
*/
|
||||
@Support({ CUBRID, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES, SQLITE })
|
||||
Field<T> bitXor(T value);
|
||||
|
||||
/**
|
||||
* The bitwise xor operator.
|
||||
*
|
||||
* @see DSL#bitXor(Field, Field)
|
||||
*/
|
||||
@Support({ CUBRID, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES, SQLITE })
|
||||
Field<T> bitXor(Field<T> value);
|
||||
|
||||
/**
|
||||
* The bitwise not xor operator.
|
||||
*
|
||||
* @see DSL#bitXNor(Field, Field)
|
||||
* @see DSL#bitNot(Field)
|
||||
*/
|
||||
@Support({ CUBRID, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES, SQLITE })
|
||||
Field<T> bitXNor(T value);
|
||||
|
||||
/**
|
||||
* The bitwise not xor operator.
|
||||
*
|
||||
* @see DSL#bitXNor(Field, Field)
|
||||
* @see DSL#bitNot(Field)
|
||||
*/
|
||||
@Support({ CUBRID, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES, SQLITE })
|
||||
Field<T> bitXNor(Field<T> value);
|
||||
|
||||
/**
|
||||
* The bitwise left shift operator.
|
||||
*
|
||||
* @see DSL#shl(Field, Field)
|
||||
* @see DSL#power(Field, Number)
|
||||
*/
|
||||
@Support({ CUBRID, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES, SQLITE })
|
||||
Field<T> shl(T value);
|
||||
|
||||
/**
|
||||
* The bitwise left shift operator.
|
||||
*
|
||||
* @see DSL#shl(Field, Field)
|
||||
* @see DSL#power(Field, Number)
|
||||
*/
|
||||
@Support({ CUBRID, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES, SQLITE })
|
||||
Field<T> shl(Field<T> value);
|
||||
|
||||
/**
|
||||
* The bitwise right shift operator.
|
||||
*
|
||||
* @see DSL#shr(Field, Field)
|
||||
* @see DSL#power(Field, Number)
|
||||
*/
|
||||
@Support({ CUBRID, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES, SQLITE })
|
||||
Field<T> shr(T value);
|
||||
|
||||
/**
|
||||
* The bitwise right shift operator.
|
||||
*
|
||||
* @see DSL#shr(Field, Field)
|
||||
* @see DSL#power(Field, Number)
|
||||
*/
|
||||
@Support({ CUBRID, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES, SQLITE })
|
||||
Field<T> shr(Field<T> value);
|
||||
|
||||
// ------------------------------------------------------------------------
|
||||
// NULL predicates
|
||||
// ------------------------------------------------------------------------
|
||||
|
||||
@ -59,6 +59,7 @@ import static org.jooq.impl.DSL.falseCondition;
|
||||
import static org.jooq.impl.DSL.inline;
|
||||
import static org.jooq.impl.DSL.nullSafe;
|
||||
import static org.jooq.impl.DSL.trueCondition;
|
||||
import static org.jooq.impl.DSL.val;
|
||||
import static org.jooq.impl.ExpressionOperator.ADD;
|
||||
import static org.jooq.impl.ExpressionOperator.DIVIDE;
|
||||
import static org.jooq.impl.ExpressionOperator.MULTIPLY;
|
||||
@ -430,6 +431,114 @@ abstract class AbstractField<T> extends AbstractQueryPart implements Field<T> {
|
||||
return mod(value);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------
|
||||
// XXX: Bitwise operations
|
||||
// ------------------------------------------------------------------------
|
||||
// Unsafe casting is needed here, as bitwise operations only work on
|
||||
// numeric values...
|
||||
|
||||
@SuppressWarnings({ "unchecked", "rawtypes" })
|
||||
@Override
|
||||
public final Field<T> bitNot() {
|
||||
return DSL.bitNot((Field) this);
|
||||
}
|
||||
|
||||
@SuppressWarnings({ "unchecked", "rawtypes" })
|
||||
@Override
|
||||
public final Field<T> bitAnd(T value) {
|
||||
return DSL.bitAnd((Field) this, (Field) val(value, this));
|
||||
}
|
||||
|
||||
@SuppressWarnings({ "unchecked", "rawtypes" })
|
||||
@Override
|
||||
public final Field<T> bitAnd(Field<T> value) {
|
||||
return DSL.bitAnd((Field) this, (Field) value);
|
||||
}
|
||||
|
||||
@SuppressWarnings({ "unchecked", "rawtypes" })
|
||||
@Override
|
||||
public final Field<T> bitNand(T value) {
|
||||
return DSL.bitNand((Field) this, (Field) val(value, this));
|
||||
}
|
||||
|
||||
@SuppressWarnings({ "unchecked", "rawtypes" })
|
||||
@Override
|
||||
public final Field<T> bitNand(Field<T> value) {
|
||||
return DSL.bitNand((Field) this, (Field) value);
|
||||
}
|
||||
|
||||
@SuppressWarnings({ "unchecked", "rawtypes" })
|
||||
@Override
|
||||
public final Field<T> bitOr(T value) {
|
||||
return DSL.bitOr((Field) this, (Field) val(value, this));
|
||||
}
|
||||
|
||||
@SuppressWarnings({ "unchecked", "rawtypes" })
|
||||
@Override
|
||||
public final Field<T> bitOr(Field<T> value) {
|
||||
return DSL.bitOr((Field) this, (Field) value);
|
||||
}
|
||||
|
||||
@SuppressWarnings({ "unchecked", "rawtypes" })
|
||||
@Override
|
||||
public final Field<T> bitNor(T value) {
|
||||
return DSL.bitNor((Field) this, (Field) val(value, this));
|
||||
}
|
||||
|
||||
@SuppressWarnings({ "unchecked", "rawtypes" })
|
||||
@Override
|
||||
public final Field<T> bitNor(Field<T> value) {
|
||||
return DSL.bitNor((Field) this, (Field) value);
|
||||
}
|
||||
|
||||
@SuppressWarnings({ "unchecked", "rawtypes" })
|
||||
@Override
|
||||
public final Field<T> bitXor(T value) {
|
||||
return DSL.bitXor((Field) this, (Field) val(value, this));
|
||||
}
|
||||
|
||||
@SuppressWarnings({ "unchecked", "rawtypes" })
|
||||
@Override
|
||||
public final Field<T> bitXor(Field<T> value) {
|
||||
return DSL.bitXor((Field) this, (Field) value);
|
||||
}
|
||||
|
||||
@SuppressWarnings({ "unchecked", "rawtypes" })
|
||||
@Override
|
||||
public final Field<T> bitXNor(T value) {
|
||||
return DSL.bitXNor((Field) this, (Field) val(value, this));
|
||||
}
|
||||
|
||||
@SuppressWarnings({ "unchecked", "rawtypes" })
|
||||
@Override
|
||||
public final Field<T> bitXNor(Field<T> value) {
|
||||
return DSL.bitXNor((Field) this, (Field) value);
|
||||
}
|
||||
|
||||
@SuppressWarnings({ "unchecked", "rawtypes" })
|
||||
@Override
|
||||
public final Field<T> shl(T value) {
|
||||
return DSL.shl((Field) this, (Field) val(value, this));
|
||||
}
|
||||
|
||||
@SuppressWarnings({ "unchecked", "rawtypes" })
|
||||
@Override
|
||||
public final Field<T> shl(Field<T> value) {
|
||||
return DSL.shl((Field) this, (Field) value);
|
||||
}
|
||||
|
||||
@SuppressWarnings({ "unchecked", "rawtypes" })
|
||||
@Override
|
||||
public final Field<T> shr(T value) {
|
||||
return DSL.shr((Field) this, (Field) val(value, this));
|
||||
}
|
||||
|
||||
@SuppressWarnings({ "unchecked", "rawtypes" })
|
||||
@Override
|
||||
public final Field<T> shr(Field<T> value) {
|
||||
return DSL.shr((Field) this, (Field) value);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------
|
||||
// XXX: Conditions created from this field
|
||||
// ------------------------------------------------------------------------
|
||||
|
||||
@ -40,10 +40,8 @@
|
||||
*/
|
||||
package org.jooq.impl;
|
||||
|
||||
import static org.jooq.impl.DSL.bitAnd;
|
||||
import static org.jooq.impl.DSL.function;
|
||||
import static org.jooq.impl.DSL.inline;
|
||||
import static org.jooq.impl.DSL.shr;
|
||||
|
||||
import org.jooq.Configuration;
|
||||
import org.jooq.Field;
|
||||
@ -79,144 +77,144 @@ class BitCount extends AbstractFunction<Integer> {
|
||||
Field<Byte> f = (Field<Byte>) field;
|
||||
|
||||
byte i = 0;
|
||||
return bitAnd(f, inline((byte) 0x01)).add(
|
||||
shr(bitAnd(f, inline((byte) 0x02)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline((byte) 0x04)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline((byte) 0x08)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline((byte) 0x10)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline((byte) 0x20)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline((byte) 0x40)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline((byte) 0x80)), inline(++i))).cast(Integer.class);
|
||||
return DSL.bitAnd(f, inline((byte) 0x01)).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline((byte) 0x02)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline((byte) 0x04)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline((byte) 0x08)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline((byte) 0x10)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline((byte) 0x20)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline((byte) 0x40)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline((byte) 0x80)), inline(++i))).cast(Integer.class);
|
||||
}
|
||||
else if (field.getType() == Short.class) {
|
||||
@SuppressWarnings("unchecked")
|
||||
Field<Short> f = (Field<Short>) field;
|
||||
|
||||
short i = 0;
|
||||
return bitAnd(f, inline((short) 0x0001)).add(
|
||||
shr(bitAnd(f, inline((short) 0x0002)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline((short) 0x0004)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline((short) 0x0008)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline((short) 0x0010)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline((short) 0x0020)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline((short) 0x0040)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline((short) 0x0080)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline((short) 0x0100)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline((short) 0x0200)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline((short) 0x0400)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline((short) 0x0800)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline((short) 0x1000)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline((short) 0x2000)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline((short) 0x4000)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline((short) 0x8000)), inline(++i))).cast(Integer.class);
|
||||
return DSL.bitAnd(f, inline((short) 0x0001)).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline((short) 0x0002)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline((short) 0x0004)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline((short) 0x0008)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline((short) 0x0010)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline((short) 0x0020)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline((short) 0x0040)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline((short) 0x0080)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline((short) 0x0100)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline((short) 0x0200)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline((short) 0x0400)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline((short) 0x0800)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline((short) 0x1000)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline((short) 0x2000)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline((short) 0x4000)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline((short) 0x8000)), inline(++i))).cast(Integer.class);
|
||||
}
|
||||
else if (field.getType() == Integer.class) {
|
||||
@SuppressWarnings("unchecked")
|
||||
Field<Integer> f = (Field<Integer>) field;
|
||||
|
||||
int i = 0;
|
||||
return bitAnd(f, inline(0x00000001)).add(
|
||||
shr(bitAnd(f, inline(0x00000002)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x00000004)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x00000008)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x00000010)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x00000020)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x00000040)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x00000080)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x00000100)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x00000200)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x00000400)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x00000800)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x00001000)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x00002000)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x00004000)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x00008000)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x00010000)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x00020000)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x00040000)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x00080000)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x00100000)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x00200000)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x00400000)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x00800000)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x01000000)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x02000000)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x04000000)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x08000000)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x10000000)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x20000000)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x40000000)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x80000000)), inline(++i)));
|
||||
return DSL.bitAnd(f, inline(0x00000001)).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x00000002)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x00000004)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x00000008)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x00000010)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x00000020)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x00000040)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x00000080)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x00000100)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x00000200)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x00000400)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x00000800)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x00001000)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x00002000)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x00004000)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x00008000)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x00010000)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x00020000)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x00040000)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x00080000)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x00100000)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x00200000)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x00400000)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x00800000)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x01000000)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x02000000)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x04000000)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x08000000)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x10000000)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x20000000)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x40000000)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x80000000)), inline(++i)));
|
||||
}
|
||||
else if (field.getType() == Long.class) {
|
||||
@SuppressWarnings("unchecked")
|
||||
Field<Long> f = (Field<Long>) field;
|
||||
|
||||
long i = 0;
|
||||
return bitAnd(f, inline(0x0000000000000001L)).add(
|
||||
shr(bitAnd(f, inline(0x0000000000000002L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000000000000004L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000000000000008L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000000000000010L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000000000000020L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000000000000040L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000000000000080L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000000000000100L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000000000000200L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000000000000400L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000000000000800L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000000000001000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000000000002000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000000000004000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000000000008000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000000000010000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000000000020000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000000000040000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000000000080000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000000000100000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000000000200000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000000000400000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000000000800000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000000001000000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000000002000000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000000004000000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000000008000000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000000010000000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000000020000000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000000040000000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000000080000000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000000100000000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000000200000000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000000400000000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000000800000000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000001000000000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000002000000000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000004000000000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000008000000000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000010000000000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000020000000000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000040000000000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000080000000000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000100000000000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000200000000000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000400000000000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0000800000000000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0001000000000000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0002000000000000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0004000000000000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0008000000000000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0010000000000000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0020000000000000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0040000000000000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0080000000000000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0100000000000000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0200000000000000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0400000000000000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x0800000000000000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x1000000000000000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x2000000000000000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x4000000000000000L)), inline(++i))).add(
|
||||
shr(bitAnd(f, inline(0x8000000000000000L)), inline(++i))).cast(Integer.class);
|
||||
return DSL.bitAnd(f, inline(0x0000000000000001L)).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000000000000002L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000000000000004L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000000000000008L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000000000000010L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000000000000020L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000000000000040L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000000000000080L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000000000000100L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000000000000200L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000000000000400L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000000000000800L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000000000001000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000000000002000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000000000004000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000000000008000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000000000010000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000000000020000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000000000040000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000000000080000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000000000100000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000000000200000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000000000400000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000000000800000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000000001000000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000000002000000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000000004000000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000000008000000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000000010000000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000000020000000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000000040000000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000000080000000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000000100000000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000000200000000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000000400000000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000000800000000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000001000000000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000002000000000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000004000000000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000008000000000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000010000000000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000020000000000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000040000000000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000080000000000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000100000000000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000200000000000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000400000000000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0000800000000000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0001000000000000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0002000000000000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0004000000000000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0008000000000000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0010000000000000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0020000000000000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0040000000000000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0080000000000000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0100000000000000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0200000000000000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0400000000000000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x0800000000000000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x1000000000000000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x2000000000000000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x4000000000000000L)), inline(++i))).add(
|
||||
DSL.shr(DSL.bitAnd(f, inline(0x8000000000000000L)), inline(++i))).cast(Integer.class);
|
||||
}
|
||||
else {
|
||||
// Currently not supported
|
||||
|
||||
@ -53,10 +53,6 @@ import static org.jooq.SQLDialect.POSTGRES;
|
||||
import static org.jooq.SQLDialect.SQLITE;
|
||||
// ...
|
||||
// ...
|
||||
import static org.jooq.impl.DSL.bitAnd;
|
||||
import static org.jooq.impl.DSL.bitNot;
|
||||
import static org.jooq.impl.DSL.bitOr;
|
||||
import static org.jooq.impl.DSL.bitXor;
|
||||
import static org.jooq.impl.DSL.field;
|
||||
import static org.jooq.impl.DSL.function;
|
||||
import static org.jooq.impl.DSL.inline;
|
||||
@ -159,15 +155,15 @@ class Expression<T> extends AbstractFunction<T> {
|
||||
/* [pro] xx
|
||||
xx xxxxxx xxx xx xxxxxxxx xxxxxx
|
||||
xxxx xx xxxxxxx xx xxxxxxxx xx xxxxxx xx xxxxxxx x
|
||||
xxxxxx xxxxxxxxxxxxxxxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
|
||||
xxxxxx xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
|
||||
x
|
||||
|
||||
xx [/pro] */
|
||||
// ~(a & b) & (a | b)
|
||||
else if (BIT_XOR == operator && asList(SQLITE).contains(family)) {
|
||||
return (Field<T>) bitAnd(
|
||||
bitNot(bitAnd(lhsAsNumber(), rhsAsNumber())),
|
||||
bitOr(lhsAsNumber(), rhsAsNumber()));
|
||||
return (Field<T>) DSL.bitAnd(
|
||||
DSL.bitNot(DSL.bitAnd(lhsAsNumber(), rhsAsNumber())),
|
||||
DSL.bitOr(lhsAsNumber(), rhsAsNumber()));
|
||||
}
|
||||
|
||||
// Many dialects don't support shifts. Use multiplication/division instead
|
||||
@ -188,13 +184,13 @@ class Expression<T> extends AbstractFunction<T> {
|
||||
|
||||
// These operators are not supported in any dialect
|
||||
else if (BIT_NAND == operator) {
|
||||
return (Field<T>) bitNot(bitAnd(lhsAsNumber(), rhsAsNumber()));
|
||||
return (Field<T>) DSL.bitNot(DSL.bitAnd(lhsAsNumber(), rhsAsNumber()));
|
||||
}
|
||||
else if (BIT_NOR == operator) {
|
||||
return (Field<T>) bitNot(bitOr(lhsAsNumber(), rhsAsNumber()));
|
||||
return (Field<T>) DSL.bitNot(DSL.bitOr(lhsAsNumber(), rhsAsNumber()));
|
||||
}
|
||||
else if (BIT_XNOR == operator) {
|
||||
return (Field<T>) bitNot(bitXor(lhsAsNumber(), rhsAsNumber()));
|
||||
return (Field<T>) DSL.bitNot(DSL.bitXor(lhsAsNumber(), rhsAsNumber()));
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------
|
||||
|
||||
Loading…
Reference in New Issue
Block a user