Пример #1
0
  public boolean validateUser(String username, String password) {
    AeSimpleSHA1 sha1handler = new AeSimpleSHA1();
    String EncodedPassword = null;
    try {
      EncodedPassword = sha1handler.SHA1(password);
    } catch (UnsupportedEncodingException | NoSuchAlgorithmException et) {
      System.out.println("Can't check your password");
      return false;
    }

    Session session = cluster.connect("ducquak");
    PreparedStatement pS = session.prepare("SELECT * FROM users");
    ResultSet rs = null;
    BoundStatement boundStatement = new BoundStatement(pS);
    rs =
        session.execute( // this is where the query is executed
            boundStatement // here you are binding the 'boundStatement'
            );
    if (rs.isExhausted()) {
      System.out.println("Nothing returned");
      return false;
    } else {
      for (Row row : rs) {

        String userName = row.getString("userName");
        if (userName.equals(username)) {
          String StoredPass = row.getString("password");
          if (StoredPass.compareTo(EncodedPassword) == 0) return true;
        }
      }
    }
    return false;
  }
  public Set<String> findUserIdsConnectedTo(String providerId, Set<String> providerUserIds) {
    ResultSet rs = null;
    Set<String> localUserIds = null;
    Statement getUserIds = null;
    try {
      getUserIds =
          QueryBuilder.select()
              .column("userid")
              .from(keyspace, table)
              .where(QueryBuilder.eq("providerId", providerId))
              .and(QueryBuilder.in("providerUserId", providerUserIds));

      rs = session.execute(getUserIds);
      if (rs.all().size() > 0) {
        localUserIds = new HashSet<String>();
      }
      for (Row row : rs.all()) {
        localUserIds.add(row.getString("userId"));
      }
      return localUserIds;
    } catch (Exception e) {
      e.printStackTrace();
    }
    return null;
  }
Пример #3
0
  @POST
  @Path("/login")
  @Consumes(MediaType.MULTIPART_FORM_DATA)
  public Response authenticate(
      @FormDataParam("username") String userId, @FormDataParam("password") String password) {

    Session session = databaseManager.getSession();
    ResultSet user =
        session.execute("SELECT * FROM righteous.user where user_id = '" + userId + "'");

    Row row = null;
    if (user.isExhausted()) {
      session.close();
      return Response.status(200).entity("Invalid Username or Password").build();
    } else {
      row = user.one();
    }

    if (row.getString("user_id").equals(userId)
        && row.getString("user_password").equals(password)) {

      session.close();
      return Response.status(200).entity("success").build();
    } else {
      session.close();
      return Response.status(200).entity("Invalid Username or Password").build();
    }
  }
Пример #4
0
  public java.util.LinkedList<Pic> getPicsForUser(String User) {
    java.util.LinkedList<Pic> Pics = new java.util.LinkedList<>();
    Session session = cluster.connect("instagrAndrew");
    PreparedStatement ps =
        session.prepare("select picid, hashtag, pic_added from userpiclist where user =?");
    ResultSet rs = null;
    BoundStatement boundStatement = new BoundStatement(ps);
    rs =
        session.execute( // this is where the query is executed
            boundStatement.bind( // here you are binding the 'boundStatement'
                User));
    if (rs.isExhausted()) {
      System.out.println("No Images returned");
      return null;
    } else {
      for (Row row : rs) {
        Pic pic = new Pic();
        java.util.UUID UUID = row.getUUID("picid");

        Date d = row.getDate("pic_added");
        java.sql.Timestamp tmp = new java.sql.Timestamp(d.getTime());

        pic.setUUID(UUID);
        pic.setDate(tmp);

        String ht = row.getString("hashtag");
        if (ht != null) {
          pic.setHashtag(ht);
        }
        Pics.add(pic);
      }
    }
    return Pics;
  }
Пример #5
0
  @Override
  public void removeValuesUnusedLongerThan(long minimumAge, TimeUnit unit)
      throws BinaryStoreException {
    try {
      Date deadline = new Date(new Date().getTime() - unit.toMillis(minimumAge));
      // When querying using 2nd indexes, Cassandra
      // (it's not CQL specific) requires that you use an '=' for at least one of
      // the indexed column in the where clause. This is a limitation of Cassandra.
      // So we have to do some tricks here
      ResultSet rs =
          session.execute(
              "SELECT cid from modeshape.binary where usage=0 and usage_time < "
                  + deadline.getTime()
                  + " allow filtering;");

      Iterator<Row> rows = rs.iterator();
      while (rows.hasNext()) {
        session.execute(
            "DELETE from modeshape.binary where cid = '" + rows.next().getString("cid") + "';");
      }

      rs =
          session.execute(
              "SELECT cid from modeshape.binary where usage=1 and usage_time < "
                  + deadline.getTime()
                  + " allow filtering;");
      rows = rs.iterator();
      while (rows.hasNext()) {
        session.execute(
            "DELETE from modeshape.binary where cid = '" + rows.next().getString("cid") + "';");
      }
    } catch (RuntimeException e) {
      throw new BinaryStoreException(e);
    }
  }
  ////////////////////////////////////
  // Overridden Methods for IBackingMap
  ////////////////////////////////////
  @SuppressWarnings("unchecked")
  @Override
  public List<T> multiGet(List<List<Object>> keys) {
    try {
      List<T> values = new ArrayList<T>();

      for (List<Object> rowKey : keys) {
        Statement statement = mapper.retrieve(rowKey);
        ResultSet results = session.execute(statement);
        // TODO: Better way to check for empty results besides accessing entire results list
        Iterator<Row> rowIter = results.iterator();
        Row row;
        if (results != null && rowIter.hasNext() && (row = rowIter.next()) != null) {
          if (rowIter.hasNext()) {
            LOG.error("Found non-unique value for key [{}]", rowKey);
          } else {
            values.add((T) mapper.getValue(row));
          }
        } else {
          values.add(null);
        }
      }

      _mreads.incrBy(values.size());
      LOG.debug("Retrieving the following keys: {} with values: {}", keys, values);
      return values;
    } catch (Exception e) {
      checkCassandraException(e);
      throw new IllegalStateException("Impossible to reach this code");
    }
  }
  public List<String> findUserIdsWithConnection(Connection<?> connection) {
    ResultSet rs = null;
    List<String> localUserIds = null;
    ConnectionKey key = connection.getKey();
    Statement getUserIds = null;
    try {
      getUserIds =
          QueryBuilder.select()
              .column("userid")
              .from(keyspace, table)
              .allowFiltering()
              .where(QueryBuilder.eq("providerId", key.getProviderId()))
              .and(QueryBuilder.eq("providerUserId", key.getProviderUserId()));

      rs = session.execute(getUserIds);
      List<Row> rows = rs.all();
      if (rows.size() > 0) {
        localUserIds = new LinkedList<String>();
      }
      for (Row row : rows) {
        localUserIds.add(row.getString("userId"));
      }
      return localUserIds;
    } catch (Exception e) {
      e.printStackTrace();
    }
    return null;
  }
  private void test() {
    ResultSet result =
        cassandraCQLUnit.session.execute(
            "select * from testCQLTable WHERE id='1690e8da-5bf8-49e8-9583-4dff8a570737'");

    String val = result.iterator().next().getString("value");
    assertEquals("Cql loaded string", val);
  }
Пример #9
0
 /** Test simple statement inserts for all collection data types */
 public void collectionInsertTest() throws Throwable {
   ResultSet rs;
   for (String execute_string : COLLECTION_INSERT_STATEMENTS) {
     rs = session.execute(execute_string);
     assertTrue(rs.isExhausted());
   }
   assertEquals(SAMPLE_COLLECTIONS.size(), 255);
   assertEquals(COLLECTION_INSERT_STATEMENTS.size(), SAMPLE_COLLECTIONS.size());
 }
Пример #10
0
 /** Test simple statement inserts for all primitive data types */
 public void primitiveInsertTest() throws Throwable {
   ResultSet rs;
   for (String execute_string : PRIMITIVE_INSERT_STATEMENTS) {
     rs = session.execute(execute_string);
     assertTrue(rs.isExhausted());
   }
   assertEquals(SAMPLE_DATA.size(), 15);
   assertEquals(PRIMITIVE_INSERT_STATEMENTS.size(), SAMPLE_DATA.size());
 }
  /**
   * @param resultSet
   * @param type
   * @return
   * @deprecated as of 1.5, {@link
   *     org.springframework.data.cassandra.mapping.CassandraMappingContext} handles type
   *     conversion.
   */
  @Deprecated
  public Object getSingleEntity(ResultSet resultSet, Class<?> type) {

    Object result =
        (resultSet.isExhausted() ? null : template.getConverter().read(type, resultSet.one()));

    warnIfMoreResults(resultSet);

    return result;
  }
Пример #12
0
 /**
  * Test content for existence.
  *
  * @param key content identifier
  * @param alive true inside used content and false for checking within content marked as unused.
  * @return true if content found
  * @throws BinaryStoreException
  */
 private boolean contentExists(BinaryKey key, boolean alive) throws BinaryStoreException {
   try {
     String query = "SELECT payload from modeshape.binary where cid='" + key.toString() + "'";
     query = alive ? query + " and usage=1;" : query + " and usage = 0;";
     ResultSet rs = session.execute(query);
     return rs.iterator().hasNext();
   } catch (RuntimeException e) {
     throw new BinaryStoreException(e);
   }
 }
  @Override
  public Company getCompany(final String firstName, final String lastName) {
    final String cql = "select * from company where first_name = ? and last_name = ?";
    final PreparedStatement cachedPreparedStatement = getCachedPreparedStatement(cql);
    final BoundStatement statement = cachedPreparedStatement.bind(firstName, lastName);

    final ResultSet resultSet = cassandraOperations.getSession().execute(statement);
    final Row row = resultSet.one();
    return toCompany(row);
  }
Пример #14
0
  @Test
  public void testTridentTopology() throws Exception {

    Session session = cassandraCQLUnit.session;
    String[] stationIds = {"station-1", "station-2", "station-3"};
    for (int i = 1; i < 4; i++) {
      ResultSet resultSet =
          session.execute(
              "INSERT INTO weather.station(id, name) VALUES(?, ?)",
              stationIds[i - 1],
              "Foo-Station-" + new Random().nextInt());
    }

    ResultSet rows = cassandraCQLUnit.session.execute("SELECT * FROM weather.station");
    for (Row row : rows) {
      System.out.println("####### row = " + row);
    }

    WeatherBatchSpout weatherBatchSpout =
        new WeatherBatchSpout(
            new Fields("weather_station_id", "temperature", "event_time"), 3, stationIds);

    TridentTopology topology = new TridentTopology();
    Stream stream = topology.newStream("cassandra-trident-stream", weatherBatchSpout);

    CassandraStateFactory insertValuesStateFactory = getInsertTemperatureStateFactory();

    CassandraStateFactory selectWeatherStationStateFactory = getSelectWeatherStationStateFactory();

    TridentState selectState = topology.newStaticState(selectWeatherStationStateFactory);
    stream =
        stream.stateQuery(
            selectState,
            new Fields("weather_station_id"),
            new CassandraQuery(),
            new Fields("name"));
    stream = stream.each(new Fields("name"), new PrintFunction(), new Fields("name_x"));

    stream.partitionPersist(
        insertValuesStateFactory,
        new Fields("weather_station_id", "name", "event_time", "temperature"),
        new CassandraStateUpdater(),
        new Fields());

    StormTopology stormTopology = topology.build();
    LocalCluster cluster = new LocalCluster();
    cluster.submitTopology("wordCounter", getConfig(), stormTopology);
    Thread.sleep(30 * 1000);

    rows = cassandraCQLUnit.session.execute("SELECT * FROM weather.temperature");
    Assert.assertTrue(rows.iterator().hasNext()); // basic sanity check

    cluster.killTopology("wordCounter");
    cluster.shutdown();
  }
  private void warnIfMoreResults(ResultSet resultSet) {

    if (log.isWarnEnabled() && !resultSet.isExhausted()) {
      int count = 0;

      while (resultSet.one() != null) {
        count++;
      }

      log.warn("ignoring extra {} row{}", count, count == 1 ? "" : "s");
    }
  }
Пример #16
0
 @Override
 public Iterable<BinaryKey> getAllBinaryKeys() throws BinaryStoreException {
   try {
     ResultSet rs = session.execute("SELECT cid from modeshape.binary WHERE usage=1;");
     Iterator<Row> it = rs.iterator();
     HashSet<BinaryKey> keys = new HashSet<BinaryKey>();
     while (it.hasNext()) {
       keys.add(new BinaryKey(it.next().getString("cid")));
     }
     return keys;
   } catch (RuntimeException e) {
     throw new BinaryStoreException(e);
   }
 }
  @Test
  public void should_execute_cas_successfully() throws Exception {
    // Given
    final AtomicBoolean casSuccess = new AtomicBoolean(false);
    CASResultListener listener =
        new CASResultListener() {
          @Override
          public void onCASSuccess() {
            casSuccess.compareAndSet(false, true);
          }

          @Override
          public void onCASError(CASResult casResult) {}
        };

    when(rs.getQueryString()).thenReturn("INSERT INTO table IF NOT EXISTS");
    wrapper =
        new RegularStatementWrapper(
            CompleteBean.class,
            rs,
            new Object[] {1},
            ONE,
            Optional.fromNullable(listener),
            NO_SERIAL_CONSISTENCY);
    when(session.execute(rs)).thenReturn(resultSet);
    when(resultSet.one().getBool(CAS_RESULT_COLUMN)).thenReturn(true);

    // When
    wrapper.execute(session);

    // Then
    verify(session).execute(rs);
    assertThat(casSuccess.get()).isTrue();
  }
Пример #18
0
  public java.util.LinkedList<Pic> getMatchingPics(String searched) {
    java.util.LinkedList<Pic> picList = new java.util.LinkedList<Pic>();

    Session session = cluster.connect("instagrAndrew");
    PreparedStatement ps = session.prepare("select * from userpicList");
    ResultSet rs = null;
    BoundStatement boundStatement = new BoundStatement(ps);
    rs = session.execute(boundStatement);
    if (rs.isExhausted()) {
      System.out.println("No Images returned");
      return new java.util.LinkedList<Pic>();
    } else {
      for (Row row : rs) {

        String fullString = row.getString("hashtag");

        UUID uuid = row.getUUID("picId");
        String us = row.getString("user");
        Date d = row.getDate("pic_added");
        java.sql.Timestamp tmp = new java.sql.Timestamp(d.getTime());

        String[] tags;
        try {
          tags = fullString.split(",");
        } catch (Exception ex) {
          tags = null;
        }

        if (tags != null) {
          for (int i = 0; i < tags.length; i++) {

            if (tags[i].toLowerCase().equals(searched.toLowerCase())) {
              Pic toAdd = new Pic();
              toAdd.setUUID(uuid);
              toAdd.setDate(tmp);
              toAdd.setUser(us);
              toAdd.setHashtag(fullString);
              picList.add(toAdd);
              break;
            }
          }
        }
      }
    }

    return picList;
  }
Пример #19
0
  private void initScheme(Session session, String keyspace) throws IOException {

    if (keyspace == null) {
      keyspace = AlertProperties.getProperty(ALERTS_CASSANDRA_KEYSPACE, "hawkular_alerts");
    }

    if (log.isDebugEnabled()) {
      log.debug("Checking Schema existence for keyspace: " + keyspace);
    }

    ResultSet resultSet =
        session.execute(
            "SELECT * FROM system.schema_keyspaces WHERE keyspace_name = '" + keyspace + "'");
    if (!resultSet.isExhausted()) {
      log.debug("Schema already exist. Skipping schema creation.");
      initialized = true;
      return;
    }

    log.infof("Creating Schema for keyspace %s", keyspace);

    ImmutableMap<String, String> schemaVars = ImmutableMap.of("keyspace", keyspace);

    String updatedCQL = null;
    try (InputStream inputStream =
            CassCluster.class.getResourceAsStream("/hawkular-alerts-schema.cql");
        InputStreamReader reader = new InputStreamReader(inputStream)) {
      String content = CharStreams.toString(reader);

      for (String cql : content.split("(?m)^-- #.*$")) {
        if (!cql.startsWith("--")) {
          updatedCQL = substituteVars(cql.trim(), schemaVars);
          if (log.isDebugEnabled()) {
            log.debug("Executing CQL:\n" + updatedCQL + "\n");
          }
          session.execute(updatedCQL);
        }
      }
    } catch (Exception e) {
      log.errorf("Failed schema creation: %s\nEXECUTING CQL:\n%s", e, updatedCQL);
    }
    initialized = true;

    log.infof("Done creating Schema for keyspace: " + keyspace);
  }
 @Test
 public void doAppendTest() throws IOException, InterruptedException {
   DeliveryCallback callback = new DeliveryCallback();
   logAppender.doAppend(generateLogEventPack(20), callback);
   Thread.sleep(3000);
   CassandraLogEventDao logEventDao =
       (CassandraLogEventDao) ReflectionTestUtils.getField(logAppender, "logEventDao");
   Session session = (Session) ReflectionTestUtils.getField(logEventDao, "session");
   ResultSet resultSet =
       session.execute(
           QueryBuilder.select()
               .countAll()
               .from(
                   KEY_SPACE_NAME, "logs_" + appToken + "_" + Math.abs(configuration.hashCode())));
   Row row = resultSet.one();
   Assert.assertEquals(20L, row.getLong(0));
   Assert.assertEquals(1, callback.getSuccessCount());
 }
Пример #21
0
 @Override
 protected String getStoredMimeType(BinaryValue source) throws BinaryStoreException {
   try {
     checkContentExists(source);
     ResultSet rs =
         session.execute(
             "SELECT mime_type FROM modeshape.binary WHERE cid = '" + source.getKey() + "';");
     Row row = rs.one();
     if (row == null) {
       throw new BinaryStoreException(
           JcrI18n.unableToFindBinaryValue.text(source.getKey(), session));
     }
     return row.getString("mime_type");
   } catch (BinaryStoreException e) {
     throw e;
   } catch (RuntimeException e) {
     throw new BinaryStoreException(e);
   }
 }
  @Test
  public void testCassandraBatchInsertAndSelectStatement() throws Exception {
    List<Book> books = getBookList(5);

    this.cassandraMessageHandler2.handleMessage(new GenericMessage<>(books));

    Message<?> message = MessageBuilder.withPayload("Cassandra Guru").setHeader("limit", 2).build();
    this.cassandraMessageHandler4.handleMessage(message);

    Message<?> receive = this.resultChannel.receive(10000);
    assertNotNull(receive);
    assertThat(receive.getPayload(), instanceOf(ResultSet.class));
    ResultSet resultSet = (ResultSet) receive.getPayload();
    assertNotNull(resultSet);
    List<Row> rows = resultSet.all();
    assertEquals(2, rows.size());

    this.cassandraMessageHandler1.handleMessage(
        new GenericMessage<>(QueryBuilder.truncate("book")));
  }
Пример #23
0
  @Override
  public InputStream getInputStream(BinaryKey key) throws BinaryStoreException {
    try {
      ResultSet rs =
          session.execute(
              "SELECT payload FROM modeshape.binary WHERE cid='"
                  + key.toString()
                  + "' and usage=1;");
      Row row = rs.one();
      if (row == null) {
        throw new BinaryStoreException(JcrI18n.unableToFindBinaryValue.text(key, session));
      }

      ByteBuffer buffer = row.getBytes("payload");
      return new BufferedInputStream(buffer);
    } catch (BinaryStoreException e) {
      throw e;
    } catch (RuntimeException e) {
      throw new BinaryStoreException(e);
    }
  }
Пример #24
0
  public UUID getProfilePic(String User) {
    Session session = cluster.connect("instagrAndrew");
    PreparedStatement ps = session.prepare("select profilepic from userprofiles where login =?");
    ResultSet rs = null;
    BoundStatement boundStatement = new BoundStatement(ps);
    rs =
        session.execute( // this is where the query is executed
            boundStatement.bind( // here you are binding the 'boundStatement'
                User));
    if (rs.isExhausted()) {
      System.out.println("No Images returned");
      return null;
    } else {
      for (Row row : rs) {
        java.util.UUID UUID = row.getUUID("profilepic");
        return UUID;
      }

      return null;
    }
  }
  @Override
  public boolean followingExists(String userId, String applicationId) throws TException {
    checkUserId(userId);
    checkAppId(applicationId);

    Statement query = createStatementToCheckIfFollowingExists(userId, applicationId);

    ResultSet results;
    try {
      results = cassandra.execute(query);
    } catch (Exception ex) {
      LOG.error(
          "Failed to query for following between User: [{}] App: [{}]", userId, applicationId, ex);
      throw new OperationFailedException("Could not query for following: " + ex.getMessage());
    }

    Row row = results.one();
    checkRowExists(row);

    long count = row.getLong(0);
    return count > 0;
  }
Пример #26
0
  @SuppressWarnings("unchecked")
  public <T> List<T> recoverObjet(Class<T> bean, ResultSet resultSet) {

    List<T> listObjList = new LinkedList<T>();
    for (Row row : resultSet.all()) {
      Map<String, Definition> mapDefinition = createMapDefinition(row.getColumnDefinitions());

      Object newObjetc = createObject(bean, row, mapDefinition);
      listObjList.add((T) newObjetc);
    }

    return listObjList;
  }
Пример #27
0
  public List<ListenableFuture<ResultSet>> moveTable(String name) throws ExecutionException {

    System.out.println("inserting data to destination:" + name);
    String query = "select * from " + name;
    BoundStatement bs = source.peer.bPrepare(source.session, query);
    ResultSet rs = source.session.execute(bs);
    ColumnDefinitions defs = rs.getColumnDefinitions();
    int ncols = defs.size();
    boolean update = false;
    for (int i = 0; i < ncols; ++i) {
      DataType dt = defs.getType(i);
      if (DataType.Name.COUNTER.equals(dt.getName())) {
        update = true;
        break;
      }
    }
    if (update) {
      return moveTableUpdate(name, rs, defs);
    } else {
      return moveTableInsert(name, rs, defs);
    }
  }
  @Test
  public void should_throw_exception_on_cas_error() throws Exception {
    // Given
    final AtomicReference<CASResult> atomicCASResult = new AtomicReference<>(null);
    CASResultListener listener =
        new CASResultListener() {
          @Override
          public void onCASSuccess() {}

          @Override
          public void onCASError(CASResult casResult) {
            atomicCASResult.compareAndSet(null, casResult);
          }
        };
    wrapper =
        new RegularStatementWrapper(
            CompleteBean.class,
            rs,
            new Object[] {1},
            ONE,
            Optional.fromNullable(listener),
            NO_SERIAL_CONSISTENCY);
    wrapper.invoker = invoker;
    when(rs.getQueryString()).thenReturn("UPDATE table IF name='John' SET");
    when(session.execute(rs)).thenReturn(resultSet);
    when(resultSet.one()).thenReturn(row);
    when(row.getBool(CAS_RESULT_COLUMN)).thenReturn(false);
    when(row.getColumnDefinitions()).thenReturn(columnDefinitions);

    when(columnDefinitions.iterator().hasNext()).thenReturn(true, true, false);
    Definition col1 = buildColumnDef("keyspace", "table", "[applied]", DataType.cboolean());
    Definition col2 = buildColumnDef("keyspace", "table", "name", DataType.text());
    when(columnDefinitions.iterator().next()).thenReturn(col1, col2);

    when(invoker.invokeOnRowForType(row, DataType.cboolean().asJavaClass(), "[applied]"))
        .thenReturn(false);
    when(invoker.invokeOnRowForType(row, DataType.text().asJavaClass(), "name"))
        .thenReturn("Helen");

    // When
    wrapper.execute(session);

    // Then
    verify(session).execute(rs);
    final CASResult actual = atomicCASResult.get();
    assertThat(actual).isNotNull();
    assertThat(actual.operation()).isEqualTo(UPDATE);
    assertThat(actual.currentValues())
        .contains(MapEntry.entry("[applied]", false), MapEntry.entry("name", "Helen"));
  }
  private Row getRow(ResultSet resultSet) {

    Iterator<Row> iterator = resultSet.iterator();
    if (!iterator.hasNext()) {
      return null;
    }

    Row firstRow = iterator.next();

    if (singleResult && iterator.hasNext()) {
      throw new CassandraNotSingleResultException(resultSet);
    }

    return firstRow;
  }
  @Test
  public void should_notify_listener_on_cas_error() throws Exception {
    // Given
    wrapper =
        new RegularStatementWrapper(
            CompleteBean.class, rs, new Object[] {1}, ONE, NO_LISTENER, NO_SERIAL_CONSISTENCY);
    wrapper.invoker = invoker;
    when(rs.getQueryString()).thenReturn("INSERT INTO table IF NOT EXISTS");
    when(session.execute(rs)).thenReturn(resultSet);
    when(resultSet.one()).thenReturn(row);
    when(row.getBool(CAS_RESULT_COLUMN)).thenReturn(false);
    when(row.getColumnDefinitions()).thenReturn(columnDefinitions);

    when(columnDefinitions.iterator().hasNext()).thenReturn(true, true, false);
    Definition col1 = buildColumnDef("keyspace", "table", "[applied]", DataType.cboolean());
    Definition col2 = buildColumnDef("keyspace", "table", "id", DataType.bigint());
    when(columnDefinitions.iterator().next()).thenReturn(col1, col2);

    when(invoker.invokeOnRowForType(row, DataType.cboolean().asJavaClass(), "[applied]"))
        .thenReturn(false);
    when(invoker.invokeOnRowForType(row, DataType.bigint().asJavaClass(), "id")).thenReturn(10L);

    AchillesLightWeightTransactionException caughtEx = null;
    // When
    try {
      wrapper.execute(session);
    } catch (AchillesLightWeightTransactionException ace) {
      caughtEx = ace;
    }

    // Then
    verify(session).execute(rs);
    assertThat(caughtEx).isNotNull();
    assertThat(caughtEx.operation()).isEqualTo(INSERT);
    assertThat(caughtEx.currentValues())
        .contains(MapEntry.entry("[applied]", false), MapEntry.entry("id", 10L));
  }