Java KeyspaceMetadata類代碼示例

import com.datastax.driver.core.KeyspaceMetadata; //導入依賴的package包/類
/**
 * Insert a row with a raw User-defined type.
 */
@Test
public void insertRawUdt() {

	KeyspaceMetadata keyspaceMetadata = adminOperations.getKeyspaceMetadata();
	UserType address = keyspaceMetadata.getUserType("address");

	UDTValue udtValue = address.newValue();
	udtValue.setString("street", "308 Negra Arroyo Lane");
	udtValue.setString("zip", "87104");
	udtValue.setString("city", "Albuquerque");

	Person person = new Person();
	person.setId(42);
	person.setFirstname("Walter");
	person.setLastname("White");

	person.setAlternative(udtValue);

	operations.insert(person);

	Person loaded = operations.selectOne("SELECT * FROM person WHERE id = 42", Person.class);

	assertThat(loaded.getAlternative().getString("zip")).isEqualTo("87104");
}
 

import com.datastax.driver.core.KeyspaceMetadata; //導入依賴的package包/類
/**
 * {@inheritDoc}
 */
@Override
public TableInfo get(@Nonnull @NonNull final ConnectorRequestContext context,
                     @Nonnull @NonNull final QualifiedName name) {
    final String keyspace = name.getDatabaseName();
    final String table = name.getTableName();
    log.debug("Attempting to get metadata for Cassandra table {}.{} for request {}", keyspace, table, context);
    try {
        final KeyspaceMetadata keyspaceMetadata = this.getCluster().getMetadata().getKeyspace(keyspace);
        if (keyspaceMetadata == null) {
            throw new DatabaseNotFoundException(name);
        }
        final TableMetadata tableMetadata = keyspaceMetadata.getTable(table);
        if (tableMetadata == null) {
            throw new TableNotFoundException(name);
        }

        final TableInfo tableInfo = this.getTableInfo(name, tableMetadata);
        log.debug("Successfully got metadata for Cassandra table {}.{} for request {}", keyspace, table, context);
        return tableInfo;
    } catch (final DriverException de) {
        log.error(de.getMessage(), de);
        throw this.getExceptionMapper().toConnectorException(de, name);
    }
}
 

import com.datastax.driver.core.KeyspaceMetadata; //導入依賴的package包/類
/**
 * {@inheritDoc}
 */
@Override
public DatabaseInfo get(
    @Nonnull @NonNull final ConnectorRequestContext context,
    @Nonnull @NonNull final QualifiedName name
) {
    final String keyspace = name.getDatabaseName();
    log.debug("Attempting to get keyspace metadata for keyspace {} for request {}", keyspace, context);
    try {
        final KeyspaceMetadata keyspaceMetadata = this.getCluster().getMetadata().getKeyspace(keyspace);
        if (keyspaceMetadata == null) {
            throw new DatabaseNotFoundException(name);
        }

        log.debug("Successfully found the keyspace metadata for {} for request {}", name, context);
        return DatabaseInfo.builder().name(name).build();
    } catch (final DriverException de) {
        log.error(de.getMessage(), de);
        throw this.getExceptionMapper().toConnectorException(de, name);
    }
}
 

import com.datastax.driver.core.KeyspaceMetadata; //導入依賴的package包/類
/**
 * Checks if the main table exists in the database.
 * @param appid name of the {@link com.erudika.para.core.App}
 * @return true if the table exists
 */
public static boolean existsTable(String appid) {
	if (StringUtils.isBlank(appid)) {
		return false;
	}
	if (cluster == null) {
		throw new IllegalStateException("Cassandra client not initialized.");
	}
	try {
		KeyspaceMetadata ks = cluster.getMetadata().getKeyspace(DBNAME);
		TableMetadata table = ks.getTable(getTableNameForAppid(appid));
		return table != null && table.getName() != null;
	} catch (Exception e) {
		return false;
	}
}
 

import com.datastax.driver.core.KeyspaceMetadata; //導入依賴的package包/類
private static void initializeUDTs(Session session) {
  Schema.ensureExists(DEFAULT_KEYSPACE + "_udts", session);
  MappingManager mapping = new MappingManager(session);

  // The UDTs are hardcoded against the zipkin keyspace.
  // If a different keyspace is being used the codecs must be re-applied to this different keyspace
  TypeCodec<TraceIdUDT> traceIdCodec = mapping.udtCodec(TraceIdUDT.class);
  TypeCodec<EndpointUDT> endpointCodec = mapping.udtCodec(EndpointUDT.class);
  TypeCodec<AnnotationUDT> annoCodec = mapping.udtCodec(AnnotationUDT.class);
  TypeCodec<BinaryAnnotationUDT> bAnnoCodec = mapping.udtCodec(BinaryAnnotationUDT.class);

  KeyspaceMetadata keyspace =
      session.getCluster().getMetadata().getKeyspace(session.getLoggedKeyspace());

  session.getCluster().getConfiguration().getCodecRegistry()
      .register(
          new TypeCodecImpl(keyspace.getUserType("trace_id"), TraceIdUDT.class, traceIdCodec))
      .register(
          new TypeCodecImpl(keyspace.getUserType("endpoint"), EndpointUDT.class, endpointCodec))
      .register(
          new TypeCodecImpl(keyspace.getUserType("annotation"), AnnotationUDT.class, annoCodec))
      .register(
          new TypeCodecImpl(keyspace.getUserType("binary_annotation"), BinaryAnnotationUDT.class,
              bAnnoCodec));
}
 

import com.datastax.driver.core.KeyspaceMetadata; //導入依賴的package包/類
static Metadata readMetadata(Session session) {
  KeyspaceMetadata keyspaceMetadata = getKeyspaceMetadata(session);

  Map<String, String> replication = keyspaceMetadata.getReplication();
  if ("SimpleStrategy".equals(replication.get("class")) && "1".equals(
      replication.get("replication_factor"))) {
    LOG.warn("running with RF=1, this is not suitable for production. Optimal is 3+");
  }
  String compactionClass =
      keyspaceMetadata.getTable("traces").getOptions().getCompaction().get("class");
  boolean hasDefaultTtl = hasUpgrade1_defaultTtl(keyspaceMetadata);
  if (!hasDefaultTtl) {
    LOG.warn("schema lacks default ttls: apply {}, or set CassandraStorage.ensureSchema=true",
        UPGRADE_1);
  }
  return new Metadata(compactionClass, hasDefaultTtl);
}
 

import com.datastax.driver.core.KeyspaceMetadata; //導入依賴的package包/類
public boolean insertRow(String tablename, Map<String, Object> valuesMap, Map<String, String> consistencyInfo, JsonInsert insObj) throws Exception {
	// Note: https://docs.datastax.com/en/cql/3.0/cql/cql_reference/insert_r.html
	String[] parts = tablename.split("\\.");
	KeyspaceMetadata ks = cluster.getMetadata().getKeyspace(parts[0]);
	TableMetadata tableInfo =  ks.getTable(parts[1]);

	StringBuilder fields = new StringBuilder();
	StringBuilder values = new StringBuilder();
	String prefix = "";
	for (String key : valuesMap.keySet()) {
		fields.append(prefix).append(key);
		Object valueObj  = valuesMap.get(key);
		DataType colType = tableInfo.getColumn(key).getType();
		values.append(prefix).append(convertToSqlDataType(colType, valueObj));
		prefix = ", ";
	}

	String suffix = getTTLSuffix(insObj);
	String query = String.format("INSERT INTO %s (%s) VALUES (%s)%s;", tablename, fields.toString(), values.toString(), suffix);
	LOG.debug(query);

	String consistency = extractConsistencyInfo(tablename, consistencyInfo);
	executeCreateQuery(query, consistency);
	return false;
}
 

import com.datastax.driver.core.KeyspaceMetadata; //導入依賴的package包/類
protected void createColumnFamily() {
    final String ks = getKeySpace();
    final String cf = getColumnFamily();

    final KeyspaceMetadata keySpaceMeta = this.cluster.getMetadata().getKeyspace(ks);
    final TableMetadata tableMetadata = keySpaceMeta.getTable(cf);

    // check if the table exists
    if (tableMetadata != null) {
        return;
    }

    final String stmt = String.format("CREATE TABLE %s (\n" +
            "  " + KEY_COLUMN + " text,\n" +
            "  " + COLL_COLUMN + " blob,\n" +
            "  PRIMARY KEY (" + KEY_COLUMN + ")\n" +
            ");", cf);

    getSession().execute(stmt);
}
 

import com.datastax.driver.core.KeyspaceMetadata; //導入依賴的package包/類
protected void initCassandraClient() {
  if(keyspace == null) {
    keyspace = DEFAULT_KEYSPACE;
  }

  if(cluster == null) {
    cluster = Cluster.builder()
      .addContactPoint(cassandraContactPoint)
      .withTimestampGenerator(new AtomicMonotonicTimestampGenerator())
      .build();
    hasOpenedCluster = true;
  }

  // make sure the keyspace exists (create it with default replication settings otherwise)
  KeyspaceMetadata existingKeyspace = cluster.getMetadata().getKeyspace("camunda");
  if(existingKeyspace == null) {
    final Session session = cluster.connect();
    session.execute(String.format("CREATE keyspace %s WITH REPLICATION = { 'class' : 'SimpleStrategy', 'replication_factor' : " + replicationFactor + " };", keyspace));
    session.close();
  }

  if(session == null) {
    session = cluster.connect(keyspace);
  }
}
 

import com.datastax.driver.core.KeyspaceMetadata; //導入依賴的package包/類
private TableMetadata getTableMetadata(SchemaTableName schemaTableName)
{
    String schemaName = schemaTableName.getSchemaName();
    String tableName = schemaTableName.getTableName();

    KeyspaceMetadata keyspaceMetadata = getCheckedKeyspaceMetadata(schemaName);
    TableMetadata tableMetadata = keyspaceMetadata.getTable(tableName);
    if (tableMetadata != null) {
        return tableMetadata;
    }

    for (TableMetadata table : keyspaceMetadata.getTables()) {
        if (table.getName().equalsIgnoreCase(tableName)) {
            return table;
        }
    }
    throw new TableNotFoundException(schemaTableName);
}
 

import com.datastax.driver.core.KeyspaceMetadata; //導入依賴的package包/類
@Test
public void schemaUpdatesTableShouldNotBeCreatedIfExists() throws Exception {
    //given
    cluster.connect("system").execute("CREATE KEYSPACE " + TEST_KEYSPACE + " WITH replication = {'class': 'SimpleStrategy', 'replication_factor': 1 };");
    Session session = cluster.connect(TEST_KEYSPACE);
    SessionContext sessionContext = new SessionContext(session, ConsistencyLevel.ALL, ConsistencyLevel.ALL, clusterHealth);
    SchemaUpdates schemaUpdates = new SchemaUpdates(sessionContext, TEST_KEYSPACE);

    //when
    schemaUpdates.initialise();

    try {
        schemaUpdates.initialise();
    } catch (AlreadyExistsException exception) {
        fail("Expected " + SCHEMA_UPDATES_TABLE + " table creation to be attempted only once.");
    }
    //then
    KeyspaceMetadata keyspaceMetadata = cluster.getMetadata().getKeyspace(TEST_KEYSPACE);
    assertThat(keyspaceMetadata.getTable(SCHEMA_UPDATES_TABLE)).as("table should have been created").isNotNull();
}
 

import com.datastax.driver.core.KeyspaceMetadata; //導入依賴的package包/類
public  CassandraMetadataResultSet makeSchemas(CassandraStatement statement, String schemaPattern) throws SQLException
{
	
	// TABLE_SCHEM String => schema name
    // TABLE_CATALOG String => catalog name (may be null)
	
	final ArrayList<MetadataRow> schemas = Lists.newArrayList();
	List<KeyspaceMetadata> keyspaces = statement.connection.getClusterMetadata().getKeyspaces();
	
	for(KeyspaceMetadata keyspace:keyspaces){
		if ("%".equals(schemaPattern)) schemaPattern = null;
		if((schemaPattern==null?keyspace.getName():schemaPattern).equals(keyspace.getName())){
			MetadataRow row = new MetadataRow().addEntry("TABLE_SCHEM", keyspace.getName()).addEntry("TABLE_CATALOG", statement.connection.getCatalog());
			schemas.add(row);
		}
		
	}
   
    CassandraMetadataResultSet result = new CassandraMetadataResultSet(statement,new MetadataResultSet().setRows(schemas));
    return result;
	    	
}
 

import com.datastax.driver.core.KeyspaceMetadata; //導入依賴的package包/類
public List<Column> getSchema(String keySpace, String tableName) {
	Metadata m = session.getCluster().getMetadata();
	KeyspaceMetadata km = m.getKeyspace(keySpace);
	if (km == null)
		return null;
	TableMetadata tm = km.getTable(tableName);
	if (tm == null)
		return null;
	// build schema
	List<Column> columns = new LinkedList<Column>();
	for (ColumnMetadata cm : tm.getColumns()) {
		if (!meta.contains(cm.getName()))
			columns.add(Column.newBuilder().setName(cm.getName())
					.setType(toSimbaType(cm.getType().toString())).build());
	}

	return columns;

}
 

import com.datastax.driver.core.KeyspaceMetadata; //導入依賴的package包/類
@Override
public void output( Collection<Metric> metrics ) {
    if( metrics.size() == 0 ) {
        return;
    }

    Map<RetentionTable, BatchStatement> stms = LazyMap.<RetentionTable, BatchStatement>lazyMap( new HashMap<>(), () -> new BatchStatement() );
    for ( Metric metric : metrics ) {
        insertMetricIntoBatch( metric, stms );
    }
    KeyspaceMetadata metadata = cluster.getMetadata().getKeyspace( keyspace );
    for (RetentionTable table : stms.keySet()) {
        createTableIfNecessary( table, metadata );
    }
    for ( BatchStatement batch : stms.values() ) {
        try {
            session.execute( batch );
        } catch ( WriteTimeoutException e ) {
            log.info( "WriteTimeoutException while sending Metrics to cassandra." );
            log.info( e.getMessage() );
            log.info( "According to http://www.datastax.com/dev/blog/how-cassandra-deals-with-replica-failure, this is harmless" );
        }
    }
    EventBusManager.fire( new DrainMetricOutputEvent( ( new PersistentCassandraDrainFactory<>().handledType() ), metrics.size() ) );
}
 

import com.datastax.driver.core.KeyspaceMetadata; //導入依賴的package包/類
private void createTableIfNecessary( RetentionTable table, KeyspaceMetadata metadata ) {
    for ( TableMetadata meta : metadata.getTables()) {
        log.debug( "Comparing " + meta.getName() + " with " + table.tableName() );
        if ( meta.getName().equalsIgnoreCase( table.tableName() )) {
            return;
        }
    }
     
    StringBuilder query = new StringBuilder();
    query.append( "CREATE TABLE " ).append( table.tableName() ).append( " (" );
    query.append( COL_NAME ).append( " text, " );
    query.append( COL_TIME ).append( " bigint, " );
    query.append( COL_VALUE ).append( " double, " );
    query.append( "PRIMARY KEY (" ).append( COL_NAME ).append( ", " ).append( COL_TIME ).append( ")");
    query.append( ");" );
    log.debug( "Creating table with query: <" + query.toString() + ">");
    try {
        session.execute( query.toString() );
    } catch( AlreadyExistsException e ) {
        // Some other gatherer might have already created the same table.
    }
}