Java UTF8Type类代码示例

import org.apache.cassandra.db.marshal.UTF8Type; //导入依赖的package包/类
public Columns deserialize(DataInputPlus in, CFMetaData metadata) throws IOException
{
    int length = (int)in.readUnsignedVInt();
    BTree.Builder<ColumnDefinition> builder = BTree.builder(Comparator.naturalOrder());
    builder.auto(false);
    for (int i = 0; i < length; i++)
    {
        ByteBuffer name = ByteBufferUtil.readWithVIntLength(in);
        ColumnDefinition column = metadata.getColumnDefinition(name);
        if (column == null)
        {
            // If we don't find the definition, it could be we have data for a dropped column, and we shouldn't
            // fail deserialization because of that. So we grab a "fake" ColumnDefinition that ensure proper
            // deserialization. The column will be ignore later on anyway.
            column = metadata.getDroppedColumnDefinition(name);
            if (column == null)
                throw new RuntimeException("Unknown column " + UTF8Type.instance.getString(name) + " during deserialization");
        }
        builder.add(column);
    }
    return new Columns(builder.build());
}
 

import org.apache.cassandra.db.marshal.UTF8Type; //导入依赖的package包/类
public ColumnIdentifier getIdentifier(CFMetaData cfm)
{
    if (!cfm.isStaticCompactTable())
        return ColumnIdentifier.getInterned(text, true);

    AbstractType<?> thriftColumnNameType = cfm.thriftColumnNameType();
    if (thriftColumnNameType instanceof UTF8Type)
        return ColumnIdentifier.getInterned(text, true);

    // We have a Thrift-created table with a non-text comparator. Check if we have a match column, otherwise assume we should use
    // thriftColumnNameType
    ByteBuffer bufferName = ByteBufferUtil.bytes(text);
    for (ColumnDefinition def : cfm.allColumns())
    {
        if (def.name.bytes.equals(bufferName))
            return def.name;
    }
    return ColumnIdentifier.getInterned(thriftColumnNameType, thriftColumnNameType.fromString(text), text);
}
 

import org.apache.cassandra.db.marshal.UTF8Type; //导入依赖的package包/类
public ColumnDefinition prepare(CFMetaData cfm)
{
    if (!cfm.isStaticCompactTable())
        return find(cfm);

    AbstractType<?> thriftColumnNameType = cfm.thriftColumnNameType();
    if (thriftColumnNameType instanceof UTF8Type)
        return find(cfm);

    // We have a Thrift-created table with a non-text comparator. Check if we have a match column, otherwise assume we should use
    // thriftColumnNameType
    ByteBuffer bufferName = ByteBufferUtil.bytes(text);
    for (ColumnDefinition def : cfm.allColumns())
    {
        if (def.name.bytes.equals(bufferName))
            return def;
    }
    return find(thriftColumnNameType.fromString(text), cfm);
}
 

import org.apache.cassandra.db.marshal.UTF8Type; //导入依赖的package包/类
@SuppressWarnings("unused")
private boolean insertInIndex(final String indexResourceType, Row row) {
	// only index in the correct lucene index.
	// this code checks if the resourceType is the same as the index.
	// TODO: externalizar resource_type

	for (Cell cell : row.cells()) {
		String columnname = cell.column().name.toString();
		if ("resource_type".equals(columnname)) {
			String resourceType = ByteBufferUtils.toString(cell.value(), UTF8Type.instance);

			if (indexResourceType.equals(resourceType)) {
				return true;
			}
			return false;
		}
	}
	return false;
}
 

import org.apache.cassandra.db.marshal.UTF8Type; //导入依赖的package包/类
private void validateAssignableTo(String keyspace, ColumnSpecification receiver) throws InvalidRequestException
{
    if (!(receiver.type instanceof UserType))
        throw new InvalidRequestException(String.format("Invalid user type literal for %s of type %s", receiver, receiver.type.asCQL3Type()));

    UserType ut = (UserType)receiver.type;
    for (int i = 0; i < ut.size(); i++)
    {
        ColumnIdentifier field = new ColumnIdentifier(ut.fieldName(i), UTF8Type.instance);
        Term.Raw value = entries.get(field);
        if (value == null)
            continue;

        ColumnSpecification fieldSpec = fieldSpecOf(receiver, i);
        if (!value.isAssignableTo(keyspace, fieldSpec))
            throw new InvalidRequestException(String.format("Invalid user type literal for %s: field %s is not of type %s", receiver, field, fieldSpec.type.asCQL3Type()));
    }
}
 

import org.apache.cassandra.db.marshal.UTF8Type; //导入依赖的package包/类
public ColumnIdentifier prepare(CFMetaData cfm)
{
    AbstractType<?> comparator = cfm.comparator.asAbstractType();
    if (cfm.getIsDense() || comparator instanceof CompositeType || comparator instanceof UTF8Type)
        return new ColumnIdentifier(text, true);

    // We have a Thrift-created table with a non-text comparator.  We need to parse column names with the comparator
    // to get the correct ByteBuffer representation.  However, this doesn't apply to key aliases, so we need to
    // make a special check for those and treat them normally.  See CASSANDRA-8178.
    ByteBuffer bufferName = ByteBufferUtil.bytes(text);
    for (ColumnDefinition def : cfm.partitionKeyColumns())
    {
        if (def.name.bytes.equals(bufferName))
            return new ColumnIdentifier(text, true);
    }
    return new ColumnIdentifier(comparator.fromString(rawText), text);
}
 

import org.apache.cassandra.db.marshal.UTF8Type; //导入依赖的package包/类
public Set<PermissionDetails> list(AuthenticatedUser performer, Set<Permission> permissions, IResource resource, String of)
throws RequestValidationException, RequestExecutionException
{
    if (!performer.isSuper() && !performer.getName().equals(of))
        throw new UnauthorizedException(String.format("You are not authorized to view %s's permissions",
                                                      of == null ? "everyone" : of));

    Set<PermissionDetails> details = new HashSet<PermissionDetails>();

    for (UntypedResultSet.Row row : process(buildListQuery(resource, of)))
    {
        if (row.has(PERMISSIONS))
        {
            for (String p : row.getSet(PERMISSIONS, UTF8Type.instance))
            {
                Permission permission = Permission.valueOf(p);
                if (permissions.contains(permission))
                    details.add(new PermissionDetails(row.getString(USERNAME),
                                                      DataResource.fromName(row.getString(RESOURCE)),
                                                      permission));
            }
        }
    }

    return details;
}
 

import org.apache.cassandra.db.marshal.UTF8Type; //导入依赖的package包/类
@Test
public void differentKeyRowMutations() throws ConfigurationException, InvalidRequestException
{
    CFMetaData metadata = makeCfMetaData("ks1", "cf1", TriggerDefinition.create("test", DifferentKeyTrigger.class.getName()));
    ColumnFamily cf = makeCf(metadata, "v1", null);
    Mutation rm = new Mutation(UTF8Type.instance.fromString("k1"), cf);

    List<? extends IMutation> tmutations = new ArrayList<>(TriggerExecutor.instance.execute(Arrays.asList(rm)));
    assertEquals(2, tmutations.size());
    Collections.sort(tmutations, new RmComparator());

    assertEquals(bytes("k1"), tmutations.get(0).key());
    assertEquals(bytes("otherKey"), tmutations.get(1).key());

    List<ColumnFamily> mutatedCFs = new ArrayList<>(tmutations.get(0).getColumnFamilies());
    assertEquals(1, mutatedCFs.size());
    assertEquals(bytes("v1"), mutatedCFs.get(0).getColumn(getColumnName(metadata, "c1")).value());
    assertNull(mutatedCFs.get(0).getColumn(getColumnName(metadata, "c2")));

    mutatedCFs = new ArrayList<>(tmutations.get(1).getColumnFamilies());
    assertEquals(1, mutatedCFs.size());
    assertNull(mutatedCFs.get(0).getColumn(getColumnName(metadata, "c1")));
    assertEquals(bytes("trigger"), mutatedCFs.get(0).getColumn(getColumnName(metadata, "c2")).value());
}
 

import org.apache.cassandra.db.marshal.UTF8Type; //导入依赖的package包/类
protected Map<ByteBuffer, ColumnGroupMap> readRequiredRows(List<ByteBuffer> partitionKeys, ColumnNameBuilder clusteringPrefix, boolean local, ConsistencyLevel cl)
throws RequestExecutionException, RequestValidationException
{
    // Lists SET operation incurs a read.
    Set<ByteBuffer> toRead = null;
    for (Operation op : columnOperations)
    {
        if (op.requiresRead())
        {
            if (toRead == null)
                toRead = new TreeSet<ByteBuffer>(UTF8Type.instance);
            toRead.add(op.columnName.key);
        }
    }

    return toRead == null ? null : readRows(partitionKeys, clusteringPrefix, toRead, (CompositeType)cfm.comparator, local, cl);
}
 

import org.apache.cassandra.db.marshal.UTF8Type; //导入依赖的package包/类
@Test
public void caseInsensitiveAnalizer() throws Exception
{
    NonTokenizingAnalyzer analyzer = new NonTokenizingAnalyzer();
    NonTokenizingOptions options = NonTokenizingOptions.getDefaultOptions();
    options.setCaseSensitive(false);
    analyzer.init(options, UTF8Type.instance);

    String testString = "Nip it in the bud";
    ByteBuffer toAnalyze = ByteBuffer.wrap(testString.getBytes());
    analyzer.reset(toAnalyze);
    ByteBuffer analyzed = null;
    while (analyzer.hasNext())
        analyzed = analyzer.next();
    Assert.assertTrue(testString.toLowerCase().equals(ByteBufferUtil.string(analyzed)));
}
 

import org.apache.cassandra.db.marshal.UTF8Type; //导入依赖的package包/类
@Test
public void testSuperBlockRetrieval() throws Exception
{
    OnDiskIndexBuilder builder = new OnDiskIndexBuilder(UTF8Type.instance, LongType.instance, OnDiskIndexBuilder.Mode.SPARSE);
    for (long i = 0; i < 100000; i++)
        builder.add(LongType.instance.decompose(i), keyAt(i), i);

    File index = File.createTempFile("on-disk-sa-multi-superblock-match", ".db");
    index.deleteOnExit();

    builder.finish(index);

    OnDiskIndex onDiskIndex = new OnDiskIndex(index, LongType.instance, new KeyConverter());

    testSearchRangeWithSuperBlocks(onDiskIndex, 0, 500);
    testSearchRangeWithSuperBlocks(onDiskIndex, 300, 93456);
    testSearchRangeWithSuperBlocks(onDiskIndex, 210, 1700);
    testSearchRangeWithSuperBlocks(onDiskIndex, 530, 3200);

    Random random = new Random(0xdeadbeef);
    for (int i = 0; i < 100000; i += random.nextInt(1500)) // random steps with max of 1500 elements
    {
        for (int j = 0; j < 3; j++)
            testSearchRangeWithSuperBlocks(onDiskIndex, i, ThreadLocalRandom.current().nextInt(i, 100000));
    }
}
 

import org.apache.cassandra.db.marshal.UTF8Type; //导入依赖的package包/类
@Test
public void testSatisfiedByWithMultipleTerms()
{
    final ByteBuffer comment = UTF8Type.instance.decompose("comment");
    final ColumnFamilyStore store = Keyspace.open("sasecondaryindex").getColumnFamilyStore("saindexed1");
    final IPartitioner<?> partitioner = StorageService.getPartitioner();

    ColumnFamily cf = ArrayBackedSortedColumns.factory.create(store.metadata);
    cf.addColumn(new Column(comment, UTF8Type.instance.decompose("software engineer is working on a project"), System.currentTimeMillis()));

    Operation.Builder builder = new Operation.Builder(OperationType.AND, UTF8Type.instance, controller,
                                        new IndexExpression(comment, IndexOperator.EQ, UTF8Type.instance.decompose("eng is a work")));
    Operation op = builder.complete();

    Assert.assertTrue(op.satisfiedBy(new Row(partitioner.decorateKey(UTF8Type.instance.decompose("key1")), cf), null, false));

    builder = new Operation.Builder(OperationType.AND, UTF8Type.instance, controller,
                                        new IndexExpression(comment, IndexOperator.EQ, UTF8Type.instance.decompose("soft works fine")));
    op = builder.complete();

    Assert.assertTrue(op.satisfiedBy(new Row(partitioner.decorateKey(UTF8Type.instance.decompose("key1")), cf), null, false));
}
 

import org.apache.cassandra.db.marshal.UTF8Type; //导入依赖的package包/类
private List<ByteBuffer> rowToJson(List<ByteBuffer> row, int protocolVersion)
{
    StringBuilder sb = new StringBuilder("{");
    for (int i = 0; i < metadata.names.size(); i++)
    {
        if (i > 0)
            sb.append(", ");

        ColumnSpecification spec = metadata.names.get(i);
        String columnName = spec.name.toString();
        if (!columnName.equals(columnName.toLowerCase(Locale.US)))
            columnName = "\"" + columnName + "\"";

        ByteBuffer buffer = row.get(i);
        sb.append('"');
        sb.append(Json.quoteAsJsonString(columnName));
        sb.append("\": ");
        if (buffer == null)
            sb.append("null");
        else
            sb.append(spec.type.toJSONString(buffer, protocolVersion));
    }
    sb.append("}");
    return Collections.singletonList(UTF8Type.instance.getSerializer().serialize(sb.toString()));
}
 

import org.apache.cassandra.db.marshal.UTF8Type; //导入依赖的package包/类
private void validateAssignableTo(String keyspace, ColumnSpecification receiver) throws InvalidRequestException
{
    if (!(receiver.type instanceof UserType))
        throw new InvalidRequestException(String.format("Invalid user type literal for %s of type %s", receiver, receiver.type.asCQL3Type()));

    UserType ut = (UserType)receiver.type;
    for (int i = 0; i < ut.size(); i++)
    {
        ColumnIdentifier field = new ColumnIdentifier(ut.fieldName(i), UTF8Type.instance);
        Term.Raw value = entries.get(field);
        if (value == null)
            continue;

        ColumnSpecification fieldSpec = fieldSpecOf(receiver, i);
        if (!value.testAssignment(keyspace, fieldSpec).isAssignable())
            throw new InvalidRequestException(String.format("Invalid user type literal for %s: field %s is not of type %s", receiver, field, fieldSpec.type.asCQL3Type()));
    }
}
 

import org.apache.cassandra.db.marshal.UTF8Type; //导入依赖的package包/类
public ColumnIdentifier prepare(CFMetaData cfm)
{
    if (!cfm.isStaticCompactTable())
        return getInterned(text, true);

    AbstractType<?> thriftColumnNameType = cfm.thriftColumnNameType();
    if (thriftColumnNameType instanceof UTF8Type)
        return getInterned(text, true);

    // We have a Thrift-created table with a non-text comparator. Check if we have a match column, otherwise assume we should use
    // thriftColumnNameType
    ByteBuffer bufferName = ByteBufferUtil.bytes(text);
    for (ColumnDefinition def : cfm.allColumns())
    {
        if (def.name.bytes.equals(bufferName))
            return def.name;
    }
    return getInterned(thriftColumnNameType.fromString(rawText), text);
}