Невозможно запросить кэш по ключу схожести при использовании пользовательского шаблона кеша - PullRequest
Новая
       18

Невозможно запросить кэш по ключу схожести при использовании пользовательского шаблона кеша

0 голосов
/ 18 октября 2018

Я заметил, что когда я запрашиваю кеш, который был создан с помощью пользовательского шаблона кеша и включаю ключ сродства кеша в предложении WHERE, результаты не возвращаются.

Я использую Ignite 2.5 со следующей конфигурацией: 

<beans xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="
   http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="grid.cfg" class="org.apache.ignite.configuration.IgniteConfiguration">
  <property name="cacheConfiguration"> 
    <list> 
      <bean id="cache-template-bean" abstract="true" class="org.apache.ignite.configuration.CacheConfiguration"> 
          <property name="name" value="myCacheTemplate*"/> 
          <property name="cacheMode" value="PARTITIONED" /> 
      </bean> 
    </list> 
  </property> 
</bean>

А вот мой тестовый код.Код создает 3 кэша.Первый - это «корневой» кэш, который определяет колокейшн для остальных.Два других кеша расположены в ключе root.Первый colocated кеш (colocated_default) использует шаблон PARTITIONED и работает как положено.Второй (colocated_custom) использует «myCacheTemplate», созданный в вышеупомянутой конфигурации.Я вставляю одну запись кэша в каждый кэш, где записи в совместном кэше имеют ключ сродства, равный ключу записи корневого кэша.

Затем я запрашиваю кэш.Сначала я запускаю запрос, чтобы убедиться, что в каждом кэше есть одна запись.Затем я запускаю запрос для каждого ключа, ГДЕ ключ сродства равен ключу схожести вставленной записи.Результаты для меня показывают, что я могу выбирать по схожести из обоих кэшей PARTITIONED, но не получаю результатов для кэша colocated_custom.Вот код: 

/**
 * Test which shows that creating a cache with a custom cache configuration template doesn't allow
 * for SQL queries to use an affinity key in the WHERE clause.
 */
public class App {

   public static void main(String[] args) {
      // Start Ignite.
      Ignition.setClientMode(true);
      final Ignite ignite = Ignition.start(new IgniteConfiguration());

      // Create caches. Create a root entity, and two entities which are colocated by the root's ID.
      // One uses the custom cache template and one just uses the PARTITIONED template.
      final List<StringBuilder> createTableStringBuilders = new ArrayList<>();

      final StringBuilder createRoot = new StringBuilder();
      createRoot.append("CREATE TABLE IF NOT EXISTS root (\n");
      createRoot.append("  \"key\" VARCHAR(24) NOT NULL,\n");
      createRoot.append("  \"data\" VARCHAR(100),\n");
      createRoot.append("  PRIMARY KEY(\"key\"))\n");
      createRoot.append(
         "WITH \"template=PARTITIONED, affinity_key=key, cache_name=root, value_type=root\";");
      createTableStringBuilders.add(createRoot);

      final StringBuilder createColocatedDefault = new StringBuilder();
      createColocatedDefault.append("CREATE TABLE IF NOT EXISTS colocated_default (\n");
      createColocatedDefault.append("  \"root_key\" VARCHAR(24) NOT NULL,\n");
      createColocatedDefault.append("  \"key\" VARCHAR(24) NOT NULL,\n");
      createColocatedDefault.append("  \"data\" VARCHAR(100),\n");
      createColocatedDefault.append("  PRIMARY KEY(\"root_key\", \"key\"))\n");
      createColocatedDefault.append(
         "WITH \"template=PARTITIONED, affinity_key=root_key, cache_name=colocated_default, key_type=colocated_default_key, value_type=colocated_default\";");
      createTableStringBuilders.add(createColocatedDefault);

      final StringBuilder createColocatedCustom = new StringBuilder();
      createColocatedCustom.append("CREATE TABLE IF NOT EXISTS colocated_custom (\n");
      createColocatedCustom.append("  \"root_key\" VARCHAR(24) NOT NULL,\n");
      createColocatedCustom.append("  \"key\" VARCHAR(24) NOT NULL,\n");
      createColocatedCustom.append("  \"data\" VARCHAR(100),\n");
      createColocatedCustom.append("  PRIMARY KEY(\"root_key\", \"key\"))\n");
      createColocatedCustom.append(
         "WITH \"template=myCacheTemplate, affinity_key=root_key, cache_name=colocated_custom, key_type=colocated_custom_key, value_type=colocated_custom\";");
      createTableStringBuilders.add(createColocatedCustom);

      try (Connection connection =
         DriverManager.getConnection("jdbc:ignite:thin://127.0.0.1:10800"))
      {
         for (final StringBuilder createTableStringBuilder : createTableStringBuilders) {
            try (PreparedStatement createTableStatement =
               connection.prepareStatement(createTableStringBuilder.toString()))
            {
               System.out.println(createTableStringBuilder.toString());
               createTableStatement.execute();
               System.out.println();
            }
         }
      }
      catch (final SQLException e) {
         throw new AssertionError(e);
      }

      // Create the root entity.
      final BinaryObject root1 = ignite.binary().builder("root")
         .setField("key", "1")
         .setField("data", "Data for 1")
         .build();

      System.out.println("Inserting into \"root\": [\"1\", " + root1 + "]");
      ignite.cache("root").withKeepBinary().put("1", root1);

      // Create the colocated entity which uses the PARTITIONED template.
      final BinaryObject colocatedDefault1 = ignite.binary().builder("colocated_default")
         .setField("root_key", "1")
         .setField("key", "2")
         .build();

      final BinaryObject colocatedDefault1Key = ignite.binary().builder("colocated_default_key")
         .setField("root_key", "1")
         .setField("key", "2")
         .build();

      System.out.println("Inserting into \"colocated_default\": [" + colocatedDefault1Key + ", " +
         colocatedDefault1 + "]");
      ignite.cache("colocated_default").withKeepBinary().put(colocatedDefault1Key,
         colocatedDefault1);

      // Create the colocated entity which uses the custom template.
      final BinaryObject colocatedCustom1 = ignite.binary().builder("colocated_custom")
         .setField("root_key", "1")
         .setField("key", "3")
         .build();

      final BinaryObject colocatedCustom1Key = ignite.binary().builder("colocated_custom_key")
         .setField("root_key", "1")
         .setField("key", "3")
         .build();

      System.out.println("Inserting into \"colocated_custom\": [" + colocatedCustom1Key + ", " +
         colocatedCustom1 + "]");
      ignite.cache("colocated_custom").withKeepBinary().put(colocatedCustom1Key,
         colocatedCustom1);

      // SELECT COUNT(*) on all caches to ensure data exists.
      System.out.println();
      final List<String> selectAllStrings = new ArrayList<>();
      selectAllStrings.add("SELECT COUNT(*) FROM root;");
      selectAllStrings.add("SELECT COUNT(*) FROM colocated_default;");
      selectAllStrings.add("SELECT COUNT(*) FROM colocated_custom;");

      try (Connection connection =
         DriverManager.getConnection("jdbc:ignite:thin://127.0.0.1:10800"))
      {
         for (final String selectAllString : selectAllStrings) {
            try (PreparedStatement selectAllStatement =
               connection.prepareStatement(selectAllString))
            {
               System.out.println(selectAllString);
               selectAllStatement.execute();

               final ResultSet resultSet = selectAllStatement.getResultSet();
               resultSet.next();
               System.out.println(resultSet.getInt(1));
               System.out.println();
            }
         }
      }
      catch (final SQLException e) {
         throw new AssertionError(e);
      }

      // SELECT COUNT(*) with affinity key in WHERE clause.
      final List<String> selectWhereStrings = new ArrayList<>();

      // Returns 1.
      selectWhereStrings.add("SELECT COUNT(*) FROM root WHERE \"key\" = '1';");

      // Returns 1.
      selectWhereStrings.add("SELECT COUNT(*) FROM colocated_default WHERE \"root_key\" = '1';");

      // Returns 0.
      selectWhereStrings.add("SELECT COUNT(*) FROM colocated_custom WHERE \"root_key\" = '1';");

      try (Connection connection =
         DriverManager.getConnection("jdbc:ignite:thin://127.0.0.1:10800"))
      {
         for (final String selectWhereString : selectWhereStrings) {
            try (PreparedStatement selectWhereStatement =
               connection.prepareStatement(selectWhereString))
            {
               System.out.println(selectWhereString);
               selectWhereStatement.execute();

               final ResultSet resultSet = selectWhereStatement.getResultSet();
               resultSet.next();
               System.out.println(resultSet.getInt(1));
               System.out.println();
            }
         }
      }
      catch (final SQLException e) {
         throw new AssertionError(e);
      }
   }
}

А вот и вывод: 

...Ignite startup logs...
[10:28:05] Ignite node started OK (id=7393583b)
[10:28:05] Topology snapshot [ver=8, servers=1, clients=1, CPUs=8, offheap=3.2GB, heap=8.1GB]
[10:28:05]   ^-- Node [id=7393583B-90FB-4D04-8D51-595F7C4DD4B6, clusterState=ACTIVE]
CREATE TABLE IF NOT EXISTS root (
  "key" VARCHAR(24) NOT NULL,
  "data" VARCHAR(100),
  PRIMARY KEY("key"))
WITH "template=PARTITIONED, affinity_key=key, cache_name=root, value_type=root";

CREATE TABLE IF NOT EXISTS colocated_default (
  "root_key" VARCHAR(24) NOT NULL,
  "key" VARCHAR(24) NOT NULL,
  "data" VARCHAR(100),
  PRIMARY KEY("root_key", "key"))
WITH "template=PARTITIONED, affinity_key=root_key, cache_name=colocated_default, key_type=colocated_default_key, value_type=colocated_default";

CREATE TABLE IF NOT EXISTS colocated_custom (
  "root_key" VARCHAR(24) NOT NULL,
  "key" VARCHAR(24) NOT NULL,
  "data" VARCHAR(100),
  PRIMARY KEY("root_key", "key"))
WITH "template=myCacheTemplate, affinity_key=root_key, cache_name=colocated_custom, key_type=colocated_custom_key, value_type=colocated_custom";

Inserting into "root": ["1", root [idHash=362827515, hash=1928708473, data=Data for 1, key=1]]
Inserting into "colocated_default": [colocated_default_key [idHash=44559647, hash=-132016556, root_key=1, key=2], colocated_default [idHash=1067599825, hash=-132016556, root_key=1, key=2]]
Inserting into "colocated_custom": [colocated_custom_key [idHash=1336001042, hash=-132016555, root_key=1, key=3], colocated_custom [idHash=1856158867, hash=-132016555, root_key=1, key=3]]

SELECT COUNT(*) FROM root;
1

SELECT COUNT(*) FROM colocated_default;
1

SELECT COUNT(*) FROM colocated_custom;
1

SELECT COUNT(*) FROM root WHERE "key" = '1';
1

SELECT COUNT(*) FROM colocated_default WHERE "root_key" = '1';
1

SELECT COUNT(*) FROM colocated_custom WHERE "root_key" = '1';
0

Я хотел бы знать, если это неправильная конфигурация с моей стороны, или ошибка в Ignite.

1 Ответ

0 голосов
/ 22 октября 2018

Видимо, это ошибка в Ignite.Подано https://issues.apache.org/jira/browse/IGNITE-9964. Спасибо за сообщение!

Эта проблема появляется только при вводе данных через withKeepBinary().Если вместо этого вы используете SQL INSERT, SELECT работает нормально.

Я предлагаю использовать INSERT вместо создания BinaryObject s вручную - это намного проще и позволяет обойти ошибку.Если вам нужно использовать BinaryObject s, вы можете попробовать добавить первую строку через INSERT и впоследствии использовать двоичный файл - это также работало в моих тестах.

...