CfDef cf = new CfDef(); cf.setName(docColumnFamily); cf.setComparator_type("BytesType"); cf.setKey_cache_size(0); cf.setRow_cache_size(0); KsDef solandraKS = new KsDef() .setName(keySpace) .setStrategy_class("org.apache.cassandra.locator.SimpleStrategy") .setStrategy_options(strategyOptions) .setCf_defs(cfs);
private void ensureColumnFamilyExists(String ksName, String cfName, String comparator) throws BackendException { CTConnection conn = null; try { KsDef keyspaceDef = ensureKeyspaceExists(ksName); conn = pool.borrowObject(ksName); Cassandra.Client client = conn.getClient(); log.debug("Looking up metadata on keyspace {}...", ksName); boolean foundColumnFamily = false; for (CfDef cfDef : keyspaceDef.getCf_defs()) { String curCfName = cfDef.getName(); if (curCfName.equals(cfName)) foundColumnFamily = true; } if (!foundColumnFamily) { createColumnFamily(client, ksName, cfName, comparator); } else { log.debug("Keyspace {} and ColumnFamily {} were found.", ksName, cfName); } } catch (SchemaDisagreementException e) { throw new TemporaryBackendException(e); } catch (Exception e) { throw new PermanentBackendException(e); } finally { pool.returnObjectUnsafe(ksName, conn); } }
private static void checkRfsMatchConfig(KsDef ks, CassandraKeyValueServiceConfig config, Set<String> dcs, Map<String, String> strategyOptions) { for (String datacenter : dcs) { if (Integer.parseInt(strategyOptions.get(datacenter)) != config.replicationFactor()) { throw new UnsupportedOperationException("Your current Cassandra keyspace (" + ks.getName() + ") has a replication factor not matching your Atlas Cassandra configuration." + " Change them to match, but be mindful of what steps you'll need to" + " take to correctly repair or cleanup existing data in your cluster."); } } } }
client.set_keyspace(keyspaceName); // Don't remove client.set_keyspace(SYSTEM_KS); log.debug("Found existing keyspace {}", keyspaceName); } catch (InvalidRequestException e) { KsDef ksdef = new KsDef().setName(keyspaceName) .setCf_defs(new LinkedList<CfDef>()) // cannot be null but can be empty .setStrategy_class(storageConfig.get(REPLICATION_STRATEGY)) .setStrategy_options(strategyOptions); client.set_keyspace(SYSTEM_KS); try { client.system_add_keyspace(ksdef);
public KsDef toThrift() { KsDef def = new KsDef(name, strategyClass, ThriftCfDef.toThriftList(cfDefs)); def.setStrategy_options(strategyOptions); def.setDurable_writes(durableWrites ); return def; }
CfDef professionalCfDef = new CfDef(); professionalCfDef.name = COLUMN_FAMILY_PROFESSIONAL; professionalCfDef.keyspace = _KEYSPACE; professionalCfDef.setComparator_type("UTF8Type"); professionalCfDef.setKey_validation_class("UTF8Type"); ColumnDef departmentDef = new ColumnDef(ByteBuffer.wrap("DEPARTMENT_ID".getBytes()), "LongType"); departmentDef.index_type = IndexType.KEYS; ColumnDef exceptionalDef = new ColumnDef(ByteBuffer.wrap("IS_EXCEPTIONAL".getBytes()), "BooleanType"); exceptionalDef.index_type = IndexType.KEYS; ColumnDef enrolmentDateDef = new ColumnDef(ByteBuffer.wrap("ENROLMENT_DATE".getBytes()), "DateType"); enrolmentDateDef.index_type = IndexType.KEYS; ksDef = CassandraCli.client.describe_keyspace(_KEYSPACE); CassandraCli.client.set_keyspace(_KEYSPACE); List<CfDef> cfDefn = ksDef.getCf_defs(); if (cfDef1.getName().equalsIgnoreCase(COLUMN_FAMILY_PROFESSIONAL)) CassandraCli.client.system_drop_column_family(COLUMN_FAMILY_PROFESSIONAL); ksDef = new KsDef(_KEYSPACE, "org.apache.cassandra.locator.SimpleStrategy", cfDefs); Map<String, String> strategy_options = new HashMap<String, String>(); strategy_options.put("replication_factor", "1"); ksDef.setStrategy_options(strategy_options); CassandraCli.client.system_add_keyspace(ksDef);
CfDef user_Def = new CfDef(); user_Def.name = "users"; user_Def.keyspace = "KunderaExamples"; user_Def.setComparator_type("UTF8Type"); user_Def.setDefault_validation_class("UTF8Type"); user_Def.setKey_validation_class("UTF8Type"); ColumnDef columnDef = new ColumnDef(ByteBuffer.wrap("birth_date".getBytes()), "Int32Type"); columnDef.index_type = IndexType.KEYS; user_Def.addToColumn_metadata(columnDef); ColumnDef columnDef1 = new ColumnDef(ByteBuffer.wrap("state".getBytes()), "UTF8Type"); columnDef1.index_type = IndexType.KEYS; user_Def.addToColumn_metadata(columnDef1); ColumnDef columnDef2 = new ColumnDef(ByteBuffer.wrap("full_name".getBytes()), "UTF8Type"); columnDef2.index_type = IndexType.KEYS; user_Def.addToColumn_metadata(columnDef2); cfDefs.add(user_Def); ksDef = new KsDef("KunderaExamples", "org.apache.cassandra.locator.SimpleStrategy", cfDefs); CassandraCli.client.system_add_keyspace(ksDef);
private static KsDef setKeySpaceOptions(String keyspace) { KsDef ksDef = new KsDef(); ksDef.setName(keyspace); Map<String, Object> ksOptions = ServerConfig.getInstance().ks_defaults; if (ksOptions != null) { m_logger.warn("Unknown KeySpace option: {} -- ignoring", name); } else { ksDef.setFieldValue(field, value); if (!ksDef.isSetStrategy_class()) { ksDef.setStrategy_class(DEFAULT_KS_STRATEGY_CLASS); if (!ksDef.isSetStrategy_options()) { Map<String, String> stratOpts = new HashMap<>(); stratOpts.put("replication_factor", DEFAULT_KS_REPLICATION_FACTOR); ksDef.setStrategy_options(stratOpts); if (!ksDef.isSetCf_defs()) { ksDef.setCf_defs(DEFAULT_KS_CF_DEFS); if (!ksDef.isSetDurable_writes()) { ksDef.setDurable_writes(DEFAULT_KS_DURABLE_WRITES);
case NAME: if (value == null) { unsetName(); } else { setName((String)value); unsetStrategy_class(); } else { setStrategy_class((String)value); unsetStrategy_options(); } else { setStrategy_options((Map<String,String>)value); unsetReplication_factor(); } else { setReplication_factor((Integer)value); unsetCf_defs(); } else { setCf_defs((List<CfDef>)value); unsetDurable_writes(); } else { setDurable_writes((Boolean)value);
/** * Creates keyspace. * * @throws Exception * the exception */ private void createKeyspace() throws Exception { if (cql_version != null && cql_version.equals(CassandraConstants.CQL_VERSION_3_0)) { onCql3CreateKeyspace(); } else { Map<String, String> strategy_options = new HashMap<String, String>(); List<CfDef> cfDefs = new ArrayList<CfDef>(); KsDef ksDef = new KsDef(databaseName, csmd.getPlacement_strategy(databaseName), cfDefs); setProperties(ksDef, strategy_options); ksDef.setStrategy_options(strategy_options); cassandra_client.system_add_keyspace(ksDef); } }
Assert.assertTrue(CassandraCli.keyspaceExist("KunderaCoreExmples")); Assert.assertTrue(CassandraCli.columnFamilyExist("CassandraEntitySimple", "KunderaCoreExmples")); org.apache.cassandra.thrift.KsDef ksDef = new KsDef(); ksDef = client.describe_keyspace("KunderaCoreExmples"); Assert.assertEquals(1, ksDef.getCf_defs().size()); for (org.apache.cassandra.thrift.CfDef cfDef : ksDef.getCf_defs()) if ("CassandraEntitySimple".equals(cfDef.getName())) Assert.assertEquals("CassandraEntitySimple", cfDef.getName()); Assert.assertEquals(2, cfDef.getColumn_metadata().size()); List<String> columns = new ArrayList<String>(); columns.add("AGE"); for (ColumnDef columnDef : cfDef.getColumn_metadata()) if (new String(columnDef.getName(), Constants.ENCODING).equals("AGE")) Assert.assertTrue(columnDef.isSetIndex_type()); Assert.assertTrue(columns.contains(new String(columnDef.getName(), Constants.ENCODING))); Assert.assertEquals(IndexType.KEYS, columnDef.index_type);
KsDef ksDef = new KsDef(ksDefToUpdate); ksDef.setCf_defs(new LinkedList<CfDef>()); ksDef.setStrategy_class(CliUtils.unescapeSQLString(mValue)); break; case STRATEGY_OPTIONS: ksDef.setStrategy_options(getStrategyOptionsFromTree(statement.getChild(i + 1))); break; case DURABLE_WRITES: ksDef.setDurable_writes(Boolean.parseBoolean(mValue)); break; default: if (ksDef.getStrategy_class().contains(".NetworkTopologyStrategy")) Map<String, String> currentStrategyOptions = ksDef.getStrategy_options(); ksDef.setStrategy_options(options);
@Override public KeyspaceDefinition addColumnFamily(ColumnFamilyDefinition cfDef) { if (ks_def.getCf_defs() == null) { ks_def.setCf_defs(new ArrayList<CfDef>()); } CfDef thriftCfDef = ((ThriftColumnFamilyDefinitionImpl) cfDef).getThriftColumnFamilyDefinition(); thriftCfDef.setColumn_type("Standard"); thriftCfDef.setKeyspace(ks_def.getName()); ks_def.getCf_defs().add(thriftCfDef); return this; }
client.set_keyspace("KunderaCoreExmples"); org.apache.cassandra.thrift.CfDef cf_def = new org.apache.cassandra.thrift.CfDef("KunderaCoreExmples", "CassandraEntitySimple"); cf_def.column_type = "Standard"; client.system_add_column_family(cf_def); org.apache.cassandra.thrift.CfDef actor = new org.apache.cassandra.thrift.CfDef("KunderaCoreExmples", "Actor"); actor.column_type = "Super"; client.system_add_column_family(actor); Assert.assertTrue(CassandraCli.columnFamilyExist("CassandraEntitySimple", "KunderaCoreExmples")); org.apache.cassandra.thrift.KsDef ksDef = client.describe_keyspace("KunderaCoreExmples"); for (org.apache.cassandra.thrift.CfDef cfDef : ksDef.getCf_defs()) if ("CassandraEntitySimple".equals(cfDef.getName())) Assert.assertEquals("CassandraEntitySimple", cfDef.getName()); for (ColumnDef columnDef : cfDef.getColumn_metadata()) Assert.assertFalse(columnDef.isSetIndex_type()); Assert.assertTrue(columns.contains(new String(columnDef.getName(), Constants.ENCODING))); Assert.assertNull(columnDef.index_name); Assert.fail("failed caused by:" + e1.getMessage());
public Object getFieldValue(_Fields field) { switch (field) { case NAME: return getName(); case STRATEGY_CLASS: return getStrategy_class(); case STRATEGY_OPTIONS: return getStrategy_options(); case REPLICATION_FACTOR: return Integer.valueOf(getReplication_factor()); case CF_DEFS: return getCf_defs(); case DURABLE_WRITES: return Boolean.valueOf(isDurable_writes()); } throw new IllegalStateException(); }
if (!cf.getKeyspace().equals(ks_def.getName())) throw new InvalidRequestException("CfDef (" + cf.getName() +") had a keyspace definition that did not match KsDef"); for (CfDef cf_def : ks_def.cf_defs) cf_def.unsetId(); // explicitly ignore any id set by client (same as system_add_column_family) CFMetaData cfm = ThriftConversion.fromThrift(cf_def);
public OperationResult<SchemaChangeResult> internalCreateKeyspace(final KsDef ksDef) throws ConnectionException { if (ksDef.getCf_defs() == null) ksDef.setCf_defs(Lists.<CfDef>newArrayList()); return executeDdlOperation( new AbstractOperationImpl<SchemaChangeResult>( tracerFactory.newTracer(CassandraOperationType.ADD_KEYSPACE)) { @Override public SchemaChangeResult internalExecute(Client client, ConnectionContext context) throws Exception { precheckSchemaAgreement(client); return new SchemaChangeResponseImpl().setSchemaId(client.system_add_keyspace(ksDef)); } }, RunOnce.get()); }
@Test public void test() throws NotFoundException, InvalidRequestException, TException, UnsupportedEncodingException { getEntityManagerFactory("create"); Assert.assertTrue(CassandraCli.keyspaceExist("KunderaCoreExmples")); Assert.assertTrue(CassandraCli.columnFamilyExist("Actor", "KunderaCoreExmples")); org.apache.cassandra.thrift.KsDef ksDef = new KsDef(); ksDef = client.describe_keyspace("KunderaCoreExmples"); Assert.assertEquals(2, ksDef.getCf_defs().size()); for (org.apache.cassandra.thrift.CfDef cfDef : ksDef.getCf_defs()) { if ("Actor".equals(cfDef.getName())) { Assert.assertEquals("Standard", cfDef.column_type); } } }
@Override public Map<String, String> getCompressionOptions(String cf) throws BackendException { CTConnection conn = null; Map<String, String> result = null; try { conn = pool.borrowObject(keySpaceName); Cassandra.Client client = conn.getClient(); KsDef ksDef = client.describe_keyspace(keySpaceName); for (CfDef cfDef : ksDef.getCf_defs()) { if (null != cfDef && cfDef.getName().equals(cf)) { result = cfDef.getCompression_options(); break; } } return result; } catch (InvalidRequestException e) { log.debug("Keyspace {} does not exist", keySpaceName); return null; } catch (Exception e) { throw new TemporaryBackendException(e); } finally { pool.returnObjectUnsafe(keySpaceName, conn); } }
public ThriftKeyspaceDefinitionImpl() { ks_def = new KsDef(); ks_def.setCf_defs(new ArrayList<CfDef>()); }