示例#1
0
  @Test
  public void testCursorPutAndGet() throws Exception {
    k1.putLong(0, 14);
    v1.putLong(0, 15);
    k2.putLong(0, 16);
    v2.putLong(0, 17);

    try (Transaction tx = env.createWriteTransaction()) {
      try (Cursor cursor = db.openCursor(tx)) {
        cursor.put(k1, v1, 0);
        cursor.put(k2, v2, 0);
      }
      tx.commit();
    }

    DirectBuffer k = new DirectBuffer();
    DirectBuffer v = new DirectBuffer();

    try (Transaction tx = env.createReadTransaction()) {
      try (Cursor cursor = db.openCursor(tx)) {
        cursor.position(k, v, GetOp.FIRST);
        assertThat(k.getLong(0), is(14L));
        assertThat(v.getLong(0), is(15L));

        cursor.position(k, v, GetOp.NEXT);
        assertThat(k.getLong(0), is(16L));
        assertThat(v.getLong(0), is(17L));
      }
    }
  }
示例#2
0
  @Test
  public void testCursorSeekRange() throws Exception {
    ByteBuffer byteBuffer = ByteBuffer.allocateDirect(8);
    k1.putLong(0, 18);
    v1.putLong(0, 19);
    k2.putLong(0, 20);
    v2.putLong(0, 21);

    try (Transaction tx = env.createWriteTransaction()) {
      try (Cursor cursor = db.openCursor(tx)) {
        cursor.put(k1, v1, 0);
        cursor.put(k2, v2, 0);
      }
      tx.commit();
    }

    try (Transaction tx = env.createReadTransaction()) {
      try (Cursor cursor = db.openCursor(tx)) {
        DirectBuffer k = new DirectBuffer(byteBuffer);
        DirectBuffer v = new DirectBuffer();
        k.putLong(0, 10);

        cursor.seekPosition(k, v, SeekOp.RANGE);
        assertThat(k.getLong(0), is(18L));
        assertThat(v.getLong(0), is(19L));

        k.wrap(byteBuffer);
        k.putLong(0, 19);
        cursor.seekPosition(k, v, SeekOp.RANGE);
        assertThat(k.getLong(0), is(20L));
        assertThat(v.getLong(0), is(21L));
      }
    }
  }
示例#3
0
  public static Database buildsecondary(Database std) {
    // Parse database loaded
    try {
      io.deleteFile("secondarydb");
      // SecondaryDatabases started
      DatabaseConfig dbConfig = new DatabaseConfig();
      dbConfig.setType(DatabaseType.HASH);
      dbConfig.setAllowCreate(true);
      dbConfig.setUnsortedDuplicates(true);
      Database secdb = new Database("secondarydb", null, dbConfig);
      // Cursors started
      Cursor stdcursor = std.openCursor(null, null);
      Cursor secdbcursor = secdb.openCursor(null, null);
      // Key and Data started
      DatabaseEntry stdkey = new DatabaseEntry();
      DatabaseEntry stddata = new DatabaseEntry();
      DatabaseEntry seckey = new DatabaseEntry();
      DatabaseEntry secdata = new DatabaseEntry();

      while (stdcursor.getNext(stdkey, stddata, LockMode.DEFAULT)
          == OperationStatus.SUCCESS) { // Writing into secondary db
        String[] key = new String(stdkey.getData()).split(",");
        String data = new String(stddata.getData());
        // DEBUG:
        // System.out.println("key 0:" + key[0] + " key 1:" + key[1] + " data:" + data);
        seckey.setData(key[1].getBytes());
        OperationStatus operation = secdbcursor.getSearchKey(seckey, secdata, LockMode.DEFAULT);

        String b = null;
        while (operation == OperationStatus.SUCCESS) {
          b = new String(secdata.getData());
          secdbcursor.delete();
          operation = secdbcursor.getNextDup(seckey, secdata, LockMode.DEFAULT);
        }
        if (b == null) {
          seckey.setData(key[1].getBytes());
          secdata.setData(("(" + key[0] + "," + data + ")").getBytes());
          secdb.put(null, seckey, secdata);
        }
        if (b != null) {
          secdata.setData(b.concat("(" + key[0] + "," + data + ")").getBytes());
          secdb.put(null, seckey, secdata);
        }
        seckey.setData(null);
        secdata.setData(null);

        stdkey.setData(null);
        stddata.setData(null);
      }
      // io.debugread(secdb);

      return secdb;
    } catch (Exception e) {
      System.out.println("Error creating <user>,<song,rating> secondary table!\n");
      System.out.println(e.getMessage());
    }
    return null; // SHOULD NEVER HAPPEN
  }
示例#4
0
 @Test
 public void testIteration() {
   k1.putLong(0, 18);
   v1.putLong(0, 19);
   k2.putLong(0, 20);
   v2.putLong(0, 21);
   db.put(k1, v1, 0);
   db.put(k2, v2, 0);
   List<Long> result = new ArrayList<>();
   try (Transaction tx = env.createWriteTransaction()) {
     try (Cursor cursor = db.openCursor(tx)) {
       DirectBuffer k = new DirectBuffer();
       DirectBuffer v = new DirectBuffer();
       for (int rc = cursor.position(k, v, FIRST);
           rc != NOTFOUND;
           rc = cursor.position(k, v, NEXT)) {
         result.add(k.getLong(0));
       }
     }
     tx.commit();
   }
   assertThat(result.size(), is(2));
   assertThat(result.get(0), is(18L));
   assertThat(result.get(1), is(20L));
 }
示例#5
0
  public void runTest(DatabaseType type) throws DatabaseException, FileNotFoundException {
    int i;
    DatabaseConfig conf = new DatabaseConfig();
    conf.setErrorStream(TestUtils.getErrorStream());
    conf.setErrorPrefix("HashCompareTest");
    conf.setType(type);
    if (type == DatabaseType.HASH) {
      conf.setHashComparator(new HashComparator());
    } else conf.setBtreeComparator(new BtreeComparator());
    conf.setAllowCreate(true);

    Database db = new Database(HASHCOMPARETEST_DBNAME, null, conf);

    DatabaseEntry key = new DatabaseEntry();
    DatabaseEntry data = new DatabaseEntry("world".getBytes());
    for (i = 0; i < 100; i++) {
      key.setData((new String("key" + i)).getBytes());
      db.put(null, key, data);
    }
    i = 0;
    Cursor dbc;
    dbc = db.openCursor(null, CursorConfig.DEFAULT);
    while (dbc.getNext(key, data, LockMode.DEFAULT) == OperationStatus.SUCCESS) {
      ++i;
    }
    //		System.out.println("retrieved " + i + " entries");
    dbc.close();
    db.close();
  }
示例#6
0
  /**
   * Instantiates the query for rscore
   *
   * @param query contains user query
   * @param cmp contains compare structure
   * @param resultIndices passes the indices that store the result
   * @throws DatabaseException when BerkeleyDB passes errors
   * @throws FileNotFoundException when respective .idx or .txt value not found
   */
  private void queryRScore(String query, ArrayList<Integer> resultIndices, COMPARE cmp)
      throws FileNotFoundException, DatabaseException {
    if (cmp == COMPARE.EQUAL) {
      query = query.replace("rscore=", "").toLowerCase();
      queryDB(query, rscoreIndex, resultIndices);
      return;
    } else if (cmp == COMPARE.LESS) {
      query = query.replace("rscore<", "");
    } else {
      query = query.replace("rscore>", "");
    }

    OperationStatus oprStatus;
    Database std_db = new Database(rscoreIndex, null, null);
    Cursor std_cursor = std_db.openCursor(null, null); // Create new cursor object

    if (cmp == COMPARE.LESS) {
      for (int n = 0; n < Integer.parseInt(query); n++) {
        String searchkey = new String();
        searchkey = n + ".0";
        DatabaseEntry key = new DatabaseEntry();
        DatabaseEntry data = new DatabaseEntry();
        oprStatus = std_cursor.getFirst(key, data, LockMode.DEFAULT);
        key.setData(searchkey.getBytes());
        key.setSize(searchkey.length());
        data = new DatabaseEntry();
        oprStatus = std_cursor.getSearchKey(key, data, LockMode.DEFAULT);
        while (oprStatus == OperationStatus.SUCCESS) {
          String s = new String(data.getData());
          if (!(resultIndices.contains(Integer.parseInt(s)))) {
            resultIndices.add(Integer.parseInt(s));
          }
          oprStatus = std_cursor.getNextDup(key, data, LockMode.DEFAULT);
        }
      }

    } else {
      for (int n = 5; n > Integer.parseInt(query); n--) {
        String searchkey = new String();
        searchkey = n + ".0";
        DatabaseEntry key = new DatabaseEntry();
        DatabaseEntry data = new DatabaseEntry();
        oprStatus = std_cursor.getFirst(key, data, LockMode.DEFAULT);
        key.setData(searchkey.getBytes());
        key.setSize(searchkey.length());
        data = new DatabaseEntry();
        oprStatus = std_cursor.getSearchKey(key, data, LockMode.DEFAULT);
        while (oprStatus == OperationStatus.SUCCESS) {
          String s = new String(data.getData());
          if (!(resultIndices.contains(Integer.parseInt(s)))) {
            resultIndices.add(Integer.parseInt(s));
          }
          oprStatus = std_cursor.getNextDup(key, data, LockMode.DEFAULT);
        }
      }
    }
  }
示例#7
0
  @Test
  public void testReserveCursorRollback() {
    byte[] key = new byte[] {1, 1, 1};
    byte[] val = new byte[] {3, 3, 3};

    Transaction tx = env.createWriteTransaction();
    Cursor cursor = db.openCursor(tx);
    DirectBuffer keyBuf = new DirectBuffer(ByteBuffer.allocateDirect(key.length));
    keyBuf.putBytes(0, key);
    DirectBuffer valBuf = cursor.reserve(keyBuf, val.length);
    valBuf.putBytes(0, val);
    tx.abort();

    byte[] result = db.get(key);
    assertNull(result);
  }
示例#8
0
  /*
   * void return type since error conditions are propogated
   * via exceptions.
   */
  private void printStocks(Database db) throws DeadlockException, DatabaseException {
    Cursor dbc = db.openCursor(null, null);

    System.out.println("\tSymbol\tPrice");
    System.out.println("\t======\t=====");

    DatabaseEntry key = new DatabaseEntry();
    DatabaseEntry data = new DatabaseEntry();
    OperationStatus ret;
    for (ret = dbc.getFirst(key, data, LockMode.DEFAULT);
        ret == OperationStatus.SUCCESS;
        ret = dbc.getNext(key, data, LockMode.DEFAULT)) {
      String keystr = new String(key.getData(), key.getOffset(), key.getSize());
      String datastr = new String(data.getData(), data.getOffset(), data.getSize());
      System.out.println("\t" + keystr + "\t" + datastr);
    }
    dbc.close();
  }
示例#9
0
  @Test
  public void testReserveCursor() {
    byte[] key = new byte[] {1, 1, 1};
    byte[] val = new byte[] {3, 3, 3};

    try (Transaction tx = env.createWriteTransaction()) {
      try (Cursor cursor = db.openCursor(tx)) {
        DirectBuffer keyBuf = new DirectBuffer(ByteBuffer.allocateDirect(key.length));
        keyBuf.putBytes(0, key);
        DirectBuffer valBuf = cursor.reserve(keyBuf, val.length);
        valBuf.putBytes(0, val);
      }
      tx.commit();
    }

    try (Transaction tx = env.createReadTransaction()) {
      byte[] result = db.get(tx, key);
      assertArrayEquals(result, val);
    }
  }
示例#10
0
  /**
   * Generic query process
   *
   * @param query contains parsed query for process
   * @param db_name contains database to query
   * @param indices passes the indices that store the result
   * @throws DatabaseException when BerkeleyDB passes errors
   * @throws FileNotFoundException when respective .idx or .txt value not found
   */
  private void queryDB(String query, String db_name, ArrayList<Integer> indices)
      throws DatabaseException, FileNotFoundException {
    OperationStatus oprStatus;
    Database std_db = new Database(db_name, null, null);
    Cursor std_cursor = std_db.openCursor(null, null); // Create new cursor object
    DatabaseEntry key = new DatabaseEntry();
    DatabaseEntry data = new DatabaseEntry();

    key.setData(query.getBytes());
    key.setSize(query.length());

    // Returns OperationStatus
    oprStatus = std_cursor.getSearchKey(key, data, LockMode.DEFAULT);
    while (oprStatus == OperationStatus.SUCCESS) {
      String s = new String(data.getData());
      if (!(indices.contains(Integer.parseInt(s)))) {
        indices.add(Integer.parseInt(s));
      }
      oprStatus = std_cursor.getNextDup(key, data, LockMode.DEFAULT);
    }

    std_cursor.close();
    std_db.close();
  }
示例#11
0
  public static String rank(Database sqSumdb) throws DatabaseException {

    Cursor sqSumCurs = sqSumdb.openCursor(null, null);
    DatabaseEntry sqSumKey = new DatabaseEntry();
    DatabaseEntry sqSumData = new DatabaseEntry();

    // initialize the ids and distances to be replaced by the loop below
    String firstIDs = "";
    String secondIDs = "";
    String thirdIDs = "";
    double inf = Integer.MAX_VALUE;
    double firstDist = inf;
    double secondDist = inf;
    double thirdDist = inf;
    // initialize containers for rating data for each song before distance calculation
    boolean firstFilled = true;
    boolean secondFilled = true;
    boolean thirdFilled = true;
    while (sqSumCurs.getNext(sqSumKey, sqSumData, LockMode.DEFAULT) == OperationStatus.SUCCESS) {
      // get song id
      String id = (new String(sqSumKey.getData()));
      String[] sumN = (new String(sqSumData.getData())).split(",");
      sqSumKey.setData(null);
      sqSumData.setData(null);
      double sum = Integer.parseInt(sumN[0]);
      double N = Integer.parseInt(sumN[1]);
      double dist = Math.sqrt(sum) / N;

      if (dist != inf) {
        if (dist < firstDist || !firstFilled) {
          // set thirdID and thirdDist
          thirdIDs = secondIDs;
          thirdDist = secondDist;
          // set secondID and secondDist
          secondIDs = firstIDs;
          secondDist = firstDist;
          // set firstID and firstDist
          firstIDs = id;
          firstDist = dist;
          if (firstFilled) {
            if (secondFilled) {
              thirdFilled = true;
            }
            secondFilled = true;
          }
          firstFilled = true;
        } else if ((dist < secondDist || !secondFilled) && dist != firstDist) {
          // set thirdID and thirdDist
          thirdIDs = secondIDs;
          thirdDist = secondDist;
          // set secondID and secondDist
          secondIDs = id;
          secondDist = dist;
          if (secondFilled) {
            thirdFilled = true;
          }
          secondFilled = true;
        } else if ((dist < thirdDist || !thirdFilled) && dist != firstDist && dist != secondDist) {
          // set thirdID and thirdDist
          thirdIDs = id;
          thirdDist = dist;
          thirdFilled = true;
        } else if (dist == firstDist) {
          // append fistID
          firstIDs += ", " + id;
        } else if (dist == secondDist) {
          // append secondID
          secondIDs += ", " + id;
        } else if (dist == thirdDist) {
          // append thirdID
          thirdIDs += ", " + id;
        }
      }
    }
    if (firstIDs.equals("")) firstIDs = "<no 1st place>";
    if (secondIDs.equals("")) secondIDs = "<no 2nd place>";
    if (thirdIDs.equals("")) thirdIDs = "<no 3rd place>";

    return firstIDs + ", " + secondIDs + ", " + thirdIDs;
  }
示例#12
0
  public static Database buildtertiary(Database std) {

    try {
      // configure new database instance
      io.deleteFile("tertiarydb");
      DatabaseConfig dbConfig = new DatabaseConfig();
      dbConfig.setType(DatabaseType.HASH);
      dbConfig.setAllowCreate(true);
      dbConfig.setUnsortedDuplicates(true);
      Database tdb = new Database("tertiarydb", null, dbConfig);

      // configure cursors and entries
      Cursor stdCurs = std.openCursor(null, null);
      Cursor tCurs = tdb.openCursor(null, null);
      DatabaseEntry stdKey = new DatabaseEntry();
      DatabaseEntry stdData = new DatabaseEntry();
      DatabaseEntry tKey = new DatabaseEntry();
      DatabaseEntry tData = new DatabaseEntry();

      // extract from linearly constructed database to populate <song>,<users> table, making
      // use of songs grouped by id
      String currUsers = "";
      String prevID = "default";
      boolean firstIter = true;
      while (stdCurs.getNext(stdKey, stdData, LockMode.DEFAULT) == OperationStatus.SUCCESS) {
        // get rating data from current row
        String[] currIDUser = (new String(stdKey.getData())).split(",");
        String currID = currIDUser[0].trim();
        String currUser = currIDUser[1].trim();
        String currRating = (new String(stdData.getData()));
        stdKey.setData(null);
        stdData.setData(null);
        if (currID.equals(prevID) || firstIter) {
          // concatenate new username with current string
          currUsers += "(" + currUser + "," + currRating + ")";
        } else if (!firstIter) {
          // insert completed <usernames> into table under key <song id>
          tKey.setData(prevID.getBytes());
          tData.setData(currUsers.substring(0, currUsers.length()).getBytes());
          tCurs.put(tKey, tData);
          tKey.setData(null);
          tData.setData(null);
          // DEBUG:
          // System.out.println(prevID+","+currUsers.substring(0, currUsers.length()-1));
          // start the new <usernames> for the next song (in currID)
          currUsers = "(" + currUser + "," + currRating + ")";
        }
        prevID = currID;
        firstIter = false;
      }
      // repeat iteration for last song
      tKey.setData(prevID.getBytes());
      tData.setData(currUsers.substring(0, currUsers.length()).getBytes());
      tCurs.put(tKey, tData);
      tKey.setData(null);
      tData.setData(null);

      // DEBUG:
      // io.debugread(tdb);
      tCurs.close();

      return tdb;

    } catch (Exception e) {
      System.out.println(" error creating <song>,<users> tertiary table\n");
      System.out.println(e.getMessage());
    }
    return null; // should never happen
  }
示例#13
0
  public static String top3(String line, Database secdb, Database tdb)
      throws DatabaseException, FileNotFoundException {
    // configure sqSum db for keeping track of cumulative squaresums
    io.deleteFile("sqSumdb");
    DatabaseConfig dbConfig = new DatabaseConfig();
    dbConfig.setType(DatabaseType.HASH);
    dbConfig.setAllowCreate(true);
    dbConfig.setUnsortedDuplicates(true);
    Database sqSumdb = new Database("sqSumdb", null, dbConfig);

    Cursor sqSumCurs = sqSumdb.openCursor(null, null);
    DatabaseEntry sqSumKey = new DatabaseEntry();
    DatabaseEntry sqSumData = new DatabaseEntry();

    Cursor secCurs = secdb.openCursor(null, null);
    Cursor tCurs = tdb.openCursor(null, null);
    DatabaseEntry secKey = new DatabaseEntry();
    DatabaseEntry secData = new DatabaseEntry();
    DatabaseEntry tKey = new DatabaseEntry();
    DatabaseEntry tData = new DatabaseEntry();

    // get input song users and ratings
    tKey.setData(line.getBytes());
    if (tCurs.getSearchKey(tKey, tData, LockMode.DEFAULT) == OperationStatus.SUCCESS) {
      // for each user in input song, get songs and ratings
      HashMap<String, String> iRatings = parseBrace(new String(tData.getData()));
      for (String user : iRatings.keySet()) {
        // get current user's rating for input song
        int inputRating = Integer.parseInt(iRatings.get(user));
        // get songs and ratings for user
        secKey.setData(null);
        secData.setData(null);
        secKey.setData(user.getBytes());
        if (secCurs.getSearchKey(secKey, secData, null) == OperationStatus.SUCCESS) {
          // for each song rated by user
          HashMap<String, String> currSongs = parseBrace(new String(secData.getData()));
          for (String song : currSongs.keySet()) {
            // input song should not be compared to itself, otherwise get the users and ratings for
            // it
            if (song.equals(line)) continue;
            // current user's rating for song under inspection
            int songRating = Integer.parseInt(currSongs.get(song));
            sqSumKey.setData(null);
            sqSumData.setData(null);
            sqSumKey.setData(song.getBytes());
            if (sqSumCurs.getSearchKey(sqSumKey, sqSumData, null) == OperationStatus.SUCCESS) {
              // if song is already in sqSum,N db, add to it
              String[] sumN = (new String(sqSumData.getData())).split(",");

              // add the new square sum to the previous and increment N
              int sum = Integer.parseInt(sumN[0]);
              int N = Integer.parseInt(sumN[1]);
              sum += (inputRating - songRating) * (inputRating - songRating);
              N += 1;
              String encoded = Integer.toString(sum) + "," + Integer.toString(N);

              // remove old entry for current song and replace it with the new one
              sqSumCurs.delete();
              sqSumKey.setData(null);
              sqSumData.setData(null);
              sqSumKey.setData(song.getBytes());
              sqSumData.setData(encoded.getBytes());
              sqSumdb.put(null, sqSumKey, sqSumData);

            } else {
              // if song in not already in sqSum,N db, create it
              int sum = (inputRating - songRating) * (inputRating - songRating);
              int N = 1;
              String encoded = Integer.toString(sum) + "," + Integer.toString(N);
              sqSumKey.setData(null);
              sqSumData.setData(null);
              sqSumKey.setData(song.getBytes());
              sqSumData.setData(encoded.getBytes());
              sqSumdb.put(null, sqSumKey, sqSumData);
            }
          }
        } else {
          System.out.println("ERROR:  user " + user + " not in secondary database.");
        }
      }
    } else {
      return line + " has not been rated by any user.";
    }
    // DEBUG
    // io.debugread(sqSumdb);

    // calculate distance for each song in, inserting into the top 3 spots as we iterate through
    String ranked = rank(sqSumdb);
    return line + ", " + ranked;
  }
示例#14
0
  /**
   * Prints the results obtained by BerkeleyDB
   *
   * @throws DatabaseException whenever BerkeleyDB is violateed
   * @throws FileNotFoundException when .idx files not found or .txt files not found.
   * @throws ParseException when ParseDouble returns an error.
   */
  private void printResults() throws DatabaseException, FileNotFoundException, ParseException {

    // System.out.println("Num of indices before pprice rdate constraints: " + indices.size());
    if (indices.isEmpty()) {
      System.out.println("+=-=-=-=-=-=-=-=-=-=-=-=-=+");
      System.out.println("No results matching given query.");
      System.out.println("+=-=-=-=-=-=-=-=-=-=-=-=-=+");
    }

    Integer counter = 0;
    for (Integer index : indices) {

      OperationStatus oprStatus;
      Database std_db = new Database("rw.idx", null, null);
      Cursor std_cursor = std_db.openCursor(null, null); // Create new cursor object
      DatabaseEntry key = new DatabaseEntry();
      DatabaseEntry data = new DatabaseEntry();
      Product product = new Product();
      Review review = new Review();

      String searchkey = index.toString().toLowerCase();
      key.setData(searchkey.getBytes());
      key.setSize(searchkey.length());

      // Returns OperationStatus
      oprStatus = std_cursor.getSearchKey(key, data, LockMode.DEFAULT);
      Bill:
      {
        if (oprStatus == OperationStatus.SUCCESS) {
          String s = new String(data.getData());

          load_data(product, review, s);

          /** Filters low priority queue for pprice / rdate processes. */
          GenericStack<String> tmplow = new GenericStack<String>(lowpriorities);
          while (!tmplow.isEmpty()) {
            String subquery = tmplow.pop();

            if (subquery.matches("pprice.*")) {
              Double value =
                  Double.parseDouble(
                      subquery
                          .replace("pprice", "")
                          .replace(">", "")
                          .replace("=", "")
                          .replace("<", ""));

              if (product.getPrice().equals("unknown")) break Bill;
              if (subquery.matches("pprice<.*")
                  && !(Double.parseDouble(product.getPrice()) > value)) continue;
              else if (subquery.matches("pprice=.*")
                  && !(Double.parseDouble(product.getPrice()) == value)) continue;
              else if (subquery.matches("pprice>.*")
                  && !(Double.parseDouble(product.getPrice()) < value)) continue;
              else break Bill;

            } else if (subquery.matches("rdate.*")) {
              String comparator = subquery.substring(5, 6);
              DateFormat df = new SimpleDateFormat("yyyy/MM/dd hh:mm:ss");
              Date valuedate = df.parse(subquery.substring(6) + " 00:00:00");
              long valuedatedoesntmatataer =
                  (valuedate.getTime() / 1000)
                      - 25200; // delay set by 7hours - timezone difference.
              switch (comparator) {
                case "<":
                  if (!(Long.parseLong(review.getTime()) < valuedatedoesntmatataer)) {
                    break Bill;
                  } else {
                    break;
                  }
                case ">":
                  if (!(Long.parseLong(review.getTime()) > valuedatedoesntmatataer)) {
                    break Bill;
                  } else {
                    break;
                  }
                case "=":
                  if (!(Long.parseLong(review.getTime()) == valuedatedoesntmatataer)) {
                    break Bill;
                  } else {
                    break;
                  }
                default:
                  break Bill;
              }
            }
          }

          // System.out.print(" "+ index +" ");
          product.print();
          review.print();
          counter++;
        }
        std_cursor.close();
        std_db.close();
      }
    }
    System.out.println("+=-=-=-=-=-=-=-=-=-=-=-=-=+");
    System.out.println("Total records found: " + counter);
    System.out.println("+=-=-=-=-=-=-=-=-=-=-=-=-=+");
  }