Java BytesType.instance方法代码示例

import org.apache.cassandra.db.marshal.BytesType; //导入方法依赖的package包/类
public static Function makeFromBlobFunction(final AbstractType<?> toType)
{
    final String name = "blobas" + toType.asCQL3Type();
    return new AbstractFunction(name, toType, BytesType.instance)
    {
        public ByteBuffer execute(List<ByteBuffer> parameters) throws InvalidRequestException
        {
            ByteBuffer val = parameters.get(0);
            try
            {
                if (val != null)
                    toType.validate(val);
                return val;
            }
            catch (MarshalException e)
            {
                throw new InvalidRequestException(String.format("In call to function %s, value 0x%s is not a valid binary representation for type %s",
                                                                name, ByteBufferUtil.bytesToHex(val), toType.asCQL3Type()));
            }
        }
    };
}
 

import org.apache.cassandra.db.marshal.BytesType; //导入方法依赖的package包/类
@Test
public void testComparisonMethod()
{
    ThreadLocalRandom random = ThreadLocalRandom.current();
    byte[] commonBytes = new byte[10];
    byte[] aBytes = new byte[16];
    byte[] bBytes = new byte[16];
    for (int i = 0 ; i < 100000 ; i++)
    {
        int commonLength = random.nextInt(0, 10);
        random.nextBytes(commonBytes);
        random.nextBytes(aBytes);
        random.nextBytes(bBytes);
        System.arraycopy(commonBytes, 0, aBytes, 0, commonLength);
        System.arraycopy(commonBytes, 0, bBytes, 0, commonLength);
        int aLength = random.nextInt(commonLength, 16);
        int bLength = random.nextInt(commonLength, 16);
        ColumnIdentifier a = new ColumnIdentifier(ByteBuffer.wrap(aBytes, 0, aLength), BytesType.instance);
        ColumnIdentifier b = new ColumnIdentifier(ByteBuffer.wrap(bBytes, 0, bLength), BytesType.instance);
        Assert.assertEquals("" + i, compareResult(a.compareTo(b)), compareResult(ByteBufferUtil.compareUnsigned(a.bytes, b.bytes)));
    }
}
 

import org.apache.cassandra.db.marshal.BytesType; //导入方法依赖的package包/类
protected Writer(int keysToSave)
{
    if (keysToSave >= getKeySet().size())
        keys = getKeySet();
    else
        keys = hotKeySet(keysToSave);

    OperationType type;
    if (cacheType == CacheService.CacheType.KEY_CACHE)
        type = OperationType.KEY_CACHE_SAVE;
    else if (cacheType == CacheService.CacheType.ROW_CACHE)
        type = OperationType.ROW_CACHE_SAVE;
    else
        type = OperationType.UNKNOWN;

    info = new CompactionInfo(new CFMetaData(Keyspace.SYSTEM_KS, cacheType.toString(), ColumnFamilyType.Standard, BytesType.instance, null),
                              type,
                              0,
                              keys.size(),
                              "keys");
}
 

import org.apache.cassandra.db.marshal.BytesType; //导入方法依赖的package包/类
public static Function makeFromBlobFunction(final AbstractType<?> toType)
{
    final String name = "blobas" + toType.asCQL3Type();
    return new NativeScalarFunction(name, toType, BytesType.instance)
    {
        public ByteBuffer execute(int protocolVersion, List<ByteBuffer> parameters) throws InvalidRequestException
        {
            ByteBuffer val = parameters.get(0);
            try
            {
                if (val != null)
                    toType.validate(val);
                return val;
            }
            catch (MarshalException e)
            {
                throw new InvalidRequestException(String.format("In call to function %s, value 0x%s is not a valid binary representation for type %s",
                                                                name, ByteBufferUtil.bytesToHex(val), toType.asCQL3Type()));
            }
        }
    };
}
 

import org.apache.cassandra.db.marshal.BytesType; //导入方法依赖的package包/类
@Test
public void testEmptyVariableLengthTypes()
{
    AbstractType<?>[] types = new AbstractType<?>[]{
                                                   AsciiType.instance,
                                                   BytesType.instance,
                                                   UTF8Type.instance,
                                                   new UFTestCustomType()
    };

    for (AbstractType<?> type : types)
    {
        Assert.assertFalse("type " + type.getClass().getName(),
                           UDHelper.isNullOrEmpty(type, ByteBufferUtil.EMPTY_BYTE_BUFFER));
    }
}
 

import org.apache.cassandra.db.marshal.BytesType; //导入方法依赖的package包/类
public static Function makeFromBlobFunction(final AbstractType<?> toType)
{
    final String name = "blobas" + toType.asCQL3Type();
    return new NativeFunction(name, toType, BytesType.instance)
    {
        public ByteBuffer execute(List<ByteBuffer> parameters) throws InvalidRequestException
        {
            ByteBuffer val = parameters.get(0);
            try
            {
                if (val != null)
                    toType.validate(val);
                return val;
            }
            catch (MarshalException e)
            {
                throw new InvalidRequestException(String.format("In call to function %s, value 0x%s is not a valid binary representation for type %s",
                                                                name, ByteBufferUtil.bytesToHex(val), toType.asCQL3Type()));
            }
        }
    };
}
 

import org.apache.cassandra.db.marshal.BytesType; //导入方法依赖的package包/类
@Test
public void testSerializeDeserialize() throws Exception
{
    ColumnDefinition cd0 = new ColumnDefinition(ByteBufferUtil.bytes("TestColumnDefinitionName0"),
                                                BytesType.instance,
                                                IndexType.KEYS,
                                                null,
                                                "random index name 0",
                                                null);

    ColumnDefinition cd1 = new ColumnDefinition(ByteBufferUtil.bytes("TestColumnDefinition1"),
                                                LongType.instance,
                                                null,
                                                null,
                                                null,
                                                null);

    testSerializeDeserialize(cd0);
    testSerializeDeserialize(cd1);
}
 

import org.apache.cassandra.db.marshal.BytesType; //导入方法依赖的package包/类
public static AbstractType getCassandraType(PrimitiveObjectInspector oi) {
  switch (oi.getPrimitiveCategory()) {
  case BOOLEAN:
    return BooleanType.instance;
  case INT:
    return Int32Type.instance;
  case LONG:
    return LongType.instance;
  case FLOAT:
    return FloatType.instance;
  case DOUBLE:
    return DoubleType.instance;
  case STRING:
    return UTF8Type.instance;
  case BYTE:
  case SHORT:
  case BINARY:
    return BytesType.instance;
  case TIMESTAMP:
    return DateType.instance;
  default:
    throw new RuntimeException("Hive internal error.");

  }
}
 

import org.apache.cassandra.db.marshal.BytesType; //导入方法依赖的package包/类
@Test
public void testSerializeDeserialize() throws Exception
{
    ColumnDefinition cd0 = new ColumnDefinition(ByteBufferUtil.bytes("TestColumnDefinitionName0"),
                                                BytesType.instance,
                                                IndexType.KEYS,
                                                "random index name 0");

    ColumnDefinition cd1 = new ColumnDefinition(ByteBufferUtil.bytes("TestColumnDefinition1"),
                                                LongType.instance,
                                                null,
                                                null);

    testSerializeDeserialize(cd0);
    testSerializeDeserialize(cd1);
}
 

import org.apache.cassandra.db.marshal.BytesType; //导入方法依赖的package包/类
/**
 * Returns a "fake" ColumnDefinition corresponding to the dropped column {@code name}
 * of {@code null} if there is no such dropped column.
 *
 * @param name - the column name
 * @param isStatic - whether the column was a static column, if known
 */
public ColumnDefinition getDroppedColumnDefinition(ByteBuffer name, boolean isStatic)
{
    DroppedColumn dropped = droppedColumns.get(name);
    if (dropped == null)
        return null;

    // We need the type for deserialization purpose. If we don't have the type however,
    // it means that it's a dropped column from before 3.0, and in that case using
    // BytesType is fine for what we'll be using it for, even if that's a hack.
    AbstractType<?> type = dropped.type == null ? BytesType.instance : dropped.type;
    return isStatic
            ? ColumnDefinition.staticDef(this, name, type)
            : ColumnDefinition.regularDef(this, name, type);
}
 

import org.apache.cassandra.db.marshal.BytesType; //导入方法依赖的package包/类
public static Function makeToBlobFunction(AbstractType<?> fromType)
{
    String name = fromType.asCQL3Type() + "asblob";
    return new AbstractFunction(name, BytesType.instance, fromType)
    {
        public ByteBuffer execute(List<ByteBuffer> parameters)
        {
            return parameters.get(0);
        }
    };
}
 

import org.apache.cassandra.db.marshal.BytesType; //导入方法依赖的package包/类
@Test
public void test6791() throws IOException, ConfigurationException
{
    File f = File.createTempFile("compressed6791_", "3");
    String filename = f.getAbsolutePath();
    try
    {

        MetadataCollector sstableMetadataCollector = new MetadataCollector(new SimpleDenseCellNameType(BytesType.instance));
        CompressedSequentialWriter writer = new CompressedSequentialWriter(f, filename + ".metadata", new CompressionParameters(SnappyCompressor.instance, 32, Collections.<String, String>emptyMap()), sstableMetadataCollector);

        for (int i = 0; i < 20; i++)
            writer.write("x".getBytes());

        FileMark mark = writer.mark();
        // write enough garbage to create new chunks:
        for (int i = 0; i < 40; ++i)
            writer.write("y".getBytes());

        writer.resetAndTruncate(mark);

        for (int i = 0; i < 20; i++)
            writer.write("x".getBytes());
        writer.close();

        CompressedRandomAccessReader reader = CompressedRandomAccessReader.open(filename, new CompressionMetadata(filename + ".metadata", f.length(), true));
        String res = reader.readLine();
        assertEquals(res, "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
        assertEquals(40, res.length());
    }
    finally
    {
        // cleanup
        if (f.exists())
            f.delete();
        File metadata = new File(filename+ ".metadata");
            if (metadata.exists())
                metadata.delete();
    }
}
 

import org.apache.cassandra.db.marshal.BytesType; //导入方法依赖的package包/类
public static Function makeFromBlobFunction(AbstractType<?> toType)
{
    String name = "blobas" + toType.asCQL3Type();
    return new AbstractFunction(name, toType, BytesType.instance)
    {
        public ByteBuffer execute(List<ByteBuffer> parameters)
        {
            return parameters.get(0);
        }
    };
}
 

import org.apache.cassandra.db.marshal.BytesType; //导入方法依赖的package包/类
private void prepareWriter() throws IOException
{
    if (outputdir == null)
    {
        String keyspace = ConfigHelper.getOutputKeyspace(conf);
        //dir must be named by ks/cf for the loader
        outputdir = new File(getOutputLocation() + File.separator + keyspace + File.separator + ConfigHelper.getOutputColumnFamily(conf));
        outputdir.mkdirs();
    }
    
    if (writer == null)
    {
        AbstractType<?> subcomparator = null;
        ExternalClient externalClient = null;
        String username = ConfigHelper.getOutputKeyspaceUserName(conf);
        String password = ConfigHelper.getOutputKeyspacePassword(conf);

        if (cfType == CFType.SUPER)
            subcomparator = BytesType.instance;

        this.writer = new SSTableSimpleUnsortedWriter(
                outputdir,
                ConfigHelper.getOutputPartitioner(conf),
                ConfigHelper.getOutputKeyspace(conf),
                ConfigHelper.getOutputColumnFamily(conf),
                BytesType.instance,
                subcomparator,
                Integer.parseInt(conf.get(BUFFER_SIZE_IN_MB, "64")),
                ConfigHelper.getOutputCompressionParamaters(conf));

        externalClient = new ExternalClient(ConfigHelper.getOutputInitialAddress(conf),
                                            ConfigHelper.getOutputRpcPort(conf),
                                            username,
                                            password);

        this.loader = new SSTableLoader(outputdir, externalClient, new NullOutputHandler());
    }
}
 

import org.apache.cassandra.db.marshal.BytesType; //导入方法依赖的package包/类
/**
 * Convert a string to bytes (ByteBuffer) according to type
 * @param content string to convert
 * @param type type to use for conversion
 * @return byte buffer representation of the given string
 */
private static ByteBuffer stringAsType(String content, AbstractType<?> type)
{
    try
    {
        return (type == BytesType.instance) ? hexToBytes(content) : type.fromString(content);
    }
    catch (MarshalException e)
    {
        throw new RuntimeException(e.getMessage());
    }
}