How to use cassandra-driver - 10 common examples

it('sets default pool configuration', function () {
      // arrange
      const config = _.extend({}, getDefaultConfig());
      const configCopy = _.extend({}, config);
      const consistencyLevel = cql.types.consistencies.one;

      // act
      const instance = new Driver({ config: config });

      // assert
      assert.deepEqual(instance.poolConfig.contactPoints, configCopy.hosts, 'hosts should be passed through');
      assert.strictEqual(instance.poolConfig.keyspace, configCopy.keyspace, 'keyspace should be passed through');
      assert.strictEqual(instance.poolConfig.getAConnectionTimeout, configCopy.timeout, 'timeout should be passed through');
      assert.strictEqual(instance.poolConfig.version, configCopy.cqlVersion, 'cqlVersion should be passed through');
      assert.strictEqual(instance.poolConfig.limit, configCopy.limit, 'limit should be passed through');
      assert.strictEqual(instance.poolConfig.consistencyLevel, consistencyLevel, 'consistencyLevel should default to ONE');
    });

const url = require("url");
let myURL = url.parse(connectionString);
let auth = myURL.auth;
let splitAuth = auth.split(":");
let username = splitAuth[0];
let password = splitAuth[1];
let sslopts = myURL.protocol === "https:" ? {} : null;

// get contactPoints for the connection
let translator = new compose.ComposeAddressTranslator();
translator.setMap(mapList);

let authProvider = new cassandra.auth.PlainTextAuthProvider(username, password);
let uuid = require("uuid");

let client = new cassandra.Client({
    contactPoints: translator.getContactPoints(),
    policies: {
        addressResolution: translator
    },
    authProvider: authProvider,
    sslOptions: sslopts
});

// Add a word to the database
function addWord(word, definition) {
    return new Promise(function(resolve, reject) {
        client.execute(
            "INSERT INTO grand_tour.words(my_table_id, word, definition) VALUES(?,?,?)", [uuid.v4(), word, definition], { prepare: true },
            function(error, result) {
                if (error) {
                    console.log(error);

console.error("Please pass in the stock exchange symbol file");
    process.exit(1);
}
const filePath = process.argv[2];
try {
    var stats = fs.statSync(filePath);
    if (!stats.isFile()) {
        console.error('file not exist');
        process.exit(1);
    }
    // Read the JSON file
    var stocks = JSON.parse(fs.readFileSync(filePath, "utf-8"));
    var exchangeName = path.basename(filePath).split('.')[0];
    //var exchangeId = '';

    const client = new cassandra.Client({ contactPoints: [CASSANDRA_HOST], keyspace: CASSANDRA_KEYSPACE });
    async.series([
        function connect(next) {
            console.log('Connecting to Cassandra');
            client.connect(next);
        },
        /*
        function getExchangeId(next) {
            const query = 'SELECT exchange_id, exchange_name FROM exchange WHERE exchange_name = ?';
            client.execute(query, [exchangeName], { prepare: true }, function (err, result) {
                if (err) return next(err);
                var row = result.first();
                if (row !== null)
                    exchangeId = row.exchange_id;
                next();
            });
        },

async _createConnectionPool(poolConfig, waitForConnect) {
    const openRequestId = uuid.v4();

    this.logger.debug('priam.Driver: Creating new pool', {
      poolConfig: {
        keyspace: poolConfig.keyspace,
        contactPoints: poolConfig.contactPoints
      }
    });

    const pool = new cqlDriver.Client(this._getDataStaxPoolConfig(poolConfig));
    pool.storeConfig = poolConfig;
    pool.waiters = [];
    pool.isReady = false;
    pool.on('log', (level, message, data) => {
      this.emit('connectionLogged', level, message, data);
      // unrecoverable errors will yield error on execution, so treat these as warnings since they'll be retried
      // treat everything else as debug information.
      const logMethod = (level === 'error' || level === 'warning') ? 'warn' : 'debug';

      const metaData = {
        datastaxLogLevel: level
      };
      if (typeof data === 'string') {
        message += `: ${data}`;
      } else {
        metaData.data = data;

// Form service migration script
// Accepted arguments
// 1. contactPoints: IP with port of DB
// 2. username: username for DB // optional
// 3. password: password for DB // optional
// example: node migration.js 11.7.1.7:9200 username password

const cassandra = require('cassandra-driver');
let cassandraClientOptions = { contactPoints: [process.argv[2]] };
if(process.argv[3] && process.argv[4]){
  cassandraClientOptions.authProvider = new cassandra.auth.PlainTextAuthProvider(process.argv[3], process.argv[4]);
}
console.log('connecting to DB with', process.argv[2], process.argv[3], process.argv[4]);
const client = new cassandra.Client(cassandraClientOptions);

let transformed_data = [];
let dest_obj = {
  root_org: undefined,
  framework: undefined,
  type: undefined,
  subtype: undefined,
  component: undefined,
  action: undefined,
  created: new Date(),
  last_modified: undefined,
  data: undefined
}

/* Copyright (c) 2016 Juniper Networks, Inc. All rights reserved. */

var _ = require("lodash");
var fs = require('fs')
var commonUtils = require(process.mainModule.exports.corePath + "/src/serverroot/utils/common.utils");
var configUtils = require(process.mainModule.exports.corePath +
        "/src/serverroot/common/config.utils");
var cassandra = require("cassandra-driver");

var uddKeyspace = "config_webui";
var tableName = "user_widgets";
var config = configUtils.getConfig();
var cass_options = { contactPoints: config.cassandra.server_ips, keyspace: "system" };
if (config.cassandra.username && config.cassandra.password) {
    var cAuthProvider = new cassandra.auth.PlainTextAuthProvider(config.cassandra.username, config.cassandra.password);
    cass_options.authProvider = cAuthProvider;
}
if (config.cassandra.use_ssl) {
    cass_options.sslOptions = { rejectUnauthorized: false };
    if ('ca_certs' in config.cassandra && config.cassandra.ca_certs) {
        cass_options.sslOptions.ca = [ fs.readFileSync(config.cassandra.ca_certs) ];
    }
}
var client = new cassandra.Client(cass_options);
client.execute("SELECT keyspace_name FROM system_schema.keyspaces;", function(err, result) {
    if (err) {
        console.error(err);
        return;
    }
    if (_.isEmpty(_.filter(result.rows, ["keyspace_name", uddKeyspace]))) {
        // if (client.metadata.keyspaces[uddKeyspace]) {

ret = value;
  }
  return ret;
}

function tupleFromArray(value) {
  var ret = null;
  if (Array.isArray(value)) {
    ret = originalTupleFromArray(value);
  } else {
    ret = value;
  }
  return ret;
}

var originalFromString = cassandra.types.Uuid.fromString;
var originalTimeFromString = cassandra.types.TimeUuid.fromString;
var originalTupleFromArray = cassandra.types.Tuple.fromArray;
cassandra.types.Uuid.fromString = uuidFromString;
cassandra.types.TimeUuid.fromString = timeUuidFromString;
cassandra.types.Tuple.fromArray = tupleFromArray;

/**
 * @module loopback-connector-cassandra
 *
 * Initialize the Cassandra connector against the given data source
 *
 * @param {DataSource} dataSource The loopback-datasource-juggler dataSource
 * @param {Function} [callback] The callback function
 */
exports.initialize = function initializeDataSource(dataSource, callback) {
  dataSource.driver = cassandra; // Provide access to the native driver

"use strict";

var P = require('bluebird');
var cass = require('cassandra-driver');
var TimeUuid = cass.types.TimeUuid;
var extend = require('extend');
var dbu = require('./dbutils');
var cassID = dbu.cassID;
var secIndexes = require('./secondaryIndexes');


function DB (client, options) {
    this.conf = options.conf;
    this.log = options.log;

    this.defaultConsistency = cass.types.consistencies[this.conf.defaultConsistency]
        || cass.types.consistencies.one;

    // cassandra client
    this.client = client;

self.createIfMissing = !!params.createIfMissing;
        self.table = params.table || 'tiles';
        self.repclass = params.repclass || 'SimpleStrategy';
        self.repfactor = typeof params.repfactor === 'undefined' ? 3 : parseInt(params.repfactor);
        let dw = params.durablewrite;
        self.durablewrite = (typeof dw === 'undefined' || (dw && dw !== 'false' && dw !== '0')) ? 'true' : 'false';
        self.minzoom = typeof params.minzoom === 'undefined' ? 0 : parseInt(params.minzoom);
        self.maxzoom = typeof params.maxzoom === 'undefined' ? 22 : parseInt(params.maxzoom);
        self.blocksize = typeof params.blocksize === 'undefined' ? 32768 : parseInt(params.blocksize);
        self.maxBatchSize = typeof params.maxBatchSize === 'undefined' ? undefined : parseInt(params.maxBatchSize);
        self.setLastModified = !!params.setLastModified;
        self.copyInfoFrom = params.copyInfoFrom;

        let clientOpts = {contactPoints: self.contactPoints};
        if (params.username || params.password) {
            clientOpts.authProvider = new cassandra.auth.PlainTextAuthProvider(params.username, params.password);
            // make sure not to expose it in the error reporting
            delete params.password;
        }
        self.client = new cassandra.Client(clientOpts);
        return self.client.connectAsync();
    }).then(() => {
        if (!self.createIfMissing) {

},
  protocolOptions: {
    port: cassandraPort,
  },
  socketOptions: {
    connectTimeout: 10000, // milliseconds
    readTimeout: 60000 // milliseconds
  },
  queryOptions: {
    autoPage: true,
    prepare: true,
    fetchSize: fetchSize
  }
};
if (cassandraUsername && cassandraPassword) {
  options.authProvider = new cassandra.auth.PlainTextAuthProvider(cassandraUsername, cassandraPassword);
}
const client = new cassandra.Client(options);

const status = {
  isInitialized: false
};

/**
 * @param {Array<{query: string, params: Array}>} mutations
 * @returns {Promise}
 */
function executeBatchMutations(mutations) {
  return new Promise((resolve, reject) => {
    if (!client) {
      loggingClient.logCassandraClientUndefined();
      return reject('No DB client available');