Example usage for org.apache.cassandra.db.marshal CounterColumnType instance

Introduction

In this page you can find the example usage for org.apache.cassandra.db.marshal CounterColumnType instance.

Prototype

CounterColumnType instance

To view the source code for org.apache.cassandra.db.marshal CounterColumnType instance.

Click Source Link

Usage

From source file:clojurewerkz.cassaforte.Codec.java

License:Apache License

private static AbstractType getCodecInternal(DataType type) {
    switch (type.getName()) {
    case ASCII://from   w  w w.j  av a  2s .  co m
        return AsciiType.instance;
    case BIGINT:
        return LongType.instance;
    case BLOB:
        return BytesType.instance;
    case BOOLEAN:
        return BooleanType.instance;
    case COUNTER:
        return CounterColumnType.instance;
    case DECIMAL:
        return DecimalType.instance;
    case DOUBLE:
        return DoubleType.instance;
    case FLOAT:
        return FloatType.instance;
    case INET:
        return InetAddressType.instance;
    case INT:
        return Int32Type.instance;
    case TEXT:
        return UTF8Type.instance;
    case TIMESTAMP:
        return DateType.instance;
    case UUID:
        return UUIDType.instance;
    case VARCHAR:
        return UTF8Type.instance;
    case VARINT:
        return IntegerType.instance;
    case TIMEUUID:
        return TimeUUIDType.instance;
    case LIST:
        return ListType.getInstance(getCodec(type.getTypeArguments().get(0)));
    case SET:
        return SetType.getInstance(getCodec(type.getTypeArguments().get(0)));
    case MAP:
        return MapType.getInstance(getCodec(type.getTypeArguments().get(0)),
                getCodec(type.getTypeArguments().get(1)));
    default:
        throw new RuntimeException("Unknown type");
    }
}

---

From source file:com.datastax.driver.core.Codec.java

License:Apache License

private static AbstractType<?> getCodecInternal(DataType type) {
    switch (type.getName()) {
    case ASCII://from w  ww  . ja  v a2s.  c o  m
        return AsciiType.instance;
    case BIGINT:
        return LongType.instance;
    case BLOB:
        return BytesType.instance;
    case BOOLEAN:
        return BooleanType.instance;
    case COUNTER:
        return CounterColumnType.instance;
    case DECIMAL:
        return DecimalType.instance;
    case DOUBLE:
        return DoubleType.instance;
    case FLOAT:
        return FloatType.instance;
    case INET:
        return InetAddressType.instance;
    case INT:
        return Int32Type.instance;
    case TEXT:
        return UTF8Type.instance;
    case TIMESTAMP:
        return DateType.instance;
    case UUID:
        return UUIDType.instance;
    case VARCHAR:
        return UTF8Type.instance;
    case VARINT:
        return IntegerType.instance;
    case TIMEUUID:
        return TimeUUIDType.instance;
    case LIST:
        return ListType.getInstance(getCodec(type.getTypeArguments().get(0)));
    case SET:
        return SetType.getInstance(getCodec(type.getTypeArguments().get(0)));
    case MAP:
        return MapType.getInstance(getCodec(type.getTypeArguments().get(0)),
                getCodec(type.getTypeArguments().get(1)));
    // We don't interpret custom values in any way
    case CUSTOM:
        return BytesType.instance;
    default:
        throw new RuntimeException("Unknown type");
    }
}

---

From source file:io.datalayer.cassandra.support.AosEmbeddedSchemaLoader.java

License:Apache License

public static Collection<KSMetaData> schemaDefinition() {
    List<KSMetaData> schema = new ArrayList<KSMetaData>();

    // A whole bucket of shorthand
    String ks1 = "Keyspace1";
    String ks2 = "Keyspace2";

    Class<? extends AbstractReplicationStrategy> simple = SimpleStrategy.class;
    Map<String, String> opts = new HashMap<String, String>();
    opts.put("replication_factor", Integer.toString(1));

    ColumnFamilyType st = ColumnFamilyType.Standard;
    ColumnFamilyType su = ColumnFamilyType.Super;
    AbstractType bytes = BytesType.instance;

    List<AbstractType> subComparators = new ArrayList<AbstractType>();
    subComparators.add(BytesType.instance);
    subComparators.add(TimeUUIDType.instance);
    subComparators.add(IntegerType.instance);

    // Keyspace 1
    schema.add(KSMetaData.testMetadata(ks1, simple, opts,

            // Column Families
            standardCFMD(ks1, "Standard1"), standardCFMD(ks1, "Standard2"), standardCFMD(ks1, "Standard3"),
            standardCFMD(ks1, "Standard4"), cqlTestCf(ks1, "StandardLong1", UTF8Type.instance),
            standardCFMD(ks1, "StandardLong2").keyValidator(UTF8Type.instance),
            superCFMD(ks1, "Super1", BytesType.instance), superCFMD(ks1, "Super2", LongType.instance),
            superCFMD(ks1, "Super3", LongType.instance), superCFMD(ks1, "Super4", UTF8Type.instance),
            superCFMD(ks1, "Super5", bytes), indexCFMD(ks1, "Indexed1", true),
            indexCFMD(ks1, "Indexed2", false),
            // new CFMetaData(ks1, "StandardInteger1", st,
            // IntegerType.instance, null).keyCacheSize(0),
            new CFMetaData(ks1, "Counter1", st, bytes, null).replicateOnWrite(true)
                    .defaultValidator(CounterColumnType.instance),
            new CFMetaData(ks1, "Counter2", st, bytes, null).replicateOnWrite(true)
                    .defaultValidator(CounterColumnType.instance),
            new CFMetaData(ks1, "SuperCounter1", su, bytes, bytes).replicateOnWrite(true).defaultValidator(
                    CounterColumnType.instance),
            jdbcCFMD(ks1, "JdbcInteger", IntegerType.instance), jdbcCFMD(ks1, "JdbcUtf8", UTF8Type.instance),
            jdbcCFMD(ks1, "JdbcLong", LongType.instance), jdbcCFMD(ks1, "JdbcBytes", bytes),
            jdbcCFMD(ks1, "JdbcAscii", AsciiType.instance)));

    // Keyspace 2

    return schema;
}

---

From source file:org.pentaho.cassandra.legacy.CassandraColumnMetaData.java

License:Apache License

/**
 * Static utility to decompose a Kettle value to a ByteBuffer. Note - does not check if the kettle value is null.
 *
 * @param vm/*from   w  w w  .  j ava2  s. c o m*/
 *          the ValueMeta for the Kettle value
 * @param value
 *          the actual Kettle value
 * @return a ByteBuffer encapsulating the bytes for the decomposed value
 * @throws KettleException
 *           if a problem occurs
 */
public ByteBuffer kettleValueToByteBuffer(ValueMetaInterface vm, Object value, boolean isKey)
        throws KettleException {

    String fullTransCoder = m_defaultValidationClass;

    // check the key first
    if (isKey) {
        fullTransCoder = m_keyValidator;
    } else {
        fullTransCoder = m_columnMeta.get(vm.getName());
        if (fullTransCoder == null) {
            // use default if not in column meta data
            fullTransCoder = m_defaultValidationClass;
        }
    }

    // we can safely strip off ReversedType, as the base type
    // is what we need in this case
    fullTransCoder = stripReversedTypeIfNecessary(fullTransCoder);

    String transCoder = fullTransCoder;

    // if it's a composite type make sure that we check only against the
    // primary type
    if (transCoder.indexOf('(') > 0) {
        transCoder = transCoder.substring(0, transCoder.indexOf('('));
    }

    ByteBuffer decomposed = null;
    if (transCoder.indexOf("UTF8Type") > 0) { //$NON-NLS-1$
        UTF8Type u = UTF8Type.instance;
        decomposed = u.decompose(vm.getString(value));
    } else if (transCoder.indexOf("AsciiType") > 0) { //$NON-NLS-1$
        AsciiType at = AsciiType.instance;
        decomposed = at.decompose(vm.getString(value));
    } else if (transCoder.indexOf("InetAddressType") > 0) { //$NON-NLS-1$
        InetAddressType it = InetAddressType.instance;
        decomposed = it.fromString(vm.getString(value));
    } else if (transCoder.indexOf("LongType") > 0) { //$NON-NLS-1$
        LongType lt = LongType.instance;
        decomposed = lt.decompose(vm.getInteger(value));
    } else if (transCoder.indexOf("DoubleType") > 0) { //$NON-NLS-1$
        DoubleType dt = DoubleType.instance;
        decomposed = dt.decompose(vm.getNumber(value));
    } else if (transCoder.indexOf("DateType") > 0) { //$NON-NLS-1$
        DateType dt = DateType.instance;
        decomposed = dt.decompose(vm.getDate(value));
    } else if (transCoder.indexOf("TimestampType") > 0) { //$NON-NLS-1$
        AbstractType<java.util.Date> tt = getTimestampType();
        if (tt == null) {
            throw new KettleException(BaseMessages.getString(PKG,
                    "CassandraColumnMetaData.Error.Cassandra1ClientAgainstCassandra2Server")); //$NON-NLS-1$
        }
        decomposed = tt.decompose(vm.getDate(value));
    } else if (transCoder.indexOf("IntegerType") > 0) { //$NON-NLS-1$
        IntegerType it = IntegerType.instance;
        decomposed = it.decompose(vm.getBigNumber(value).toBigInteger());
    } else if (transCoder.indexOf("CounterColumnType") > 0) { //$NON-NLS-1$
        CounterColumnType cct = CounterColumnType.instance;
        decomposed = cct.decompose(vm.getInteger(value));
    } else if (transCoder.indexOf("FloatType") > 0) { //$NON-NLS-1$
        FloatType ft = FloatType.instance;
        decomposed = ft.decompose(vm.getNumber(value).floatValue());
    } else if (transCoder.indexOf("LexicalUUIDType") > 0) { //$NON-NLS-1$
        LexicalUUIDType lt = LexicalUUIDType.instance;
        UUID uuid = UUID.fromString((vm.getString(value)));
        decomposed = lt.decompose(uuid);
    } else if (transCoder.indexOf("UUIDType") > 0) { //$NON-NLS-1$
        UUIDType ut = UUIDType.instance;
        UUID uuid = UUID.fromString((vm.getString(value)));
        decomposed = ut.decompose(uuid);
    } else if (transCoder.indexOf("BooleanType") > 0) { //$NON-NLS-1$
        BooleanType bt = BooleanType.instance;
        decomposed = bt.decompose(vm.getBoolean(value));
    } else if (transCoder.indexOf("Int32Type") > 0) { //$NON-NLS-1$
        Int32Type it = Int32Type.instance;
        decomposed = it.decompose(vm.getInteger(value).intValue());
    } else if (transCoder.indexOf("DecimalType") > 0) { //$NON-NLS-1$
        DecimalType dt = DecimalType.instance;
        decomposed = dt.decompose(vm.getBigNumber(value));
    } else if (transCoder.indexOf("BytesType") > 0) { //$NON-NLS-1$
        BytesType bt = BytesType.instance;
        decomposed = bt.decompose(ByteBuffer.wrap(vm.getBinary(value)));
    } else if (transCoder.indexOf("DynamicCompositeType") > 0) { //$NON-NLS-1$
        AbstractType<?> serializer = null;
        if (vm.isString()) {
            try {
                serializer = TypeParser.parse(fullTransCoder);
                decomposed = ((DynamicCompositeType) serializer).fromString(vm.getString(value));

            } catch (Exception e) {
                throw new KettleException(e.getMessage(), e);
            }
        } else {
            throw new KettleException(
                    BaseMessages.getString(PKG, "CassandraColumnMetaData.Error.CantConvertTypeThrift", //$NON-NLS-1$
                            vm.getTypeDesc(), fullTransCoder));
        }
    } else if (transCoder.indexOf("CompositeType") > 0) { //$NON-NLS-1$
        AbstractType<?> serializer = null;
        if (vm.isString()) {
            try {
                serializer = TypeParser.parse(fullTransCoder);
                decomposed = ((CompositeType) serializer).fromString(vm.toString());
            } catch (Exception e) {
                throw new KettleException(e.getMessage(), e);
            }
        } else {
            throw new KettleException(
                    BaseMessages.getString(PKG, "CassandraColumnMetaData.Error.CantConvertTypeThrift", //$NON-NLS-1$
                            vm.getTypeDesc(), fullTransCoder));
        }
    }

    if (decomposed == null) {
        throw new KettleException(BaseMessages.getString(PKG,
                "CassandraColumnMetaData.Error.UnableToConvertValue", vm.getName())); //$NON-NLS-1$
    }

    return decomposed;
}

---

From source file:org.pentaho.cassandra.legacy.CassandraColumnMetaData.java

License:Apache License

/**
 * Encode a string representation of a column name using the serializer for the default comparator.
 *
 * @param colName//from   w  w  w.  j  a v  a  2 s . co  m
 *          the textual column name to serialze
 * @return a ByteBuffer encapsulating the serialized column name
 * @throws KettleException
 *           if a problem occurs during serialization
 */
public ByteBuffer columnNameToByteBuffer(String colName) throws KettleException {

    AbstractType<?> serializer = null;
    String fullEncoder = m_columnComparator;
    fullEncoder = stripReversedTypeIfNecessary(fullEncoder);
    String encoder = fullEncoder;

    // if it's a composite type make sure that we check only against the
    // primary type
    if (encoder.indexOf('(') > 0) {
        encoder = encoder.substring(0, encoder.indexOf('('));
    }

    if (encoder.indexOf("UTF8Type") > 0) { //$NON-NLS-1$
        serializer = UTF8Type.instance;
    } else if (encoder.indexOf("AsciiType") > 0) { //$NON-NLS-1$
        serializer = AsciiType.instance;
    } else if (encoder.indexOf("LongType") > 0) { //$NON-NLS-1$
        serializer = LongType.instance;
    } else if (encoder.indexOf("InetAddressType") > 0) { //$NON-NLS-1$
        serializer = InetAddressType.instance;
    } else if (encoder.indexOf("DoubleType") > 0) { //$NON-NLS-1$
        serializer = DoubleType.instance;
    } else if (encoder.indexOf("DateType") > 0) { //$NON-NLS-1$
        serializer = DateType.instance;
    } else if (encoder.indexOf("TimestampType") > 0) { //$NON-NLS-1$
        serializer = getTimestampType();
        if (serializer == null) {
            throw new KettleException(BaseMessages.getString(PKG,
                    "CassandraColumnMetaData.Error.Cassandra1ClientAgainstCassandra2Server")); //$NON-NLS-1$
        }
    } else if (encoder.indexOf("IntegerType") > 0) { //$NON-NLS-1$
        serializer = IntegerType.instance;
    } else if (encoder.indexOf("CounterColumnType") > 0) { //$NON-NLS-1$
        serializer = CounterColumnType.instance;
    } else if (encoder.indexOf("FloatType") > 0) { //$NON-NLS-1$
        serializer = FloatType.instance;
    } else if (encoder.indexOf("LexicalUUIDType") > 0) { //$NON-NLS-1$
        serializer = LexicalUUIDType.instance;
    } else if (encoder.indexOf("UUIDType") > 0) { //$NON-NLS-1$
        serializer = UUIDType.instance;
    } else if (encoder.indexOf("BooleanType") > 0) { //$NON-NLS-1$
        serializer = BooleanType.instance;
    } else if (encoder.indexOf("Int32Type") > 0) { //$NON-NLS-1$
        serializer = Int32Type.instance;
    } else if (encoder.indexOf("DecimalType") > 0) { //$NON-NLS-1$
        serializer = DecimalType.instance;
    } else if (encoder.indexOf("BytesType") > 0) { //$NON-NLS-1$
        serializer = BytesType.instance;
    } else if (encoder.indexOf("DynamicCompositeType") > 0) { //$NON-NLS-1$
        try {
            serializer = TypeParser.parse(fullEncoder);
        } catch (Exception e) {
            throw new KettleException(e.getMessage(), e);
        }
    } else if (encoder.indexOf("CompositeType") > 0) { //$NON-NLS-1$
        try {
            serializer = TypeParser.parse(fullEncoder);
        } catch (Exception e) {
            throw new KettleException(e.getMessage(), e);
        }
    }

    ByteBuffer result = serializer.fromString(colName);

    return result;
}

---

From source file:org.pentaho.cassandra.legacy.CassandraColumnMetaData.java

License:Apache License

private static Object getColumnValue(ByteBuffer valueBuff, String decoder) throws KettleException {
    if (valueBuff == null) {
        return null;
    }//from ww w.ja v  a 2  s  .  c  o  m

    decoder = stripReversedTypeIfNecessary(decoder);

    Object result = null;
    AbstractType<?> deserializer = null;
    String fullDecoder = decoder;

    // if it's a composite type make sure that we check only against the
    // primary type
    if (decoder.indexOf('(') > 0) {
        decoder = decoder.substring(0, decoder.indexOf('('));
    }

    if (decoder.indexOf("UTF8Type") > 0) { //$NON-NLS-1$
        deserializer = UTF8Type.instance;
    } else if (decoder.indexOf("AsciiType") > 0) { //$NON-NLS-1$
        deserializer = AsciiType.instance;
    } else if (decoder.indexOf("InetAddressType") > 0) { //$NON-NLS-1$
        deserializer = InetAddressType.instance;

        result = deserializer.getString(valueBuff);
        return result;
    } else if (decoder.indexOf("LongType") > 0) { //$NON-NLS-1$
        deserializer = LongType.instance;
    } else if (decoder.indexOf("CounterColumnType") > 0) { //$NON-NLS-1$
        deserializer = CounterColumnType.instance;
    } else if (decoder.indexOf("DoubleType") > 0) { //$NON-NLS-1$
        deserializer = DoubleType.instance;
    } else if (decoder.indexOf("DateType") > 0) { //$NON-NLS-1$
        deserializer = DateType.instance;
    } else if (decoder.indexOf("TimestampType") > 0) { //$NON-NLS-1$
        deserializer = getTimestampType();
        if (deserializer == null) {
            throw new KettleException(BaseMessages.getString(PKG,
                    "CassandraColumnMetaData.Error.Cassandra1ClientAgainstCassandra2Server")); //$NON-NLS-1$
        }
    } else if (decoder.indexOf("IntegerType") > 0) { //$NON-NLS-1$
        deserializer = IntegerType.instance;

        result = new Long(((IntegerType) deserializer).compose(valueBuff).longValue());
        return result;
    } else if (decoder.indexOf("FloatType") > 0) { //$NON-NLS-1$
        deserializer = FloatType.instance;

        result = new Double(((FloatType) deserializer).compose(valueBuff)).doubleValue();
        return result;
    } else if (decoder.indexOf("LexicalUUIDType") > 0) { //$NON-NLS-1$
        deserializer = LexicalUUIDType.instance;

        result = new String(((LexicalUUIDType) deserializer).compose(valueBuff).toString());
        return result;
    } else if (decoder.indexOf("UUIDType") > 0) { //$NON-NLS-1$
        deserializer = UUIDType.instance;

        result = new String(((UUIDType) deserializer).compose(valueBuff).toString());
        return result;
    } else if (decoder.indexOf("BooleanType") > 0) { //$NON-NLS-1$
        deserializer = BooleanType.instance;
    } else if (decoder.indexOf("Int32Type") > 0) { //$NON-NLS-1$
        deserializer = Int32Type.instance;

        result = new Long(((Int32Type) deserializer).compose(valueBuff)).longValue();
        return result;
    } else if (decoder.indexOf("DecimalType") > 0) { //$NON-NLS-1$
        deserializer = DecimalType.instance;
    } else if (decoder.indexOf("BytesType") > 0) { //$NON-NLS-1$
        deserializer = BytesType.instance;
        result = deserializer.getString(valueBuff);

        return result;
    } else if (decoder.indexOf("DynamicCompositeType") > 0) { //$NON-NLS-1$
        try {
            deserializer = TypeParser.parse(fullDecoder);

            // now return the string representation of the composite value
            result = ((DynamicCompositeType) deserializer).getString(valueBuff);
            return result;
        } catch (Exception e) {
            throw new KettleException(e.getMessage(), e);
        }
    } else if (decoder.indexOf("CompositeType") > 0) { //$NON-NLS-1$
        try {
            deserializer = TypeParser.parse(fullDecoder);

            // now return the string representation of the composite value
            result = ((CompositeType) deserializer).getString(valueBuff);

            return result;
        } catch (Exception e) {
            throw new KettleException(e.getMessage(), e);
        }
    } else if (decoder.indexOf("SetType") > 0 || decoder.indexOf("ListType") > 0 //$NON-NLS-1$//$NON-NLS-2$
            || decoder.indexOf("MapType") > 0) { //$NON-NLS-1$
        try {
            deserializer = TypeParser.parse(fullDecoder);
        } catch (Exception e) {
            throw new KettleException(e);
        }
    }

    if (deserializer == null) {
        throw new KettleException(
                BaseMessages.getString(PKG, "CassandraColumnMetaData.Error.CantFindADeserializerForType") //$NON-NLS-1$
                        + " :" + fullDecoder); //$NON-NLS-1$
    }

    result = deserializer.compose(valueBuff);

    return result;
}

---

From source file:org.usergrid.vx.experimental.CassandraRunner.java

License:Apache License

private void maybeCreateColumnFamily(RequiresColumnFamily rcf) {
    try {//from   w w  w. j  av  a  2  s . c  o m
        CFMetaData cfMetaData;
        if (rcf.isCounter()) {
            cfMetaData = new CFMetaData(rcf.ksName(), rcf.cfName(), ColumnFamilyType.Standard,
                    TypeParser.parse(rcf.comparator()), null).replicateOnWrite(false)
                            .defaultValidator(CounterColumnType.instance);
        } else {
            cfMetaData = new CFMetaData(rcf.ksName(), rcf.cfName(), ColumnFamilyType.Standard,
                    TypeParser.parse(rcf.comparator()), null);
        }
        MigrationManager.announceNewColumnFamily(cfMetaData);
    } catch (AlreadyExistsException aee) {
        logger.info("ColumnFamily already exists for " + rcf.cfName());
        maybeTruncateSafely(rcf);
    } catch (Exception ex) {
        throw new RuntimeException("Could not create column family for: " + rcf.cfName(), ex);
    }
}

---