connections now are object oriented, and basic keyspace and column fa…

…mily support is being provided, see sandbox for example

FluentCassandra.Sandbox/Program.cs

@@ -22,45 +22,44 @@ public class Location
 		public string Name;
 	}
 
-	public class LocationMap : ColumnFamilyMap<Location> { }
-
 	internal class Program
 	{
 		private static void Main(string[] args)
 		{
-			CassandraDatabase.Init("Keyspace1");
-
-			CassandraConfiguration.Initialize(c => {
-				c.For<Location>(m => {
-					m.UseColumnFamily("Location");
-					m.ForKey(p => p.Id);
-					m.ForProperty(p => p.Latitude);
-					m.ForProperty(p => p.Longitude);
-					m.ForProperty(p => p.Street);
-					m.ForProperty(p => p.City);
-					m.ForProperty(p => p.State);
-					m.ForProperty(p => p.PostalCode);
-					m.ForProperty(p => p.Name);
+			CassandraConfiguration.Initialize(config => {
+				config.For<Location>(x => {
+					x.UseColumnFamily("Location");
+					x.ForKey(p => p.Id);
+					x.ForProperty(p => p.Latitude);
+					x.ForProperty(p => p.Longitude);
+					x.ForProperty(p => p.Street);
+					x.ForProperty(p => p.City);
+					x.ForProperty(p => p.State);
+					x.ForProperty(p => p.PostalCode);
+					x.ForProperty(p => p.Name);
 				});
 			});
 
-			var mapping = new LocationMap();
+			using (var db = new CassandraContext("Keyspace1", "localhost"))
+			{
+				var location = new Location {
+					Id = "19001",
+					Name = "Some Location",
 
-			var location = new Location {
-				Id = "19001",
-				Name = "Some Location",
+					Latitude = 30.0M,
+					Longitude = -40.0M,
 
-				Latitude = 30.0M,
-				Longitude = -40.0M,
+					Street = "123 Some St.",
+					City = "Philadelphia",
+					State = "PA",
+					PostalCode = "19001"
+				};
 
-				Street = "123 Some St.",
-				City = "Philadelphia",
-				State = "PA",
-				PostalCode = "19001"
-			};
+				var table = db.GetColumnFamily<Location>();
 
-			Console.WriteLine("Insert record");
-			mapping.Insert(location);
+				Console.WriteLine("Insert record");
+				table.Insert(location);
+			}
 
 			Console.WriteLine("Done");
 			Console.Read();

FluentCassandra/CassandraColumnFamily.cs

@@ -0,0 +1,106 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Apache.Cassandra;
+
+namespace FluentCassandra
+{
+	public class CassandraColumnFamily
+	{
+		private CassandraKeyspace _keyspace;
+		private IConnection _connection;
+
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="keyspace"></param>
+		/// <param name="connection"></param>
+		public CassandraColumnFamily(CassandraKeyspace keyspace, IConnection connection)
+		{
+			_keyspace = keyspace;
+			_connection = connection;
+		}
+
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <returns></returns>
+		protected Cassandra.Client GetClient()
+		{
+			return _connection.Client;
+		}
+
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="record"></param>
+		public void Insert(FluentColumnFamily record)
+		{
+			Insert(record.ColumnFamily, record.Key, record);
+		}
+
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="columnFamily"></param>
+		/// <param name="key"></param>
+		/// <param name="record"></param>
+		public void Insert(string columnFamily, string key, FluentColumnFamily record)
+		{
+			var utf8 = Encoding.UTF8;
+
+			foreach (var col in record)
+			{
+				var path = new ColumnPath {
+					Column_family = columnFamily,
+					Column = col.NameBytes
+				};
+
+				GetClient().insert(
+					_keyspace.KeyspaceName,
+					key,
+					path,
+					col.ValueBytes,
+					col.Timestamp.Ticks,
+					ConsistencyLevel.ONE
+				);
+			}
+		}
+
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="record"></param>
+		/// <param name="columnName"></param>
+		public void Remove(FluentColumnFamily record, string columnName = null)
+		{
+			Remove(record.ColumnFamily, record.Key, columnName);
+		}
+
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="columnFamily"></param>
+		/// <param name="key"></param>
+		/// <param name="columnName"></param>
+		public void Remove(string columnFamily, string key, string columnName = null)
+		{
+			var utf8 = Encoding.UTF8;
+			var path = new ColumnPath {
+				Column_family = columnFamily
+			};
+
+			if (!String.IsNullOrWhiteSpace(columnName))
+				path.Column = FluentColumn<string>.GetBytes(columnName);
+
+			GetClient().remove(
+				_keyspace.KeyspaceName,
+				key,
+				path,
+				DateTimeOffset.UtcNow.Ticks,
+				ConsistencyLevel.ONE
+			);
+		}
+	}
+}

FluentCassandra/ColumnFamilyMap.cs → FluentCassandra/CassandraColumnFamily`1.cs

@@ -10,16 +10,26 @@
 
 namespace FluentCassandra
 {
-	public class ColumnFamilyMap<T>
+	public class CassandraColumnFamily<T> : CassandraColumnFamily
 	{
-		private string _keyspace;
 		private ITypeGetConfiguration<T> _config;
 
-		public ColumnFamilyMap()
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="keyspace"></param>
+		/// <param name="connection"></param>
+		public CassandraColumnFamily(CassandraKeyspace keyspace, IConnection connection)
+			: base(keyspace, connection)
 		{
 			_config = CassandraConfiguration.GetMapFor<T>();
 		}
 
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="obj"></param>
+		/// <returns></returns>
 		public FluentColumnFamily PrepareColumnFamily(T obj)
 		{
 			FluentColumnFamily record = new FluentColumnFamily();
@@ -37,21 +47,22 @@ public FluentColumnFamily PrepareColumnFamily(T obj)
 			return record;
 		}
 
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="obj"></param>
 		public void Insert(T obj)
 		{
-			var record = PrepareColumnFamily(obj);
-			CassandraDatabase context = new CassandraDatabase();
-			context.Open();
-			context.Insert(record);
-			context.Close();
+			Insert(PrepareColumnFamily(obj));
 		}
 
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="obj"></param>
 		public void Remove(T obj)
 		{
-			CassandraDatabase context = new CassandraDatabase();
-			context.Open();
-			context.Remove(_config.ColumnFamily, _config.KeyMap.KeyAccessor(obj));
-			context.Close();
+			Remove(PrepareColumnFamily(obj));
 		}
 	}
 }

FluentCassandra/CassandraContext.cs

@@ -0,0 +1,110 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace FluentCassandra
+{
+	public class CassandraContext : IDisposable
+	{
+		private readonly ConnectionBuilder _connectionBuilder;
+		private readonly IConnectionProvider _connectionProvider;
+		private readonly IConnection _connection;
+		private readonly CassandraKeyspace _keyspace;
+		private bool _disposed;
+
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="keyspace"></param>
+		/// <param name="host"></param>
+		/// <param name="port"></param>
+		/// <param name="timeout"></param>
+		/// <param name="provider"></param>
+		public CassandraContext(string keyspace, string host, int port = 9160, int timeout = 0, string provider = "Normal")
+			: this(new ConnectionBuilder(keyspace, host, port, timeout, provider)) { }
+
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="connectionString"></param>
+		public CassandraContext(string connectionString)
+			: this(new ConnectionBuilder(connectionString)) { }
+
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="connectionBuilder"></param>
+		public CassandraContext(ConnectionBuilder connectionBuilder)
+		{
+			_connectionBuilder = connectionBuilder;
+			_connectionProvider = connectionBuilder.Provider;
+			_connection = _connectionProvider.Open();
+			_keyspace = new CassandraKeyspace(_connectionBuilder.Keyspace, _connection);
+		}
+
+		/// <summary>
+		/// Gets the database.
+		/// </summary>
+		public CassandraKeyspace Keyspace
+		{
+			get { return this._keyspace; }
+		}
+
+		/// <summary>
+		/// Gets ConnectionProvider.
+		/// </summary>
+		public IConnectionProvider ConnectionProvider
+		{
+			get { return this._connectionProvider; }
+		}
+
+		/// <summary>
+		/// 
+		/// </summary>
+		public IConnection Connection
+		{
+			get { return this._connection; }
+		}
+
+		/// <summary>
+		/// Gets a typed column family.
+		/// </summary>
+		/// <typeparam name="T">Type of column family.</typeparam>
+		/// <returns></returns>
+		public CassandraColumnFamily<T> GetColumnFamily<T>()
+		{
+			return _keyspace.GetColumnFamily<T>();
+		}
+
+		/// <summary>
+		/// 
+		/// </summary>
+		public void Dispose()
+		{
+			Dispose(true);
+		}
+
+		/// <summary>
+		/// The dispose.
+		/// </summary>
+		/// <param name="disposing">
+		/// The disposing.
+		/// </param>
+		protected virtual void Dispose(bool disposing)
+		{
+			if (!this._disposed && disposing && this._connection != null)
+				this._connectionProvider.Close(this._connection);
+
+			this._disposed = true;
+		}
+
+		/// <summary>
+		/// Finalizes an instance of the <see cref="Mongo"/> class. 
+		/// </summary>
+		~CassandraContext()
+		{
+			this.Dispose(false);
+		}
+	}
+}