Beispiel #1
0
static void
createTableFunc(std::string t, HbaseClient client)
{
    // Create the demo table with two column families, entry: and unused:
    ColVec columns;
    columns.push_back(ColumnDescriptor());
    columns.back().name = "entry:";
    columns.back().maxVersions = 10;
    columns.push_back(ColumnDescriptor());
    columns.back().name = "unused:";

    std::cout << "creating table: " << t << std::endl;
    try {
      // テーブル t の作成, カラムは上で作成
      client.createTable(t, columns);
    } catch (const AlreadyExists &ae) {
      std::cerr << "WARN: " << ae.message << std::endl;
    }
}
Beispiel #2
0
int main(int argc, char** argv) {
  if (argc < 6) {
    std::cerr << "Invalid arguments!\n" << "Usage: testput host port key_len val_len list_num" << std::endl;
    return -1;
  }
  HbCli myhbcli(argv[1], argv[2]);
 
  myhbcli.connect();
   
  std::string table("test_table");
  ColVec columns;
  columns.push_back(ColumnDescriptor());
  columns.back().name = "entry:";
  columns.back().maxVersions = 1;
  columns.back().compression = "LZO";
  columns.back().inMemory = true;
  columns.back().blockCacheEnabled = true;
  columns.back().bloomFilterType = "ROW";
  columns.back().timeToLive = 3 * 24 * 3600;
  if (!myhbcli.tableExists(table))
    myhbcli.createTable(table, columns);
 
  int klen = atoi(argv[3]);
  int vlen = atoi(argv[4]);
  int lnum = atoi(argv[5]);
  long actual_ms = 0;
  struct timeval tvstart, tvend;
  gettimeofday(&tvstart, NULL);
  if (lnum == 1)
    actual_ms = test_row_put(myhbcli, table, klen, vlen);
  else
    actual_ms = test_row_put_list(myhbcli, table, klen, vlen, lnum);
  gettimeofday(&tvend, NULL);
  long total_ms = gen_ms(tvstart, tvend);
  std::cout << "total time in ms: " << total_ms << std::endl;
  std::cout << "actual time in ms: " << actual_ms << std::endl;
  std::cout << "qps in total time: " << (long)(COUNT*1000)/total_ms << std::endl;
  std::cout << "qps in actual time: " << (long)(COUNT*1000)/actual_ms << std::endl;
  
  myhbcli.deleteTable(table);
  
  myhbcli.disconnect();
}
Beispiel #3
0
extern "C" int test_table()
{
    char buf[8][1024];
    int i;
    bool isFramed = false;
    bool tmptable = false;
    boost::shared_ptr<TTransport> socket(new TSocket("localhost", 9090));
    boost::shared_ptr<TTransport> transport;
    if (isFramed)
    {
        transport.reset(new TFramedTransport(socket));
    }
    else
    {
        transport.reset(new TBufferedTransport(socket));
    }
    boost::shared_ptr<TProtocol> protocol(new TBinaryProtocol(transport));

    const std::map<Text, Text>  dummyAttributes; // see HBASE-6806 HBASE-4658
    HbaseClient client(protocol);
    try
    {
        transport->open();
        std::string t[]= {"T1","T2","T3","T4","T5","T6","T7","T8"};
        StrVec tables;
        client.getTableNames(tables);

        for(i=0; i<8; i++)
        {
            tmptable = false;
            StrVec::const_iterator it = tables.begin();
            for (StrVec::const_iterator it = tables.begin(); it != tables.end(); ++it)
            {
                if (t[i] == *it)
                {
                    tmptable = true;
                }
            }
            if(!tmptable)//创建表
            {
                ColVec columns;
                columns.push_back(ColumnDescriptor());
                columns.back().name = "PROTOCOL";
                columns.push_back(ColumnDescriptor());
                columns.back().name = "INPUT_SNMP";
                columns.push_back(ColumnDescriptor());
                columns.back().name = "OUTPUT_SNMP";
                columns.push_back(ColumnDescriptor());
                columns.back().name = "IN_PKTS";
                columns.push_back(ColumnDescriptor());
                columns.back().name = "IN_BYTES";
                columns.push_back(ColumnDescriptor());
                columns.back().name = "SRC_TOS";
                columns.push_back(ColumnDescriptor());
                columns.back().name = "SRC_AS";
                columns.push_back(ColumnDescriptor());
                columns.back().name = "DST_AS";
                columns.push_back(ColumnDescriptor());
                columns.back().name = "TCP_FLAGS";
                std::cout << "creating table: " << t[i] << std::endl;
                try
                {
                    client.createTable(t[i], columns);
                }
                catch (const AlreadyExists &ae)
                {
                    std::cerr << "WARN: " << ae.message << std::endl;
                }
            }
        }
    }
    catch (const TException &tx)
    {
        std::cerr << "ERROR: " << tx.what() << std::endl;
    }
    return 0;
}
Beispiel #4
0
int 
main(int argc, char** argv) 
{
  if (argc < 3) {
    std::cerr << "Invalid arguments!\n" << "Usage: DemoClient host port" << std::endl;
    return -1;
  }

  boost::shared_ptr<TTransport> socket(new TSocket(argv[1], boost::lexical_cast<int>(argv[2])));
  boost::shared_ptr<TTransport> transport(new TBufferedTransport(socket));
  boost::shared_ptr<TProtocol> protocol(new TBinaryProtocol(transport));
  HbaseClient client(protocol);

  try {
    transport->open();

    std::string t("demo_table");

    //
    // Scan all tables, look for the demo table and delete it.
    //
    std::cout << "scanning tables..." << std::endl;
    StrVec tables;
    client.getTableNames(tables);
    for (StrVec::const_iterator it = tables.begin(); it != tables.end(); ++it) {
      std::cout << "  found: " << *it << std::endl;
      if (t == *it) {
        if (client.isTableEnabled(*it)) {
          std::cout << "    disabling table: " << *it << std::endl;
          client.disableTable(*it);
        }
        std::cout << "    deleting table: " << *it << std::endl;
        client.deleteTable(*it);
      }
    }

    //
    // Create the demo table with two column families, entry: and unused:
    //
    ColVec columns;
    columns.push_back(ColumnDescriptor());
    columns.back().name = "entry:";
    columns.back().maxVersions = 10;
    columns.push_back(ColumnDescriptor());
    columns.back().name = "unused:";

    std::cout << "creating table: " << t << std::endl;
    try {
      client.createTable(t, columns);
    } catch (const AlreadyExists &ae) {
      std::cerr << "WARN: " << ae.message << std::endl;
    }

    ColMap columnMap;
    client.getColumnDescriptors(columnMap, t);
    std::cout << "column families in " << t << ": " << std::endl;
    for (ColMap::const_iterator it = columnMap.begin(); it != columnMap.end(); ++it) {
      std::cout << "  column: " << it->second.name << ", maxVer: " << it->second.maxVersions << std::endl;
    }

    //
    // Test UTF-8 handling
    //
    std::string invalid("foo-\xfc\xa1\xa1\xa1\xa1\xa1");
    std::string valid("foo-\xE7\x94\x9F\xE3\x83\x93\xE3\x83\xBC\xE3\x83\xAB");
    std::map<std::string, std::string> attrs;

    // non-utf8 is fine for data
    std::vector<Mutation> mutations;
    mutations.push_back(Mutation());
    mutations.back().column = "entry:foo";
    mutations.back().value = invalid;
    client.mutateRow(t, "foo", mutations, attrs);

    // try empty strings
    mutations.clear();
    mutations.push_back(Mutation());
    mutations.back().column = "entry:";
    mutations.back().value = "";
    client.mutateRow(t, "", mutations, attrs);

    // this row name is valid utf8
    mutations.clear();
    mutations.push_back(Mutation());
    mutations.back().column = "entry:foo";
    mutations.back().value = valid;
    client.mutateRow(t, valid, mutations, attrs);

    // non-utf8 is now allowed in row names because HBase stores values as binary
    mutations.clear();
    mutations.push_back(Mutation());
    mutations.back().column = "entry:foo";
    mutations.back().value = invalid;
    client.mutateRow(t, invalid, mutations, attrs);

    // Run a scanner on the rows we just created
    StrVec columnNames;
    columnNames.push_back("entry:");

    std::cout << "Starting scanner..." << std::endl;
    int scanner = client.scannerOpen(t, "", columnNames, attrs);
    try {
      while (true) {
        std::vector<TRowResult> value;
        client.scannerGet(value, scanner);
        if (value.size() == 0)
          break;
        printRow(value);
      }
    } catch (const IOError &ioe) {
      std::cerr << "FATAL: Scanner raised IOError" << std::endl;
    }

    client.scannerClose(scanner);
    std::cout << "Scanner finished" << std::endl;

    //
    // Run some operations on a bunch of rows.
    //
    for (int i = 100; i >= 0; --i) {
      // format row keys as "00000" to "00100"
      char buf[32];
      sprintf(buf, "%05d", i);
      std::string row(buf);
      std::vector<TRowResult> rowResult;

      mutations.clear();
      mutations.push_back(Mutation());
      mutations.back().column = "unused:";
      mutations.back().value = "DELETE_ME";
      client.mutateRow(t, row, mutations, attrs);
      client.getRow(rowResult, t, row, attrs);
      printRow(rowResult);
      client.deleteAllRow(t, row, attrs);

      mutations.clear();
      mutations.push_back(Mutation());
      mutations.back().column = "entry:num";
      mutations.back().value = "0";
      mutations.push_back(Mutation());
      mutations.back().column = "entry:foo";
      mutations.back().value = "FOO";
      client.mutateRow(t, row, mutations, attrs);
      client.getRow(rowResult, t, row, attrs);
      printRow(rowResult);

      // sleep to force later timestamp 
      poll(0, 0, 50);

      mutations.clear();
      mutations.push_back(Mutation());
      mutations.back().column = "entry:foo";
      mutations.back().isDelete = true;
      mutations.push_back(Mutation());
      mutations.back().column = "entry:num";
      mutations.back().value = "-1";
      client.mutateRow(t, row, mutations, attrs);
      client.getRow(rowResult, t, row, attrs);
      printRow(rowResult);

      mutations.clear();
      mutations.push_back(Mutation());
      mutations.back().column = "entry:num";
      mutations.back().value = boost::lexical_cast<std::string>(i);
      mutations.push_back(Mutation());
      mutations.back().column = "entry:sqr";
      mutations.back().value = boost::lexical_cast<std::string>(i*i);
      client.mutateRow(t, row, mutations, attrs);
      client.getRow(rowResult, t, row, attrs);
      printRow(rowResult);

      mutations.clear();
      mutations.push_back(Mutation());
      mutations.back().column = "entry:num";
      mutations.back().value = "-999";
      mutations.push_back(Mutation());
      mutations.back().column = "entry:sqr";
      mutations.back().isDelete = true;
      client.mutateRowTs(t, row, mutations, 1, attrs); // shouldn't override latest
      client.getRow(rowResult, t, row, attrs);
      printRow(rowResult);

      CellVec versions;
      client.getVer(versions, t, row, "entry:num", 10, attrs);
      printVersions(row, versions);
      assert(versions.size());
      std::cout << std::endl;

      try {
        std::vector<TCell> value;
        client.get(value, t, row, "entry:foo", attrs);
        if (value.size()) {
          std::cerr << "FATAL: shouldn't get here!" << std::endl;
          return -1;
        }
      } catch (const IOError &ioe) {
        // blank
      }
    }

    // scan all rows/columns

    columnNames.clear();
    client.getColumnDescriptors(columnMap, t);
    std::cout << "The number of columns: " << columnMap.size() << std::endl;
    for (ColMap::const_iterator it = columnMap.begin(); it != columnMap.end(); ++it) {
      std::cout << " column with name: " + it->second.name << std::endl;
      columnNames.push_back(it->second.name);
    }
    std::cout << std::endl;

    std::cout << "Starting scanner..." << std::endl;
    scanner = client.scannerOpenWithStop(t, "00020", "00040", columnNames, attrs);
    try {
      while (true) {
        std::vector<TRowResult> value;
        client.scannerGet(value, scanner);
        if (value.size() == 0)
          break;
        printRow(value);
      }
    } catch (const IOError &ioe) {
      std::cerr << "FATAL: Scanner raised IOError" << std::endl;
    }

    client.scannerClose(scanner);
    std::cout << "Scanner finished" << std::endl;

    transport->close();
  } catch (const TException &tx) {
    std::cerr << "ERROR: " << tx.what() << std::endl;
  }
}