Ejemplo n.º 1
0
CassFuture* CassandraFS::create_dir_entry(const char* path, mode_t mode) {
    CassStatement* statement = cass_statement_new("INSERT INTO entries(path, mode, created_at, modified_at) VALUES(?,?,?,?)", 4);

    cass_statement_bind_string(statement, 0, path);
    cass_statement_bind_int32(statement, 1, mode);
    cass_statement_bind_int64(statement, 2, time(NULL)*1000);
    cass_statement_bind_int64(statement, 3, time(NULL)*1000);

    CassFuture* result_future = cass_session_execute(ctxt->session, statement);

    cass_statement_free(statement);

    return result_future;
}
Ejemplo n.º 2
0
CassError insert_into_basic(CassSession* session, const char* key, const Basic* basic) {
  CassError rc = CASS_OK;
  CassStatement* statement = NULL;
  CassFuture* future = NULL;
  const char* query = "INSERT INTO examples.basic (key, bln, flt, dbl, i32, i64) VALUES (?, ?, ?, ?, ?, ?);";

  statement = cass_statement_new(query, 6);

  cass_statement_bind_string(statement, 0, key);
  cass_statement_bind_bool(statement, 1, basic->bln);
  cass_statement_bind_float(statement, 2, basic->flt);
  cass_statement_bind_double(statement, 3, basic->dbl);
  cass_statement_bind_int32(statement, 4, basic->i32);
  cass_statement_bind_int64(statement, 5, basic->i64);

  future = cass_session_execute(session, statement);
  cass_future_wait(future);

  rc = cass_future_error_code(future);
  if (rc != CASS_OK) {
    print_error(future);
  }

  cass_future_free(future);
  cass_statement_free(statement);

  return rc;
}
Ejemplo n.º 3
0
void on_create_table(CassFuture* future, void* data) {
  const char* insert_query = "INSERT INTO callbacks (key, value) "
                             "VALUES (?, ?)";
  CassUuid key;
  CassStatement* statement = NULL;
  CassFuture* insert_future = NULL;

  CassError code = cass_future_error_code(future);
  if (code != CASS_OK) {
    print_error(future);
  }

  statement = cass_statement_new(insert_query, 2);

  cass_uuid_gen_time(uuid_gen, &key);
  cass_statement_bind_uuid(statement, 0, key);
  cass_statement_bind_int64(statement, 1, cass_uuid_timestamp(key));

  insert_future = cass_session_execute((CassSession*)data, statement);

  cass_future_set_callback(insert_future, on_insert, data);

  cass_statement_free(statement);
  cass_future_free(insert_future);
}
Ejemplo n.º 4
0
  bool execute_insert(CassSession* session, const std::string& table_name) {
    std::string query = str(boost::format("INSERT INTO %s (id, event_time, text_sample) VALUES (?, ?, ?)") % table_name);
    test_utils::CassStatementPtr statement(cass_statement_new(query.c_str(), 3));

    // Determine if bound parameters can be used based on C* version
    if (version.major == 1) {
      test_utils::CassPreparedPtr prepared = test_utils::prepare(session, query.c_str());
      statement = test_utils::CassStatementPtr(cass_prepared_bind(prepared.get()));
    }

    boost::chrono::system_clock::time_point now(boost::chrono::system_clock::now());
    boost::chrono::milliseconds event_time(boost::chrono::duration_cast<boost::chrono::milliseconds>(now.time_since_epoch()));
    std::string text_sample(test_utils::string_from_time_point(now));

    cass_statement_bind_uuid(statement.get(), 0, test_utils::generate_time_uuid(uuid_gen));
    cass_statement_bind_int64(statement.get(), 1, event_time.count());
    cass_statement_bind_string(statement.get(), 2, text_sample.c_str());

    test_utils::CassFuturePtr future(cass_session_execute(session, statement.get()));
    cass_future_wait(future.get());
    CassError code = cass_future_error_code(future.get());
    if (code != CASS_OK && code != CASS_ERROR_LIB_REQUEST_TIMED_OUT) { // Timeout is okay
      CassString message;
      cass_future_error_message(future.get(), &message.data, &message.length);
      fprintf(stderr, "Error occurred during insert '%.*s'\n", static_cast<int>(message.length), message.data);
      return false;
    }

    return true;
  }
Ejemplo n.º 5
0
CassError insert_into(CassSession* session, const char* key) {
  CassError rc = CASS_OK;
  CassStatement* statement = NULL;
  CassFuture* future = NULL;
  cass_uint32_t d;
  cass_int64_t t;
  const char* query = "INSERT INTO examples.date_time (key, d, t) VALUES (?, ?, ?);";
  time_t now = time(NULL);

  d = cass_date_from_epoch(now);
  t = cass_time_from_epoch(now);

  statement = cass_statement_new(query, 3);

  cass_statement_bind_string(statement, 0, key);
  cass_statement_bind_uint32(statement, 1, d);
  cass_statement_bind_int64(statement, 2, t);

  future = cass_session_execute(session, statement);
  cass_future_wait(future);

  rc = cass_future_error_code(future);
  if (rc != CASS_OK) {
    print_error(future);
  }

  cass_future_free(future);
  cass_statement_free(statement);

  return rc;
}
Ejemplo n.º 6
0
CassFuture* CassandraFS::update_file_length(CassUuid* physical_file_id, long size) {
    CassStatement* statement = cass_statement_new("UPDATE physical_files SET size = ? WHERE id = ?", 2);
    cass_statement_bind_int64(statement, 0, size);
    cass_statement_bind_uuid(statement, 1, *physical_file_id);

    CassFuture* result_future = cass_session_execute(ctxt->session, statement);
    cass_statement_free(statement);

    return result_future;
}
Ejemplo n.º 7
0
    bool bind_and_execute_insert(CassStatement* statement) {
        boost::chrono::system_clock::time_point now(boost::chrono::system_clock::now());
        boost::chrono::milliseconds event_time(boost::chrono::duration_cast<boost::chrono::milliseconds>(now.time_since_epoch()));
        std::string text_sample(test_utils::string_from_time_point(now));

        cass_statement_bind_uuid(statement, 0, test_utils::generate_time_uuid(uuid_gen));
        cass_statement_bind_int64(statement, 1, event_time.count());
        cass_statement_bind_string_n(statement, 2, text_sample.data(), text_sample.size());

        return execute_insert(statement);
    }
Ejemplo n.º 8
0
int CassandraFS::update_timestamps(const char* path, const struct timespec last_access_stamp, const struct timespec last_modification_stamp) {
    CassStatement* statement = cass_statement_new("UPDATE entries SET modified_at = ? WHERE path = ?", 2);
    cass_statement_bind_int64(statement, 0, last_modification_stamp.tv_sec * 1000 + (last_modification_stamp.tv_nsec / 1000000));
    cass_statement_bind_string(statement, 1, path);

    CassFuture* result_future = cass_session_execute(ctxt->session, statement);
    cass_statement_free(statement);
    int error = 0;

    if (cass_future_error_code(result_future) == CASS_OK) {
        // Nada
    } else {
        /* Handle error */
        error = -EIO;
        cassandra_log_error(result_future);
    }
    cass_future_free(result_future);
        
    return error;
}
Ejemplo n.º 9
0
  /// ATM only supports (key, value) inserts
  void asyncInsert(const std::string &table,
                   const int64_t &key,
                   const std::string &value) {
    if(!connected_) {
      LOG(FATAL)
        << "asyncInsert failed, establish connection to cassandra first";
    } else if(futures_.size() > kMaxNumQueuedFutures) {
      VLOG(1) << "asyncInsert, queue has reached capacity, draining...";
      wait();
    }

    const auto tableName = keyspace_ + "." + table;
    const auto query("INSERT INTO " + tableName + " (key, value) "
                     + "VALUES (?, ?);");
    auto statement = createStatement(cass_statement_new(query.c_str(), 2));
    cass_statement_bind_int64(statement.get(), 0, (cass_int64_t)key);
    cass_statement_bind_string(statement.get(), 1, value.data());

    futures_.emplace(cass_session_execute(session_.get(), statement.get()),
                     cass_future_free);
  }
Ejemplo n.º 10
0
int CassandraFS::truncate(const char* path, off_t size) {
    CassStatement* statement = NULL;
    struct stat stat;
    struct cfs_attrs cfs_attrs;
    CassandraFutureSpool* spool = new CassandraFutureSpool(4);
    
    int err = getattr(path, &stat, &cfs_attrs);

    if (err != 0) {
        return -EIO;
    }

    statement = cass_statement_new("UPDATE physical_files SET size = ? WHERE id = ?", 2);
    cass_statement_bind_int64(statement, 0, size);
    cass_statement_bind_uuid(statement, 1, cfs_attrs.physical_file_id);
    spool->append(cass_session_execute(ctxt->session, statement));
    cass_statement_free(statement);
    
    off_t current_size = stat.st_size;
    int current_blocks = blocks_needed(current_size, cfs_attrs.block_size);
    int needed_blocks = blocks_needed(size, cfs_attrs.block_size);
    
    for (int a = needed_blocks; a<current_blocks; a++) {
        spool->append(delete_file_block(&stat, &cfs_attrs, a));
    }

    if (size % cfs_attrs.block_size > 0) {
        spool->append(truncate_block(&stat, &cfs_attrs, needed_blocks-1, size % cfs_attrs.block_size));
    }
    
    spool->wait_all();
    int errors = spool->get_errors();
    delete spool;
    
    if (errors>0) {
        return -EIO;
    }

    return 0;
}
Ejemplo n.º 11
0
void insert_into_async(CassSession* session, const char* key) {
  CassError rc = CASS_OK;
  CassStatement* statement = NULL;
  const char* query = "INSERT INTO async (key, bln, flt, dbl, i32, i64) VALUES (?, ?, ?, ?, ?, ?);";

  CassFuture* futures[NUM_CONCURRENT_REQUESTS];

  size_t i;
  for (i = 0; i < NUM_CONCURRENT_REQUESTS; ++i) {
     char key_buffer[64];
    statement = cass_statement_new(query, 6);

    sprintf(key_buffer, "%s%u", key, (unsigned int)i);
    cass_statement_bind_string(statement, 0, key_buffer);
    cass_statement_bind_bool(statement, 1, i % 2 == 0 ? cass_true : cass_false);
    cass_statement_bind_float(statement, 2, i / 2.0f);
    cass_statement_bind_double(statement, 3, i / 200.0);
    cass_statement_bind_int32(statement, 4, (cass_int32_t)(i * 10));
    cass_statement_bind_int64(statement, 5, (cass_int64_t)(i * 100));

    futures[i] = cass_session_execute(session, statement);

    cass_statement_free(statement);
  }

  for (i = 0; i < NUM_CONCURRENT_REQUESTS; ++i) {
    CassFuture* future = futures[i];

    cass_future_wait(future);

    rc = cass_future_error_code(future);
    if (rc != CASS_OK) {
      print_error(future);
    }

    cass_future_free(future);
  }
}
Ejemplo n.º 12
0
 void bindInt64(unsigned idx, __int64 value)
 {
     if (query.length())
         traceBind(idx, "%" I64F "d", value);
     check(cass_statement_bind_int64(statement, idx, value));
 }
Ejemplo n.º 13
0
void InsertThread::run() {

	// CONNECT TO CASSANDRA

	CassCluster* cluster;
	CassSession* session;
	if (!CassConnectToKeyspace("127.0.0.1", "chaos", "'class': 'SimpleStrategy', 'replication_factor': 1", &cluster, &session)) {
		// free resources
		CassFreeClusterAndSession(cluster, session);
		return;
	}// if error ...

	// INSERTING NUMBERS

	const CassPrepared *preparedInsert = NULL;
	CassFuture* prefuture = cass_session_prepare(session, "INSERT INTO test (group, num, minimize) VALUES (?, ?, ?) IF NOT EXISTS");
	cass_future_wait(prefuture);
	CassError prerc = cass_future_error_code(prefuture);
	if (prerc != CASS_OK) {
		CassPrintError(prefuture);
		// free resources
		cass_future_free(prefuture);
		CassFreeClusterAndSession(cluster, session);
		return;
	} else
		preparedInsert = cass_future_get_prepared(prefuture);
	cass_future_free(prefuture);

	int group;
	unsigned long minimize;
	CassStatement* statement;
	CassFuture* future;
	CassError rcI;

	while (GetNextNum()) {
		group = num % 1000000;
		minimize = num;

		statement = cass_prepared_bind(preparedInsert);
		cass_statement_bind_int32(statement, 0, group);
		cass_statement_bind_int64(statement, 1, num);
		cass_statement_bind_int64(statement, 2, minimize);

		future = cass_session_execute(session, statement);
		cass_future_wait(future);
		rcI = cass_future_error_code(future);

		if (rcI != CASS_OK) {
			CassPrintError(future);
		}// if error ...

		cass_future_free(future);
		cass_statement_free(statement);
		
		// stop loop on error
		if (rcI != CASS_OK) break;

		// show progress on console
		if ((num % 3751) == 0) printf("%lu\n", num);
	}// foreach num ...

	// free resources
	cass_prepared_free(preparedInsert);
	CassFreeClusterAndSession(cluster, session);
}
Ejemplo n.º 14
0
 static CassError bind(CassStatement* statement, size_t index, cass_int64_t value) {
   return cass_statement_bind_int64(statement, index, value);
 }
Ejemplo n.º 15
0
int CassandraFS::hardlink(const char* from, const char* to) {
    int operation_done = 0;
    CassStatement* statement = cass_statement_new("SELECT mode, created_at, modified_at, physical_file_id FROM entries WHERE path = ?", 1);
    cass_statement_bind_string(statement, 0, from);

    CassFuture* result_future = cass_session_execute(ctxt->session, statement);
    cass_statement_free(statement);
    int error = 0;

    if (cass_future_error_code(result_future) == CASS_OK) {
		/* Retrieve result set and iterate over the rows */
		const CassResult* result = cass_future_get_result(result_future);
		CassIterator* rows = cass_iterator_from_result(result);

		if (cass_iterator_next(rows)) {
		    const CassRow* row = cass_iterator_get_row(rows);
		    const CassValue* mode_value = cass_row_get_column_by_name(row, "mode");
		    const CassValue* modified_at_value = cass_row_get_column_by_name(row, "modified_at");
		    const CassValue* created_at_value = cass_row_get_column_by_name(row, "created_at");
		    const CassValue* physical_file_id_value = cass_row_get_column_by_name(row, "physical_file_id");

		    int mode;
		    cass_value_get_int32(mode_value, &mode);

		    cass_int64_t modified_at;
		    cass_value_get_int64(modified_at_value, &modified_at);

		    cass_int64_t created_at;
		    cass_value_get_int64(created_at_value, &created_at);

            CassUuid physical_file_id;
		    cass_value_get_uuid(physical_file_id_value, &physical_file_id);

            CassStatement* insert_statement = cass_statement_new("INSERT INTO entries(path, mode, created_at, modified_at, physical_file_id) VALUES(?,?,?,?,?)", 5);
            cass_statement_bind_string(insert_statement, 0, to);
            cass_statement_bind_int32(insert_statement, 1, mode);
            cass_statement_bind_int64(insert_statement, 2, created_at);
            cass_statement_bind_int64(insert_statement, 3, modified_at);
            cass_statement_bind_uuid(insert_statement, 4, physical_file_id);
            
            CassFuture* insert_future2 = create_sub_entry(to);

            CassFuture* insert_future = cass_session_execute(ctxt->session, insert_statement);
            cass_statement_free(insert_statement);
            if (cass_future_error_code(insert_future) == CASS_OK) {
                operation_done = 1;
            } else {
                operation_done = 0;
                cassandra_log_error(insert_future);
            }

            if (cass_future_error_code(insert_future2) == CASS_OK) {
                operation_done = 1;
            } else {
                operation_done = 0;
                cassandra_log_error(insert_future2);
            }

            cass_future_free(insert_future);
            cass_future_free(insert_future2);

		}
	    
		cass_result_free(result);
		cass_iterator_free(rows);
    } else {
		/* Handle error */
        error = -EIO;
		cassandra_log_error(result_future);
    }
    cass_future_free(result_future);
    
    if (!operation_done) {
		return -ENOENT;
	}

    return error;
}