ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From se...@apache.org
Subject [1/4] incubator-ignite git commit: ignite-959-x - wip
Date Wed, 01 Jul 2015 19:52:43 GMT
Repository: incubator-ignite
Updated Branches:
  refs/heads/ignite-959-x [created] 7df4f8cb0


ignite-959-x - wip


Project: http://git-wip-us.apache.org/repos/asf/incubator-ignite/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-ignite/commit/781f0d5f
Tree: http://git-wip-us.apache.org/repos/asf/incubator-ignite/tree/781f0d5f
Diff: http://git-wip-us.apache.org/repos/asf/incubator-ignite/diff/781f0d5f

Branch: refs/heads/ignite-959-x
Commit: 781f0d5ff32ea034d67260469a595cdb64048655
Parents: 285d790
Author: S.Vladykin <svladykin@gridgain.com>
Authored: Thu Jun 25 12:46:25 2015 +0300
Committer: S.Vladykin <svladykin@gridgain.com>
Committed: Thu Jun 25 12:46:25 2015 +0300

----------------------------------------------------------------------
 .../configuration/CacheConfiguration.java       | 602 ++++++++++++++++++-
 .../processors/query/GridQueryProcessor.java    |  44 ++
 .../processors/query/h2/IgniteH2Indexing.java   |   2 -
 3 files changed, 632 insertions(+), 16 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/781f0d5f/modules/core/src/main/java/org/apache/ignite/configuration/CacheConfiguration.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/configuration/CacheConfiguration.java
b/modules/core/src/main/java/org/apache/ignite/configuration/CacheConfiguration.java
index 7af4974..50ba040 100644
--- a/modules/core/src/main/java/org/apache/ignite/configuration/CacheConfiguration.java
+++ b/modules/core/src/main/java/org/apache/ignite/configuration/CacheConfiguration.java
@@ -25,6 +25,9 @@ import org.apache.ignite.cache.eviction.*;
 import org.apache.ignite.cache.query.annotations.*;
 import org.apache.ignite.cache.store.*;
 import org.apache.ignite.cluster.*;
+import org.apache.ignite.internal.processors.query.*;
+import org.apache.ignite.internal.util.tostring.*;
+import org.apache.ignite.internal.util.typedef.*;
 import org.apache.ignite.internal.util.typedef.internal.*;
 import org.apache.ignite.lang.*;
 import org.apache.ignite.plugin.*;
@@ -33,8 +36,11 @@ import org.jetbrains.annotations.*;
 import javax.cache.*;
 import javax.cache.configuration.*;
 import javax.cache.expiry.*;
+import java.lang.reflect.*;
 import java.util.*;
 
+import static org.apache.ignite.internal.processors.query.GridQueryIndexType.*;
+
 /**
  * This class defines grid cache configuration. This configuration is passed to
  * grid via {@link IgniteConfiguration#getCacheConfiguration()} method. It defines all configuration
@@ -298,7 +304,7 @@ public class CacheConfiguration<K, V> extends MutableConfiguration<K,
V> {
     private boolean sqlEscapeAll;
 
     /** */
-    private Class<?>[] indexedTypes;
+    private transient Class<?>[] indexedTypes;
 
     /** */
     private int sqlOnheapRowCacheSize = DFLT_SQL_ONHEAP_ROW_CACHE_SIZE;
@@ -1506,7 +1512,12 @@ public class CacheConfiguration<K, V> extends MutableConfiguration<K,
V> {
      * @return {@code this} for chaining.
      */
     public CacheConfiguration setTypeMetadata(Collection<CacheTypeMetadata> typeMeta)
{
-        this.typeMeta = typeMeta;
+        if (this.typeMeta == null)
+            this.typeMeta = new ArrayList<>(typeMeta);
+        else if (indexedTypes != null)
+            this.typeMeta.addAll(typeMeta);
+        else
+            throw new CacheException("Type metadata can be set only once.");
 
         return this;
     }
@@ -1661,21 +1672,31 @@ public class CacheConfiguration<K, V> extends MutableConfiguration<K,
V> {
      * @return {@code this} for chaining.
      */
     public CacheConfiguration setIndexedTypes(Class<?>... indexedTypes) {
-        A.ensure(indexedTypes == null || (indexedTypes.length & 1) == 0,
+        int len = indexedTypes.length;
+
+        A.ensure(len > 0, "Array of indexed types can not be empty.");
+        A.ensure((len & 1) == 0,
             "Number of indexed types is expected to be even. Refer to method javadoc for
details.");
 
-        if (indexedTypes != null) {
-            int len = indexedTypes.length;
+        if (this.indexedTypes != null)
+            throw new CacheException("Indexed types can be set only once.");
+
+        Class<?>[] newIndexedTypes = new Class<?>[len];
 
-            Class<?>[] newIndexedTypes = new Class<?>[len];
+        for (int i = 0; i < len; i++)
+            newIndexedTypes[i] = U.box(indexedTypes[i]);
 
-            for (int i = 0; i < len; i++)
-                newIndexedTypes[i] = U.box(indexedTypes[i]);
+        if (typeMeta == null)
+            typeMeta = new ArrayList<>();
 
-            this.indexedTypes = newIndexedTypes;
+        for (int i = 0; i < len; i += 2) {
+            Class<?> keyCls = newIndexedTypes[i];
+            Class<?> valCls = newIndexedTypes[i + 1];
+
+            TypeDescriptor desc = processKeyAndValueClasses(keyCls, valCls);
+
+            typeMeta.add(convert(desc));
         }
-        else
-            this.indexedTypes = null;
 
         return this;
     }
@@ -1773,6 +1794,165 @@ public class CacheConfiguration<K, V> extends MutableConfiguration<K,
V> {
         return this;
     }
 
+    /**
+     * @param desc Type descriptor.
+     * @return Type metadata.
+     */
+    private CacheTypeMetadata convert(TypeDescriptor desc) {
+        CacheTypeMetadata meta = new CacheTypeMetadata();
+
+        // TODO
+
+        return meta;
+    }
+
+    /**
+     * @param keyCls Key class.
+     * @param valCls Value class.
+     * @return Type descriptor.
+     */
+    private static TypeDescriptor processKeyAndValueClasses(
+        Class<?> keyCls,
+        Class<?> valCls
+    ) {
+        TypeDescriptor d = new TypeDescriptor();
+
+        d.keyClass(keyCls);
+        d.valueClass(valCls);
+
+        processAnnotationsInClass(true, d.keyCls, d, null);
+
+        String valTypeName = GridQueryProcessor.typeName(valCls);
+
+        d.name(valTypeName);
+
+        processAnnotationsInClass(false, d.valCls, d, null);
+
+        return d;
+    }
+
+    /**
+     * Process annotations for class.
+     *
+     * @param key If given class relates to key.
+     * @param cls Class.
+     * @param type Type descriptor.
+     * @param parent Parent in case of embeddable.
+     */
+    private static void processAnnotationsInClass(boolean key, Class<?> cls, TypeDescriptor
type,
+        @Nullable ClassProperty parent) {
+        if (U.isJdk(cls) || GridQueryProcessor.isGeometryClass(cls)) {
+            if (parent == null && !key && GridQueryProcessor.isSqlType(cls)
) { // We have to index primitive _val.
+                String idxName = "_val_idx";
+
+                type.addIndex(idxName, GridQueryProcessor.isGeometryClass(cls) ? GEO_SPATIAL
: SORTED);
+
+                type.addFieldToIndex(idxName, "_VAL", 0, false);
+            }
+
+            return;
+        }
+
+        if (parent != null && parent.knowsClass(cls))
+            throw new CacheException("Recursive reference found in type: " + cls.getName());
+
+        if (parent == null) { // Check class annotation at top level only.
+            QueryTextField txtAnnCls = cls.getAnnotation(QueryTextField.class);
+
+            if (txtAnnCls != null)
+                type.valueTextIndex(true);
+
+            QueryGroupIndex grpIdx = cls.getAnnotation(QueryGroupIndex.class);
+
+            if (grpIdx != null)
+                type.addIndex(grpIdx.name(), SORTED);
+
+            QueryGroupIndex.List grpIdxList = cls.getAnnotation(QueryGroupIndex.List.class);
+
+            if (grpIdxList != null && !F.isEmpty(grpIdxList.value())) {
+                for (QueryGroupIndex idx : grpIdxList.value())
+                    type.addIndex(idx.name(), SORTED);
+            }
+        }
+
+        for (Class<?> c = cls; c != null && !c.equals(Object.class); c = c.getSuperclass())
{
+            for (Field field : c.getDeclaredFields()) {
+                QuerySqlField sqlAnn = field.getAnnotation(QuerySqlField.class);
+                QueryTextField txtAnn = field.getAnnotation(QueryTextField.class);
+
+                if (sqlAnn != null || txtAnn != null) {
+                    ClassProperty prop = new ClassProperty(field, key);
+
+                    prop.parent(parent);
+
+                    processAnnotation(key, sqlAnn, txtAnn, field.getType(), prop, type);
+
+                    type.addProperty(prop, true);
+                }
+            }
+
+            for (Method mtd : c.getDeclaredMethods()) {
+                QuerySqlField sqlAnn = mtd.getAnnotation(QuerySqlField.class);
+                QueryTextField txtAnn = mtd.getAnnotation(QueryTextField.class);
+
+                if (sqlAnn != null || txtAnn != null) {
+                    if (mtd.getParameterTypes().length != 0)
+                        throw new CacheException("Getter with QuerySqlField " +
+                            "annotation cannot have parameters: " + mtd);
+
+                    ClassProperty prop = new ClassProperty(mtd, key);
+
+                    prop.parent(parent);
+
+                    processAnnotation(key, sqlAnn, txtAnn, mtd.getReturnType(), prop, type);
+
+                    type.addProperty(prop, true);
+                }
+            }
+        }
+    }
+
+    /**
+     * Processes annotation at field or method.
+     *
+     * @param key If given class relates to key.
+     * @param sqlAnn SQL annotation, can be {@code null}.
+     * @param txtAnn H2 text annotation, can be {@code null}.
+     * @param cls Class of field or return type for method.
+     * @param prop Current property.
+     * @param desc Class description.
+     */
+    private static void processAnnotation(boolean key, QuerySqlField sqlAnn, QueryTextField
txtAnn,
+        Class<?> cls, ClassProperty prop, TypeDescriptor desc) {
+        if (sqlAnn != null) {
+            processAnnotationsInClass(key, cls, desc, prop);
+
+            if (!sqlAnn.name().isEmpty())
+                prop.name(sqlAnn.name());
+
+            if (sqlAnn.index()) {
+                String idxName = prop.name() + "_idx";
+
+                desc.addIndex(idxName, GridQueryProcessor.isGeometryClass(prop.type()) ?
GEO_SPATIAL : SORTED);
+
+                desc.addFieldToIndex(idxName, prop.name(), 0, sqlAnn.descending());
+            }
+
+            if (!F.isEmpty(sqlAnn.groups())) {
+                for (String group : sqlAnn.groups())
+                    desc.addFieldToIndex(group, prop.name(), 0, false);
+            }
+
+            if (!F.isEmpty(sqlAnn.orderedGroups())) {
+                for (QuerySqlField.Group idx : sqlAnn.orderedGroups())
+                    desc.addFieldToIndex(idx.name(), prop.name(), idx.order(), idx.descending());
+            }
+        }
+
+        if (txtAnn != null)
+            desc.addFieldToTextIndex(prop.name());
+    }
+
     /** {@inheritDoc} */
     @Override public String toString() {
         return S.toString(CacheConfiguration.class, this);
@@ -1792,10 +1972,404 @@ public class CacheConfiguration<K, V> extends MutableConfiguration<K,
V> {
 
         /** {@inheritDoc} */
         @Override public boolean equals(Object obj) {
-            if (obj == null)
-                return false;
+            return obj != null && obj.getClass().equals(this.getClass());
+        }
+    }
+
+    /**
+     * Descriptor of type.
+     */
+    private static class TypeDescriptor implements GridQueryTypeDescriptor {
+        /** */
+        private String name;
+
+        /** Value field names and types with preserved order. */
+        @GridToStringInclude
+        private final Map<String, Class<?>> fields = new LinkedHashMap<>();
+
+        /** */
+        @GridToStringExclude
+        private final Map<String, Property> props = new HashMap<>();
+
+        /** */
+        @GridToStringInclude
+        private final Map<String, IndexDescriptor> indexes = new HashMap<>();
+
+        /** */
+        private IndexDescriptor fullTextIdx;
+
+        /** */
+        private Class<?> keyCls;
+
+        /** */
+        private Class<?> valCls;
+
+        /** */
+        private boolean valTextIdx;
+
+        /** SPI can decide not to register this type. */
+        private boolean registered;
+
+        /**
+         * @return {@code True} if type registration in SPI was finished and type was not
rejected.
+         */
+        boolean registered() {
+            return registered;
+        }
+
+        /**
+         * @param registered Sets registered flag.
+         */
+        void registered(boolean registered) {
+            this.registered = registered;
+        }
+
+        /** {@inheritDoc} */
+        @Override public String name() {
+            return name;
+        }
+
+        /**
+         * Sets type name.
+         *
+         * @param name Name.
+         */
+        void name(String name) {
+            this.name = name;
+        }
+
+        /** {@inheritDoc} */
+        @Override public Map<String, Class<?>> fields() {
+            return fields;
+        }
+
+        /** {@inheritDoc} */
+        @SuppressWarnings("unchecked")
+        @Override public <T> T value(String field, Object key, Object val) throws IgniteCheckedException
{
+            assert field != null;
+
+            Property prop = props.get(field);
+
+            if (prop == null)
+                throw new IgniteCheckedException("Failed to find field '" + field + "' in
type '" + name + "'.");
+
+            return (T)prop.value(key, val);
+        }
+
+        /** {@inheritDoc} */
+        @Override public Map<String, GridQueryIndexDescriptor> indexes() {
+            return Collections.<String, GridQueryIndexDescriptor>unmodifiableMap(indexes);
+        }
+
+        /**
+         * Adds index.
+         *
+         * @param idxName Index name.
+         * @param type Index type.
+         * @return Index descriptor.
+         */
+        public IndexDescriptor addIndex(String idxName, GridQueryIndexType type) {
+            IndexDescriptor idx = new IndexDescriptor(type);
+
+            if (indexes.put(idxName, idx) != null)
+                throw new CacheException("Index with name '" + idxName + "' already exists.");
+
+            return idx;
+        }
 
-            return obj.getClass().equals(this.getClass());
+        /**
+         * Adds field to index.
+         *
+         * @param idxName Index name.
+         * @param field Field name.
+         * @param orderNum Fields order number in index.
+         * @param descending Sorting order.
+         */
+        public void addFieldToIndex(String idxName, String field, int orderNum,
+            boolean descending) {
+            IndexDescriptor desc = indexes.get(idxName);
+
+            if (desc == null)
+                desc = addIndex(idxName, SORTED);
+
+            desc.addField(field, orderNum, descending);
+        }
+
+        /**
+         * Adds field to text index.
+         *
+         * @param field Field name.
+         */
+        public void addFieldToTextIndex(String field) {
+            if (fullTextIdx == null) {
+                fullTextIdx = new IndexDescriptor(FULLTEXT);
+
+                indexes.put(null, fullTextIdx);
+            }
+
+            fullTextIdx.addField(field, 0, false);
+        }
+
+        /** {@inheritDoc} */
+        @Override public Class<?> valueClass() {
+            return valCls;
+        }
+
+        /**
+         * Sets value class.
+         *
+         * @param valCls Value class.
+         */
+        void valueClass(Class<?> valCls) {
+            this.valCls = valCls;
+        }
+
+        /** {@inheritDoc} */
+        @Override public Class<?> keyClass() {
+            return keyCls;
+        }
+
+        /**
+         * Set key class.
+         *
+         * @param keyCls Key class.
+         */
+        void keyClass(Class<?> keyCls) {
+            this.keyCls = keyCls;
+        }
+
+        /**
+         * Adds property to the type descriptor.
+         *
+         * @param prop Property.
+         * @param failOnDuplicate Fail on duplicate flag.
+         */
+        public void addProperty(Property prop, boolean failOnDuplicate) {
+            String name = prop.name();
+
+            if (props.put(name, prop) != null && failOnDuplicate)
+                throw new CacheException("Property with name '" + name + "' already exists.");
+
+            fields.put(name, prop.type());
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean valueTextIndex() {
+            return valTextIdx;
+        }
+
+        /**
+         * Sets if this value should be text indexed.
+         *
+         * @param valTextIdx Flag value.
+         */
+        public void valueTextIndex(boolean valTextIdx) {
+            this.valTextIdx = valTextIdx;
+        }
+
+        /** {@inheritDoc} */
+        @Override public String toString() {
+            return S.toString(TypeDescriptor.class, this);
+        }
+    }
+
+    /**
+     * Index descriptor.
+     */
+    private static class IndexDescriptor implements GridQueryIndexDescriptor {
+        /** Fields sorted by order number. */
+        private final Collection<T2<String, Integer>> fields = new TreeSet<>(
+            new Comparator<T2<String, Integer>>() {
+                @Override public int compare(T2<String, Integer> o1, T2<String,
Integer> o2) {
+                    if (o1.get2().equals(o2.get2())) // Order is equal, compare field names
to avoid replace in Set.
+                        return o1.get1().compareTo(o2.get1());
+
+                    return o1.get2() < o2.get2() ? -1 : 1;
+                }
+            });
+
+        /** Fields which should be indexed in descending order. */
+        private Collection<String> descendings;
+
+        /** */
+        private final GridQueryIndexType type;
+
+        /**
+         * @param type Type.
+         */
+        private IndexDescriptor(GridQueryIndexType type) {
+            assert type != null;
+
+            this.type = type;
+        }
+
+        /** {@inheritDoc} */
+        @Override public Collection<String> fields() {
+            Collection<String> res = new ArrayList<>(fields.size());
+
+            for (T2<String, Integer> t : fields)
+                res.add(t.get1());
+
+            return res;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean descending(String field) {
+            return descendings != null && descendings.contains(field);
+        }
+
+        /**
+         * Adds field to this index.
+         *
+         * @param field Field name.
+         * @param orderNum Field order number in this index.
+         * @param descending Sort order.
+         */
+        public void addField(String field, int orderNum, boolean descending) {
+            fields.add(new T2<>(field, orderNum));
+
+            if (descending) {
+                if (descendings == null)
+                    descendings  = new HashSet<>();
+
+                descendings.add(field);
+            }
+        }
+
+        /** {@inheritDoc} */
+        @Override public GridQueryIndexType type() {
+            return type;
+        }
+
+        /** {@inheritDoc} */
+        @Override public String toString() {
+            return S.toString(IndexDescriptor.class, this);
+        }
+    }
+
+    /**
+     *
+     */
+    private abstract static class Property {
+        /**
+         * Gets this property value from the given object.
+         *
+         * @param key Key.
+         * @param val Value.
+         * @return Property value.
+         * @throws IgniteCheckedException If failed.
+         */
+        public abstract Object value(Object key, Object val) throws IgniteCheckedException;
+
+        /**
+         * @return Property name.
+         */
+        public abstract String name();
+
+        /**
+         * @return Class member type.
+         */
+        public abstract Class<?> type();
+    }
+
+    /**
+     * Description of type property.
+     */
+    private static class ClassProperty extends Property {
+        /** */
+        private final Member member;
+
+        /** */
+        private ClassProperty parent;
+
+        /** */
+        private String name;
+
+        /** */
+        private boolean field;
+
+        /** */
+        private boolean key;
+
+        /**
+         * Constructor.
+         *
+         * @param member Element.
+         */
+        ClassProperty(Member member, boolean key) {
+            this.member = member;
+            this.key = key;
+
+            name = member instanceof Method && member.getName().startsWith("get")
&& member.getName().length() > 3 ?
+                member.getName().substring(3) : member.getName();
+
+            ((AccessibleObject) member).setAccessible(true);
+
+            field = member instanceof Field;
+        }
+
+        /** {@inheritDoc} */
+        @Override public Object value(Object key, Object val) throws IgniteCheckedException
{
+            Object x = this.key ? key : val;
+
+            if (parent != null)
+                x = parent.value(key, val);
+
+            if (x == null)
+                return null;
+
+            try {
+                if (field) {
+                    Field field = (Field)member;
+
+                    return field.get(x);
+                }
+                else {
+                    Method mtd = (Method)member;
+
+                    return mtd.invoke(x);
+                }
+            }
+            catch (Exception e) {
+                throw new IgniteCheckedException(e);
+            }
+        }
+
+        /**
+         * @param name Property name.
+         */
+        public void name(String name) {
+            this.name = name;
+        }
+
+        /** {@inheritDoc} */
+        @Override public String name() {
+            return name;
+        }
+
+        /** {@inheritDoc} */
+        @Override public Class<?> type() {
+            return member instanceof Field ? ((Field)member).getType() : ((Method)member).getReturnType();
+        }
+
+        /**
+         * @param parent Parent property if this is embeddable element.
+         */
+        public void parent(ClassProperty parent) {
+            this.parent = parent;
+        }
+
+        /** {@inheritDoc} */
+        @Override public String toString() {
+            return S.toString(ClassProperty.class, this);
+        }
+
+        /**
+         * @param cls Class.
+         * @return {@code true} If this property or some parent relates to member of the
given class.
+         */
+        public boolean knowsClass(Class<?> cls) {
+            return member.getDeclaringClass() == cls || (parent != null && parent.knowsClass(cls));
         }
     }
 }

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/781f0d5f/modules/core/src/main/java/org/apache/ignite/internal/processors/query/GridQueryProcessor.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/query/GridQueryProcessor.java
b/modules/core/src/main/java/org/apache/ignite/internal/processors/query/GridQueryProcessor.java
index e080c6d..f6cff33 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/query/GridQueryProcessor.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/query/GridQueryProcessor.java
@@ -41,6 +41,8 @@ import org.jsr166.*;
 
 import javax.cache.*;
 import java.lang.reflect.*;
+import java.math.*;
+import java.sql.*;
 import java.util.*;
 import java.util.concurrent.*;
 
@@ -52,6 +54,28 @@ import static org.apache.ignite.internal.processors.query.GridQueryIndexType.*;
  * Indexing processor.
  */
 public class GridQueryProcessor extends GridProcessorAdapter {
+    /** */
+    private static final Class<?> GEOMETRY_CLASS = U.classForName("com.vividsolutions.jts.geom.Geometry",
null);
+
+    /** */
+    private static Set<Class<?>> SQL_TYPES = new HashSet<>(F.<Class<?>>asList(
+        Integer.class,
+        Boolean.class,
+        Byte.class,
+        Short.class,
+        Long.class,
+        BigDecimal.class,
+        Double.class,
+        Float.class,
+        Time.class,
+        Timestamp.class,
+        java.util.Date.class,
+        java.sql.Date.class,
+        String.class,
+        UUID.class,
+        byte[].class
+    ));
+
     /** For tests. */
     public static Class<? extends GridQueryIndexing> idxCls;
 
@@ -801,6 +825,26 @@ public class GridQueryProcessor extends GridProcessorAdapter {
     }
 
     /**
+     * Checks if the given class can be mapped to a simple SQL type.
+     *
+     * @param cls Class.
+     * @return {@code true} If can.
+     */
+    public static boolean isSqlType(Class<?> cls) {
+        return SQL_TYPES.contains(cls);
+    }
+
+    /**
+     * Checks if the given class is GEOMETRY.
+     *
+     * @param cls Class.
+     * @return {@code true} If this is geometry.
+     */
+    public static boolean isGeometryClass(Class<?> cls) {
+        return GEOMETRY_CLASS != null && GEOMETRY_CLASS.isAssignableFrom(cls);
+    }
+
+    /**
      * Gets type name by class.
      *
      * @param cls Class.

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/781f0d5f/modules/indexing/src/main/java/org/apache/ignite/internal/processors/query/h2/IgniteH2Indexing.java
----------------------------------------------------------------------
diff --git a/modules/indexing/src/main/java/org/apache/ignite/internal/processors/query/h2/IgniteH2Indexing.java
b/modules/indexing/src/main/java/org/apache/ignite/internal/processors/query/h2/IgniteH2Indexing.java
index 06c0961..359341a 100644
--- a/modules/indexing/src/main/java/org/apache/ignite/internal/processors/query/h2/IgniteH2Indexing.java
+++ b/modules/indexing/src/main/java/org/apache/ignite/internal/processors/query/h2/IgniteH2Indexing.java
@@ -1584,8 +1584,6 @@ public class IgniteH2Indexing implements GridQueryIndexing {
             map.put(Timestamp.class, TIMESTAMP);
             map.put(java.util.Date.class, TIMESTAMP);
             map.put(java.sql.Date.class, DATE);
-            map.put(char.class, CHAR);
-            map.put(Character.class, CHAR);
             map.put(String.class, VARCHAR);
             map.put(UUID.class, UUID);
             map.put(byte[].class, BINARY);


Mime
View raw message