diff --git a/jOOQ/src/main/java/org/jooq/Field.java b/jOOQ/src/main/java/org/jooq/Field.java
index 5a3b64d9c6..07ba197986 100644
--- a/jOOQ/src/main/java/org/jooq/Field.java
+++ b/jOOQ/src/main/java/org/jooq/Field.java
@@ -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
     // ------------------------------------------------------------------------
diff --git a/jOOQ/src/main/java/org/jooq/impl/AbstractField.java b/jOOQ/src/main/java/org/jooq/impl/AbstractField.java
index af46036b88..b5e02ffd95 100644
--- a/jOOQ/src/main/java/org/jooq/impl/AbstractField.java
+++ b/jOOQ/src/main/java/org/jooq/impl/AbstractField.java
@@ -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
     // ------------------------------------------------------------------------
diff --git a/jOOQ/src/main/java/org/jooq/impl/BitCount.java b/jOOQ/src/main/java/org/jooq/impl/BitCount.java
index 4a44ffca16..1bd8f65903 100644
--- a/jOOQ/src/main/java/org/jooq/impl/BitCount.java
+++ b/jOOQ/src/main/java/org/jooq/impl/BitCount.java
@@ -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
diff --git a/jOOQ/src/main/java/org/jooq/impl/Expression.java b/jOOQ/src/main/java/org/jooq/impl/Expression.java
index 63347b26b9..0e87348898 100644
--- a/jOOQ/src/main/java/org/jooq/impl/Expression.java
+++ b/jOOQ/src/main/java/org/jooq/impl/Expression.java
@@ -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()));
         }
 
         // ---------------------------------------------------------------------