private UserType getSessionType(Session session, CassandraType type) {
   return session
       .getCluster()
       .getMetadata()
       .getKeyspace(session.getLoggedKeyspace())
       .getUserType(type.getName());
 }
Beispiel #2
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;
  }
  @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();
    }
  }
  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;
  }
  @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);
    }
  }
  public Optional<Auction> getAuction(String auctionName) {
    BoundStatement auctionBoundStatement = getAuction.bind(auctionName);
    Row auction = session.execute(auctionBoundStatement).one();

    LOGGER.debug("Getting auction information for auction {} rows {}", auctionName, auction);

    BoundStatement bidsBound = getAuctionBids.bind(auctionName);
    List<BidVo> bids =
        session
            .execute(bidsBound)
            .all()
            .stream()
            .map(
                row ->
                    new BidVo(
                        row.getString("bid_user"),
                        row.getLong("bid_amount"),
                        UUIDs.unixTimestamp(row.getUUID("bid_time"))))
            .collect(Collectors.toList());

    return Optional.of(
        new Auction(
            auction.getString("name"),
            Instant.ofEpochMilli(auction.getLong("ends")),
            bids,
            auction.getString("owner")));
  }
  public void execute(Tuple tuple) {
    LOG.info("Story found");

    String tweet = tuple.getString(0);
    outputCollector.ack(tuple);
    PreparedStatement preparedStatement =
        session.prepare("INSERT INTO tweets (seen, tweet) VALUES (?, ?)");
    session.execute(preparedStatement.bind(new Timestamp(System.currentTimeMillis()), tweet));
  }
 @PostConstruct
 public void prepareStatements() {
   createAuction = session.prepare("insert INTO auctions (name, owner, ends) VALUES (?, ?, ?)");
   getAuction = session.prepare("select * from auctions where name = ?");
   getAuctionBids = session.prepare("select * from auction_bids where name = ?");
   getAllAuctionSparse = session.prepare("select * from auctions");
   storeBid =
       session.prepare(
           "INSERT INTO auction_bids (name, bid_time , bid_amount , bid_user) VALUES ( ?, ?, ?, ?);");
 }
  @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();
  }
  @POST
  @Path("/register")
  public Response register(
      @FormDataParam("id") String userId,
      @FormDataParam("username") String userName,
      @FormDataParam("password") String password,
      @FormDataParam("dob") String dob,
      @FormDataParam("gender") String gender,
      @FormDataParam("location") String location,
      @FormDataParam("proPic") InputStream proPicInputStream,
      @FormDataParam("proPic") FormDataContentDisposition proPicFileDetail) {

    Session session = databaseManager.getSession();
    ResultSet users = session.execute("SELECT * FROM righteous.user");

    Calendar calendar = new GregorianCalendar();
    SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
    Date date = null;
    try {
      date = simpleDateFormat.parse(dob);
    } catch (ParseException e1) {
      log.error("", e1);
    }
    calendar.setTime(date);

    for (Row row : users) {
      if (row.getString("user_id").equalsIgnoreCase(userId)) {
        return Response.status(200).entity("Username unavailable").build();
      }
    }

    byte[] imageBytes = null;
    try {
      imageBytes = org.apache.commons.io.IOUtils.toByteArray(proPicInputStream);
    } catch (IOException e) {
      log.error("Unable to retrieve the image", e);
    }

    ByteBuffer imageByteBuffer = ByteBuffer.wrap(imageBytes);

    PreparedStatement preparedStatement =
        session.prepare(
            "INSERT INTO righteous.user (user_id, user_name, user_password, user_dob, user_gender, user_location, user_pic) "
                + "VALUES (?,?,?,?,?,?,?)");

    BoundStatement boundStatement = new BoundStatement(preparedStatement);
    session.execute(
        boundStatement.bind(
            userId, userName, password, calendar.getTime(), gender, location, imageByteBuffer));

    session.close();

    return Response.status(200).entity("Registration successful").build();
  }
 private void refreshEndpointMap() {
   String keyspace = ConfigHelper.getOutputKeyspace(conf);
   try (Session session =
       CqlConfigHelper.getOutputCluster(ConfigHelper.getOutputInitialAddress(conf), conf)
           .connect(keyspace)) {
     rangeMap = new HashMap<>();
     metadata = session.getCluster().getMetadata();
     Set<TokenRange> ranges = metadata.getTokenRanges();
     for (TokenRange range : ranges) {
       rangeMap.put(range, metadata.getReplicas(keyspace, range));
     }
   }
 }
  public static synchronized Session getSession(String host, int port) throws UnknownHostException {
    Session session = hostConnectionMap.getIfPresent(host);
    if (session == null || session.isClosed()) {
      Cluster.Builder builder = Cluster.builder().addContactPoint(host).withPort(port);
      Cluster cluster = builder.build();
      session = cluster.connect();
      hostConnectionMap.put(host, session);

      logger.debug("Created connection to {}.", host);
      logger.debug("Number of sessions opened are {}.", hostConnectionMap.size());
    }
    return session;
  }
Beispiel #13
0
 public List<ListenableFuture<ResultSet>> applyStatements(List<String> ss, boolean sync)
     throws Exception {
   List<ListenableFuture<ResultSet>> list = new ArrayList<>();
   for (String s : ss) {
     System.out.println(s);
     if (sync) {
       session.execute(s);
     } else {
       list.add(session.executeAsync(s));
     }
   }
   return list;
 }
Beispiel #14
0
  @Test
  public void should_batch_counters() throws Exception {
    // Start batch
    CQLBatchingEntityManager batchEm = emf.createBatchingEntityManager();
    batchEm.startBatch();

    CompleteBean entity = CompleteBeanTestBuilder.builder().randomId().name("name").buid();

    entity = batchEm.merge(entity);

    entity.setLabel("label");

    Tweet welcomeTweet = TweetTestBuilder.tweet().randomId().content("welcomeTweet").buid();
    entity.setWelcomeTweet(welcomeTweet);

    entity.getVersion().incr(10L);
    batchEm.merge(entity);

    Row result = session.execute("SELECT label from CompleteBean where id=" + entity.getId()).one();
    assertThat(result).isNull();

    result =
        session
            .execute(
                "SELECT counter_value from achilles_counter_table where fqcn='"
                    + CompleteBean.class.getCanonicalName()
                    + "' and primary_key='"
                    + entity.getId()
                    + "' and property_name='version'")
            .one();
    assertThat(result.getLong("counter_value")).isEqualTo(10L);

    // Flush
    batchEm.endBatch();

    result = session.execute("SELECT label from CompleteBean where id=" + entity.getId()).one();
    assertThat(result.getString("label")).isEqualTo("label");

    result =
        session
            .execute(
                "SELECT counter_value from achilles_counter_table where fqcn='"
                    + CompleteBean.class.getCanonicalName()
                    + "' and primary_key='"
                    + entity.getId()
                    + "' and property_name='version'")
            .one();
    assertThat(result.getLong("counter_value")).isEqualTo(10L);
    assertThatBatchContextHasBeenReset(batchEm);
  }
  public static void main(String[] args) {

    System.out.println("Connecting to db: " + System.getProperty("DB_HOST"));

    Cluster cluster =
        Cluster.builder().addContactPoints(System.getProperty("DB_HOST").split(",")).build();

    Session session = cluster.connect();
    session.execute(
        "CREATE KEYSPACE IF NOT EXISTS todolist WITH REPLICATION = { 'class' : 'SimpleStrategy', 'replication_factor' : 3 };");
    session.execute(
        "CREATE TABLE IF NOT EXISTS todolist.todo (" + "id int PRIMARY KEY," + "text text);");
    SpringApplication.run(Application.class, args);
  }
 private void dropTables() {
   ResultSet resultSet =
       session.execute(
           "SELECT columnfamily_name FROM system.schema_columnfamilies "
               + "WHERE keyspace_name = 'rhq'");
   for (Row row : resultSet) {
     String table = row.getString(0);
     if (table.equals("one_hour_metrics")
         || table.equals("six_hour_metrics")
         || table.equals("twenty_four_hour_metrics")) {
       log.info("Dropping table " + table);
       session.execute("DROP table rhq." + table);
     }
   }
 }
 public void updateConnection(
     String displayName,
     String profileUrl,
     String imageUrl,
     String accessToken,
     String secret,
     String refreshToken,
     Long expireTime,
     String userId,
     String providerId,
     String providerUserId) {
   try {
     Statement updateConn =
         QueryBuilder.update(keyspace, table)
             .with(QueryBuilder.set("displayName", displayName))
             .and(QueryBuilder.set("profileUrl", profileUrl))
             .and(QueryBuilder.set("imageUrl", imageUrl))
             .and(QueryBuilder.set("accessToken", accessToken))
             .and(QueryBuilder.set("secret", secret))
             .and(QueryBuilder.set("refreshToken", refreshToken))
             .and(QueryBuilder.set("expireTime", expireTime))
             .where(QueryBuilder.eq("userId", userId))
             .and(QueryBuilder.eq("providerId", providerId))
             .and(QueryBuilder.eq("providerUserId", providerUserId));
     session.execute(updateConn);
   } catch (Exception e) {
     e.printStackTrace();
   }
 }
  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;
  }
  private void initPreparedStatements() {
    find1HourData =
        session.prepare(
            "SELECT schedule_id, time, type, value, ttl(value), writetime(value) FROM rhq.one_hour_metrics "
                + "WHERE schedule_id = ?");

    find6HourData =
        session.prepare(
            "SELECT schedule_id, time, type, value, ttl(value), writetime(value) FROM rhq.six_hour_metrics "
                + "WHERE schedule_id = ?");

    find24HourData =
        session.prepare(
            "SELECT schedule_id, time, type, value, ttl(value), writetime(value) FROM rhq.twenty_four_hour_metrics "
                + "WHERE schedule_id = ?");
  }
  @SuppressWarnings("unchecked")
  @Override
  public void multiPut(List<List<Object>> keys, List<T> values) {
    LOG.debug("Putting the following keys: {} with values: {}", keys, values);
    try {
      List<Statement> statements = new ArrayList<Statement>();

      // Retrieve the mapping statement for the key,val pair
      for (int i = 0; i < keys.size(); i++) {
        List<Object> key = keys.get(i);
        T val = values.get(i);
        Statement retrievedStatment = mapper.map(key, val);
        if (retrievedStatment
            instanceof BatchStatement) { // Allows for BatchStatements to be returned by the mapper.
          BatchStatement batchedStatment = (BatchStatement) retrievedStatment;
          statements.addAll(batchedStatment.getStatements());
        } else {
          statements.add(retrievedStatment);
        }
      }

      // Execute all the statements as a batch.
      BatchStatement batch = new BatchStatement(batchType);
      batch.addAll(statements);
      session.execute(batch);

      _mwrites.incrBy(statements.size());
    } catch (Exception e) {
      checkCassandraException(e);
      LOG.error("Exception {} caught.", 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");
    }
  }
Beispiel #22
0
  private void writeToRegister(
      String key,
      int index,
      String clId,
      long l,
      long latencyDep,
      long curr_deadline2,
      String string,
      Session session) {
    // TODO Auto-generated method stub
    String cqlStr =
        "INSERT INTO consistify.registry (KEY, CLID, DEADLINE, INDIC, LATENCYDEP,WAITINGTIME,STATUS, CREATETIME) VALUES ('"
            + key
            + "','"
            + clId
            + "','"
            + +curr_deadline2
            + "','"
            + index
            + " ','"
            + latencyDep
            + " ','"
            + l
            + " ','"
            + string
            + " ','"
            + (long) System.currentTimeMillis()
            + "') if not exists";
    Statement statement = new SimpleStatement(cqlStr);

    // System.out.println("****11consistify cqlStr:="+cqlStr);
    statement.setConsistencyLevel(ConsistencyLevel.ALL);
    session.execute(statement);
    // .executeAsync(arg0)
  }
Beispiel #23
0
 // private ArrayList<RegistryEntry> readFromRegister(String key, Session session) {
 private String readFromRegister(String key, Session session) {
   // TODO Auto-generated method stub
   // Map<String, String> resultMap = new HashMap<String, String>();
   String CLID = null, STATUS = null;
   String cqlStr = "SELECT * from consistify.registry WHERE key='" + key + "'";
   Statement statement = new SimpleStatement(cqlStr);
   ResultSet results = session.execute(statement);
   CopyOnWriteArrayList<RegistryEntry> rList = new CopyOnWriteArrayList<RegistryEntry>();
   RegistryEntry r = null;
   Scheduler scheduler = new Scheduler();
   for (Row aRow : results) {
     // if (!resultMap.containsKey(aRow.getKey())) {
     if (aRow.getString("CREATETIME") != null && aRow.getString("key").equalsIgnoreCase(key)) {
       r = new RegistryEntry();
       r.setKey(aRow.getString("key"));
       // System.out.println("**222*CLID:=="+aRow.getString("CLID"));
       r.setCLID(aRow.getString("CLID"));
       r.setDEADLINE(aRow.getString("DEADLINE"));
       r.setINDEX(aRow.getString("INDIC"));
       r.setLATENCYDEP(aRow.getString("LATENCYDEP"));
       r.setWAITINGTIME(aRow.getString("WAITINGTIME"));
       r.setSTATUS(aRow.getString("STATUS"));
       r.setCREATETIME(aRow.getString("CREATETIME"));
       rList.add(r);
     }
     // resultMap.put(aRow.getKey(), ++rowCnt);
     // System.out.println(aRow.getKey() + ":" + rowCnt);
     // }
   }
   // CLID = scheduler.schedule(rList).split(":")[0];
   CLID = scheduler.schedule(rList);
   // System.out.println("****CLID:="+CLID);
   return CLID;
 }
  public <K> void deleteByKeyAsync(
      Iterable<K> keys, Class<?> bean, Session session, ConsistencyLevel consistency) {

    for (K key : keys) {
      session.executeAsync(runDelete(key, bean, consistency));
    }
  }
  @Override
  public void output(Collection<Metric> metrics) {
    if (!eventRegistered.getAndSet(true)) {
      EventBusManager.createRegistrationPoint()
          .subscribe(
              WriteToStorageEvent.class,
              w -> {
                MetricStorage storage = w.storageToWriteTo().getSubStorageCalled("cassandra");
                storage.store("metrics-to-cassandra", metricCount.longValue());
              });

      EvilManagerHack.subscribe(this.cluster);
    }

    if (metrics.size() == 0) {
      return;
    }

    Map<RetentionTable, BatchStatement> stms =
        LazyMap.<RetentionTable, BatchStatement>lazyMap(
            new HashMap<>(), () -> new BatchStatement());
    for (Metric metric : metrics) {
      insertMetricIntoBatch(metric, stms);
    }
    KeyspaceMetadata metadata = cluster.getMetadata().getKeyspace(keyspace);
    for (RetentionTable table : stms.keySet()) {
      createTableIfNecessary(table, metadata);
    }
    for (BatchStatement batch : stms.values()) {
      session.execute(batch);
    }

    metricCount.addAndGet(metrics.size());
  }
  @Override
  public List<Application> getApplicationsFollowedBy(String userId) throws TException {
    checkUserId(userId);

    Statement query = createQueryForAppsFollowedBy(userId);

    ResultSet results;

    try {
      results = cassandra.execute(query);
    } catch (Exception ex) {
      LOG.error("Failed to query Cassandra for apps followed by User: [{}]", userId, ex);
      throw new OperationFailedException(
          "Could not find apps followed by user: "******"Found {} apps followed by {}", apps.size(), userId);
    return apps;
  }
  @Override
  public List<User> getApplicationFollowers(String applicationId) throws TException {
    checkAppId(applicationId);

    Statement query = createQueryForFollowersOfApp(applicationId);

    ResultSet results;

    try {
      results = cassandra.execute(query);
    } catch (Exception ex) {
      LOG.error("Failed to query for App's followed: App: [{}]", applicationId, ex);
      throw new OperationFailedException("Could not query for App's Followers: " + ex.getMessage());
    }

    List<User> followers = Lists.create();

    for (Row row : results) {
      User follower = createUserFromRow(row);
      followers.add(follower);
    }

    LOG.debug("Found {} Users followed App [{}]", followers.size(), applicationId);
    return followers;
  }
Beispiel #28
0
 public void changePassword(String username, String newPassword) {
   Session session = cluster.connect("ducquak");
   Statement s00;
   s00 = QueryBuilder.select().all().from("ducquak", "users");
   ResultSet rs = session.execute(s00);
   for (Row row : rs) {
     String olduserName = row.getString("userName");
     if (olduserName.equals(username)) {
       Statement s01 =
           QueryBuilder.update("ducquak", "users")
               .with(set("password", username))
               .where(eq("password", olduserName));
       session.execute(s01);
     }
   }
 }
  @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();
  }
  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;
  }