private byte[] GetBytes(CassandraObject[] components)
        {
            using (var bytes = new MemoryStream())
            {
                foreach (var c in components)
                {
                    var b = (byte[])c;
                    var length = (ushort)b.Length;

                    // comparator part
                    bytes.WriteByte((byte)1);
                    bytes.WriteByte((byte)_aliases.FirstOrDefault(x => x.Value == c.GetType()).Key);

                    // value length
                    bytes.Write(BitConverter.GetBytes(length), 0, 2);

                    // value
                    bytes.Write(b, 0, length);

                    // end of component
                    bytes.WriteByte((byte)0);
                }

                return bytes.ToArray();
            }
        }

 public static void InsertCounterColumn(this CassandraColumnFamily family, CassandraObject key,
                                        CassandraObject superColumnName, CassandraObject columnName,
                                        long columnValue)
 {
     var op = new AddColumn(key, superColumnName, columnName, columnValue);
     family.ExecuteOperation(op);
 }

		public CassandraRangeSlicePredicate(CassandraObject start, CassandraObject finish, bool reversed = false, int count = 100)
		{
			Start = start;
			Finish = finish;
			Reversed = reversed;
			Count = count;
		}

		public Apache.Cassandra.ColumnOrSuperColumn get(CassandraObject key, CassandraColumnPath column_path, Apache.Cassandra.ConsistencyLevel consistency_level)
		{
			return _client.get(
				key.TryToBigEndian(),
				Helper.CreateColumnPath(column_path),
				consistency_level);
		}

 public void add(CassandraObject key, CassandraColumnParent column_parent, CassandraCounterColumn column, Apache.Cassandra.ConsistencyLevel consistency_level)
 {
     _client.add(
         key.TryToBigEndian(),
         Helper.CreateColumnParent(column_parent),
         Helper.CreateCounterColumn(column),
         consistency_level);
 }

		public int get_count(CassandraObject key, CassandraColumnParent column_parent, CassandraSlicePredicate predicate, Apache.Cassandra.ConsistencyLevel consistency_level)
		{
			return _client.get_count(
				key.TryToBigEndian(),
				Helper.CreateColumnParent(column_parent),
				Helper.CreateSlicePredicate(predicate),
				consistency_level);
		}

		public CassandraKeyRange(CassandraObject startKey, CassandraObject endKey, string startToken, string endToken, int count)
		{
			StartKey = startKey;
			EndKey = endKey;
			StartToken = startToken;
			EndToken = endToken;
			Count = count;
		}

        public static void InsertColumn(this CassandraColumnFamily family, CassandraObject key, FluentColumnPath path)
        {
            var columnName = path.Column.ColumnName;
            var columnValue = path.Column.ColumnValue;
            var timestamp = path.Column.ColumnTimestamp;
            var timeToLive = path.Column.ColumnSecondsUntilDeleted;

            var op = new InsertColumn(key, columnName, columnValue, timestamp, timeToLive);
            family.ExecuteOperation(op);
        }

		public CassandraQuerySetup()
		{
			Reverse = false;

			KeyCount = 100;
			ColumnCount = 100;

			Keys = new CassandraObject[0];
			Columns = new CassandraObject[0];
		}

        public void Implicit_ByteArray_Cast()
        {
            // arrange
            var expected = new CassandraObject[] { (AsciiType)"string1", (LongType)300 };
            byte[] bytes = GetBytes(expected);

            // act
            CompositeType actual = bytes;

            // assert
            Assert.IsTrue(expected.SequenceEqual(actual));
        }

        public void CassandraType_Cast()
        {
            // arranage
            var expected = new CassandraObject[] { (AsciiType)"string1", (LongType)300 };

            // act
            CompositeType actualType = expected;
            CassandraObject actual = actualType;

            // assert
            Assert.IsTrue(expected.SequenceEqual((CassandraObject[])actual));
        }

        public void JavaBytes_To_CompositeType()
        {
            // arrange
            var expected = new CassandraObject[] { (BytesType)_compositeType[0].GetValue<string>(), (BytesType)_compositeType[1].GetValue<long>() };

            // act
            var actual = new CompositeType();
            actual.SetValueFromBigEndian(_javaByteOrder);

            // assert
            Assert.True(expected.SequenceEqual((CassandraObject[])actual));
        }

		private byte[] GetBytes(CassandraObject[] components)
		{
			using (var bytes = new MemoryStream())
			{
				foreach (var c in components)
				{
					var b = (byte[])c;
					var length = (ushort)b.Length;

					// value length
					bytes.Write(BitConverter.GetBytes(length), 0, 2);

					// value
					bytes.Write(b, 0, length);

					// end of component
					bytes.WriteByte((byte)0);
				}

				return bytes.ToArray();
			}
		}

		public static int SuperColumnCount(this CassandraSuperColumnFamily family, CassandraObject key, CassandraObject superColumnName, CassandraObject columnStart, CassandraObject columnEnd, bool reversed = false, int count = 100)
		{
			var op = new ColumnCount(key, superColumnName, new CassandraRangeSlicePredicate(columnStart, columnEnd, reversed, count));
			return family.ExecuteOperation(op);
		}

		public static FluentSuperColumnFamily GetSingle(this CassandraSuperColumnFamily family, CassandraObject key, CassandraObject columnStart, CassandraObject columnEnd, bool reversed = false, int count = 100)
		{
			var op = new GetSuperColumnFamilySlice(key, new CassandraRangeSlicePredicate(columnStart, columnEnd, reversed, count));
			return family.ExecuteOperation(op);
		}

		public static FluentColumn GetColumn(this CassandraSuperColumnFamily family, CassandraObject key, CassandraObject superColumnName, CassandraObject columnName)
		{
			var op = new GetColumn(key, superColumnName, columnName);
			return family.ExecuteOperation(op);
		}

		public static void InsertColumn(this CassandraSuperColumnFamily family, CassandraObject key, CassandraObject superColumnName, CassandraObject name, BytesType value, DateTimeOffset timestamp, int? timeToLive)
		{
			var op = new InsertColumn(key, superColumnName, name, value, timestamp, timeToLive);
			family.ExecuteOperation(op);
		}

 public void remove_counter(CassandraObject key, CassandraColumnPath path, Apache.Cassandra.ConsistencyLevel consistency_level)
 {
     _client.remove_counter(
         key.TryToBigEndian(),
         Helper.CreateColumnPath(path),
         consistency_level);
 }

 public void remove(CassandraObject key, CassandraColumnPath column_path, long timestamp, Apache.Cassandra.ConsistencyLevel consistency_level)
 {
     _client.remove(
         key.TryToBigEndian(),
         Helper.CreateColumnPath(column_path),
         timestamp,
         consistency_level);
 }

		public static CassandraType GetCassandraType(CassandraObject obj)
		{
			var typeName = obj.GetType().Name;
			var cassandraType = (CassandraType)null;

			switch (typeName.ToLower())
			{
				case "asciitype": cassandraType = AsciiType; break;
				case "booleantype": cassandraType = BooleanType; break;
				case "bytestype": cassandraType = BytesType; break;
				case "datetype": cassandraType = DateType; break;
				case "decimaltype": cassandraType = DecimalType; break;
				case "doubletype": cassandraType = DoubleType; break;
				case "floattype": cassandraType = FloatType; break;
				case "int32type": cassandraType = Int32Type; break;
				case "integertype": cassandraType = IntegerType; break;
				case "lexicaluuidtype": cassandraType = LexicalUUIDType; break;
				case "longtype": cassandraType = LongType; break;
				case "timeuuidtype": cassandraType = TimeUUIDType; break;
				case "utf8type": cassandraType = UTF8Type; break;
				case "uuidtype": cassandraType = UUIDType; break;
				case "emptytype": cassandraType = EmptyType; break;
				case "inetaddresstype": cassandraType = InetAddressType; break;
				// these need work
				//case "compositetype": cassandraType = CompositeType; break;
				//case "dynamiccompositetype": cassandraType = DynamicCompositeType; break;
				//case "countercolumntype": cassandraType = CounterColumnType; break;
				//case "reversedtype": cassandraType = ReversedType; break;
				default: throw new CassandraException("Type '" + typeName + "' not found.");
			}

			return cassandraType;
		}