Exemplo n.º 1
0
        public static void Main()
        {
            IDseCluster cluster = DseCluster.Builder().
                                  AddContactPoint("127.0.0.1").
                                  WithGraphOptions(new GraphOptions().SetName("killrvideo")).
                                  Build();
            IDseSession session = cluster.Connect();
            var         killr   = DseGraph.Traversal(session);

            PrintHeader("Actors for Young Guns", "killr.Movies(\"Young Guns\").Actors().Values(\"name\")");
            var results = killr.Movies("Young Guns").Actors().Values <string>("name").ToList();

            PrintItems(results);

            PrintHeader("Ratings Distribution by Age for Young Guns", "killr.Movies(\"Young Guns\").Ratings().DistributionForAges(18, 40)");
            IDictionary <string, long> ratingsByAge = killr.Movies("Young Guns").Ratings().DistributionForAges(18, 40).Next();
            var pairs = String.Join(", ", ratingsByAge.Select(kvp => kvp.Key + "=" + kvp.Value.ToString()));

            Console.WriteLine($"[{pairs}]");

            PrintHeader("Failed Validation", "killr.Movies(\"Young Guns\").Ratings().DistributionForAges(17,40)");
            try
            {
                killr.Movies("Young Guns").Ratings().DistributionForAges(17, 40).Next();
            }
            catch (ArgumentException ae)
            {
                Console.WriteLine($"Caught ArgumentException: {ae.Message}");
            }

            PrintHeader("Five Recommendations for u460", "killr.Users(\"u460\").Recommend(5, 7).Values(KEY_TITLE)");
            results = killr.Users("u460").Recommend(5, 7).Values <string>(KeyTitle).ToList();
            PrintItems(results);

            PrintHeader("Five Recommendations for u460 that are comedies", "killr.Users(\"u460\").Recommend(5, 7, Genre(COMEDY)).Values(KEY_TITLE)");
            results = killr.Users("u460").Recommend(5, 7, Genre(Comedy)).Values <string>(KeyTitle).ToList();
            PrintItems(results);

            PrintHeader("Five Recommendations for u460 that use larger actor sampling and are comedies", "killr.users(\"u460\").recommend(5, 7, genre(COMEDY)).values(KEY_TITLE)");
            results = killr.Users("u460").Recommend(5, 7, LargeSample, Genre(Comedy)).Values <string>(KeyTitle).ToList();
            PrintItems(results);

            PrintHeader("Include some additional graph statistics about Young Guns", "killr.movies(\"Young Guns\").enrich(IN_DEGREE, OUT_DEGREE)");
            IDictionary <object, object> enriched = killr.Movies("Young Guns").enrich(InDegree, OutDegree).Next();

            pairs = String.Join(", ", enriched.Select(kvp => kvp.Key + "=" + kvp.Value.ToString()));
            Console.WriteLine($"[{pairs}]");

            PrintHeader("Insert/update movie and a actors for that movie", "killr.movie(\"m100000\", \"Manos: The Hands of Fate\",...).actor(...)");
            killr.Movie("m100000", "Manos: The Hands of Fate", 1966, 70, "USA", "Sun City Films").
            Ensure <Vertex, object, Vertex>(__KillrVideo.Actor("p1000000", "Tom Neyman")).
            Ensure <Vertex, object, Vertex>(__KillrVideo.Actor("p1000001", "John Reynolds")).
            Ensure <Vertex, object, Vertex>(__KillrVideo.Actor("p1000002", "Diane Mahree")).
            Iterate();
            Console.WriteLine("Updated 'Manos: The Hands of Fate'");

            PrintHeader("Get the actors for the newly added movie", "killr.movies(\"Manos: The Hands of Fate\").actors().values(\"name\")");
            results = killr.Movies("Manos: The Hands of Fate").Actors().Values <String>("name").ToList();
            PrintItems(results);
        }
Exemplo n.º 2
0
 public void Test_Infrastructure()
 {
     using (var cluster = DseCluster.Builder().AddContactPoint(CcmHelper.InitialContactPoint).Build())
     {
         Assert.DoesNotThrow(() => cluster.Connect());
     }
 }
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;

            String create_keyspace   = @"CREATE KEYSPACE IF NOT EXISTS driver_test 
                                          WITH REPLICATION = { 
                                           'class' : 'NetworkTopologyStrategy', 
                                           'DC1' : 1 
                                          } ;
                                        ";
            String create_user_table = @"CREATE TABLE IF NOT EXISTS driver_test.user (
                                            id uuid, 
                                            first_name text, 
                                            last_name text, 
                                            PRIMARY KEY (id)
                                        );";

            IDseCluster cluster = DseCluster.Builder()
                                  .AddContactPoint("127.0.0.1")
                                  .Build();
            IDseSession session = cluster.Connect();

            session.Execute(create_keyspace);
            session.Execute(create_user_table);

            session.Dispose();
        }
Exemplo n.º 4
0
        public void Should_Have_The_Different_ReadTimeout_Per_Statement()
        {
            var timeout = 2000;

            using (var cluster = DseCluster.Builder()
                                 .AddContactPoint(CcmHelper.InitialContactPoint)
                                 .WithGraphOptions(new GraphOptions().SetName(GraphName).SetReadTimeoutMillis(timeout))
                                 .Build())
            {
                var session     = cluster.Connect();
                var stopwatch   = new Stopwatch();
                var stmtTimeout = 500;
                try
                {
                    stopwatch.Start();
                    session.ExecuteGraph(new SimpleGraphStatement("java.util.concurrent.TimeUnit.MILLISECONDS.sleep(1000L);")
                                         .SetReadTimeoutMillis(stmtTimeout));
                }
                catch
                {
                    stopwatch.Stop();
                    Assert.GreaterOrEqual(stopwatch.ElapsedMilliseconds, stmtTimeout);
                    Assert.Less(stopwatch.ElapsedMilliseconds, timeout);
                }
            }
        }
 public void TestFixtureSetup()
 {
     if (Values == null || Values.Length == 0)
     {
         throw new InconclusiveException("You must specify the values to test");
     }
     CcmHelper.Start(1);
     Cluster = DseCluster.Builder().AddContactPoint(CcmHelper.InitialContactPoint).Build();
     Trace.TraceInformation("Waiting additional time for test Cluster to be ready");
     Thread.Sleep(15000);
     Session = Cluster.Connect();
     Session.Execute(string.Format(CreateKeyspaceQuery, Keyspace));
     Session.Execute(string.Format("USE {0}", Keyspace));
     _queries = new[]
     {
         string.Format("CREATE TABLE geotable1 (id text, value '{0}', PRIMARY KEY (id))", TypeName),
         string.Format("CREATE TABLE keyed (id '{0}', value text, PRIMARY KEY (id))", TypeName),
         string.Format("INSERT INTO keyed (id, value) VALUES ('{0}', 'hello')", Values[0]),
         string.Format("CREATE TYPE geo_udt (f text, v '{0}')", TypeName),
         "CREATE TABLE tbl_udts (id uuid PRIMARY KEY, value frozen<geo_udt>)",
         string.Format("CREATE TABLE tbl_tuple (id uuid PRIMARY KEY, value tuple<int, '{0}'>)", TypeName),
         string.Format("CREATE TABLE tbl_list (id uuid PRIMARY KEY, value list<'{0}'>)", TypeName),
         string.Format("CREATE TABLE tbl_set (id uuid PRIMARY KEY, value set<'{0}'>)", TypeName),
         string.Format("CREATE TABLE tbl_map (id uuid PRIMARY KEY, value map<text, '{0}'>)", TypeName)
     };
     foreach (var query in _queries)
     {
         Session.Execute(query);
     }
 }
Exemplo n.º 6
0
        public void Should_Support_List_As_Parameter()
        {
            var names = new[] { "Mario", "Luigi", "Toad", "Bowser", "Peach", "Wario", "Waluigi" };

            using (var cluster = DseCluster.Builder()
                                 .AddContactPoint(CcmHelper.InitialContactPoint)
                                 .WithGraphOptions(new GraphOptions().SetName(GraphName))
                                 .Build())
            {
                var session = cluster.Connect();
                var schemaCharacterQuery = "" +
                                           "schema.propertyKey(\"characterName\").Text().create();\n" +
                                           "schema.vertexLabel(\"character\").properties(\"characterName\").create();";

                session.ExecuteGraph(new SimpleGraphStatement(schemaCharacterQuery));
                var createChars = session.ExecuteGraph(new SimpleGraphStatement("characters.each { character -> " +
                                                                                "    graph.addVertex(label, 'character', 'characterName', character);" +
                                                                                "};", new { characters = names }));
                Assert.AreEqual(names.Length, createChars.ToArray().Length);

                var rs          = session.ExecuteGraph(new SimpleGraphStatement("g.V().hasLabel('character').values('characterName')"));
                var resultArray = rs.ToArray();
                Assert.AreEqual(names.Length, resultArray.Length);

                foreach (var name in resultArray)
                {
                    Assert.True(names.Contains(name.ToString()));
                }
            }
        }
Exemplo n.º 7
0
        public void Should_Have_Infinite_ReadTimeout_Per_Statement()
        {
            //setting a really small global timeout to make sure that the query exceeds this time
            var timeout   = 2000;
            var stmtSleep = 10000L;

            using (var cluster = DseCluster.Builder()
                                 .AddContactPoint(CcmHelper.InitialContactPoint)
                                 .WithGraphOptions(new GraphOptions().SetName(GraphName).SetReadTimeoutMillis(timeout))
                                 .Build())
            {
                var session   = cluster.Connect();
                var stopwatch = new Stopwatch();
                try
                {
                    stopwatch.Start();
                    session.ExecuteGraph(new SimpleGraphStatement("java.util.concurrent.TimeUnit.MILLISECONDS.sleep(" + stmtSleep + ");")
                                         .SetReadTimeoutMillis(Timeout.Infinite));
                }
                finally
                {
                    stopwatch.Stop();
                    Assert.GreaterOrEqual(stopwatch.ElapsedMilliseconds, timeout);
                    Assert.GreaterOrEqual(stopwatch.ElapsedMilliseconds, stmtSleep);
                }
            }
        }
Exemplo n.º 8
0
        public void Should_Support_Types(string type, object value, string expectedString)
        {
            using (var cluster = DseCluster.Builder()
                                 .AddContactPoint(CcmHelper.InitialContactPoint)
                                 .WithGraphOptions(new GraphOptions().SetName(GraphName))
                                 .Build())
            {
                var session      = cluster.Connect();
                var id           = _idGenerator++;
                var vertexLabel  = "vertex" + id;
                var propertyName = "prop" + id;

                var schemaQuery = string.Format("schema.propertyKey(propertyName).{0}().ifNotExists().create();\n", type) +
                                  "schema.vertexLabel(vertexLabel).properties(propertyName).ifNotExists().create();";

                session.ExecuteGraph(new SimpleGraphStatement(schemaQuery, new { vertexLabel = vertexLabel, propertyName = propertyName }));

                var parameters = new { vertexLabel = vertexLabel, propertyName = propertyName, val = value };
                var rs         = session.ExecuteGraph(new SimpleGraphStatement("g.addV(label, vertexLabel, propertyName, val)", parameters));
                ValidateVertexResult(rs, vertexLabel, propertyName, expectedString);

                rs =
                    session.ExecuteGraph(
                        new SimpleGraphStatement("g.V().hasLabel(vertexLabel).has(propertyName, val).next()", parameters));
                ValidateVertexResult(rs, vertexLabel, propertyName, expectedString);
            }
        }
Exemplo n.º 9
0
 public void Should_Get_Path_With_Labels()
 {
     using (var cluster = DseCluster.Builder()
                          .AddContactPoint(CcmHelper.InitialContactPoint)
                          .WithGraphOptions(new GraphOptions().SetName(GraphName))
                          .Build())
     {
         var session = cluster.Connect();
         var rs      = session.ExecuteGraph(new SimpleGraphStatement(
                                                "g.V().hasLabel('person').has('name', 'marko').as('a').outE('knows').as('b').inV().as('c', 'd')" +
                                                ".outE('created').as('e', 'f', 'g').inV().as('h').path()"));
         foreach (Path path in rs)
         {
             Console.WriteLine("checking");
             CollectionAssert.AreEqual(
                 new string[][]
             {
                 new [] { "a" }, new [] { "b" }, new[] { "c", "d" }, new[] { "e", "f", "g" }, new [] { "h" }
             }, path.Labels);
             var person = path.Objects.First().ToVertex();
             Assert.AreEqual("person", person.Label);
             Assert.True(person.Properties.ContainsKey("name"));
         }
     }
 }
 /// <summary>
 /// Creates the classic graph using a specific connection
 /// </summary>
 public void CreateClassicGraph(string contactPoint, string name)
 {
     using (var cluster = DseCluster.Builder().AddContactPoint(TestClusterManager.InitialContactPoint).Build())
     {
         CreateClassicGraph(cluster.Connect(), name);
     }
 }
Exemplo n.º 11
0
        private Vertex IncludeAndQueryVertex(string vertexLabel, string propertyName, string type, object value, string expectedString, bool verifyToString = true)
        {
            Vertex vertex = null;

            using (var cluster = DseCluster.Builder()
                                 .AddContactPoint(TestClusterManager.InitialContactPoint)
                                 .WithGraphOptions(new GraphOptions().SetName(GraphName))
                                 .Build())
            {
                var session = cluster.Connect();

                var schemaQuery = string.Format("schema.propertyKey(propertyName).{0}.ifNotExists().create();\n", type) +
                                  "schema.vertexLabel(vertexLabel).properties(propertyName).ifNotExists().create();";

                session.ExecuteGraph(new SimpleGraphStatement(schemaQuery, new { vertexLabel = vertexLabel, propertyName = propertyName }));

                var parameters = new { vertexLabel = vertexLabel, propertyName = propertyName, val = value };
                session.ExecuteGraph(new SimpleGraphStatement("g.addV(label, vertexLabel, propertyName, val)", parameters));

                var rs =
                    session.ExecuteGraph(
                        new SimpleGraphStatement("g.V().hasLabel(vertexLabel).has(propertyName, val).next()", parameters));
                var first = rs.FirstOrDefault();
                Assert.NotNull(first);
                vertex = first.ToVertex();
                if (verifyToString)
                {
                    ValidateVertexResult(vertex, vertexLabel, propertyName, expectedString);
                }
            }
            return(vertex);
        }
        public void Should_Build_A_Cluster_With_Default_Graph_Options()
        {
            //without specifying graph options
            IDseCluster cluster = DseCluster.Builder().AddContactPoint("192.168.1.159").Build();

            Assert.NotNull(cluster.Configuration);
            Assert.NotNull(cluster.Configuration.CassandraConfiguration);
            Assert.NotNull(cluster.Configuration.GraphOptions);
        }
        public void Should_Build_A_Cluster_With_DseLoadBalancingPolicy()
        {
            //without specifying load balancing policy
            IDseCluster cluster = DseCluster.Builder().AddContactPoint("192.168.1.159").Build();

            Assert.NotNull(cluster.Configuration);
            Assert.IsInstanceOf <DseLoadBalancingPolicy>(
                cluster.Configuration.CassandraConfiguration.Policies.LoadBalancingPolicy);
        }
        public SessionManager()
        {
            cluster = DseCluster.Builder().AddContactPoint("127.0.0.1").Build();
            session = cluster.Connect("test");
            var row = session.Execute("select * from system.local").First();

            Console.WriteLine("Podłączono do klastra " + row.GetValue <string>("cluster_name"));
            PrepareStatements();
        }
 private static DseSession NewInstance(ISession coreSession, GraphOptions graphOptions = null)
 {
     //Cassandra Configuration does not have a public constructor
     //Create a dummy Cluster instance
     using (var cluster = DseCluster.Builder().AddContactPoint("127.0.0.1")
                          .WithGraphOptions(graphOptions ?? new GraphOptions()).Build())
     {
         return(new DseSession(coreSession, cluster.Configuration));
     }
 }
        public void Should_Build_A_Cluster_With_The_Specified_LoadBalancingPolicy()
        {
            var         lbp     = new TestLoadBalancingPolicy();
            IDseCluster cluster = DseCluster.Builder()
                                  .AddContactPoint("192.168.1.159")
                                  .WithLoadBalancingPolicy(lbp)
                                  .Build();

            Assert.NotNull(cluster.Configuration);
            Assert.AreSame(lbp, cluster.Configuration.CassandraConfiguration.Policies.LoadBalancingPolicy);
        }
        public void Should_Build_A_Cluster_With_Graph_Options()
        {
            var         graphOptions = new GraphOptions();
            IDseCluster cluster      = DseCluster.Builder()
                                       .WithGraphOptions(graphOptions)
                                       .AddContactPoint("192.168.1.159")
                                       .Build();

            Assert.NotNull(cluster.Configuration);
            Assert.NotNull(cluster.Configuration.CassandraConfiguration);
            Assert.AreSame(graphOptions, cluster.Configuration.GraphOptions);
        }
Exemplo n.º 18
0
 public void OneTimeSetUp()
 {
     TestClusterManager.CreateNew(1, new TestClusterOptions {
         Workloads = new[] { "graph" }
     });
     CreateClassicGraph(TestClusterManager.InitialContactPoint, GraphName);
     _cluster = DseCluster.Builder()
                .AddContactPoint(TestClusterManager.InitialContactPoint)
                .WithGraphOptions(new GraphOptions().SetName(GraphName))
                .Build();
     _session = _cluster.Connect();
 }
Exemplo n.º 19
0
 public static void VerifyCurrentClusterWorkloads(string[] expectedWorkloads)
 {
     using (var cluster = DseCluster.Builder()
                          .AddContactPoint(TestClusterManager.InitialContactPoint)
                          .Build())
     {
         cluster.Connect();
         foreach (var host in cluster.Metadata.AllHosts())
         {
             CollectionAssert.AreEquivalent(expectedWorkloads, host.Workloads);
         }
     }
 }
Exemplo n.º 20
0
        public CassandraDBRepository(IOptions <CassandraDBOptions> optionsAccessor, ILoggerFactory loggerFactory)
        {
            var         options = optionsAccessor.Value;
            IDseCluster cluster = DseCluster.Builder()
                                  .AddContactPoints(options.ContactPoints.Split(','))
                                  .WithAuthProvider(new DsePlainTextAuthProvider(options.Username, options.Password))
                                  .Build();

            session = cluster.Connect();

            tableName = options.Tablename;

            logger = loggerFactory.CreateLogger <CassandraDBRepository>();
        }
Exemplo n.º 21
0
        public void Should_Return_Zero_Results()
        {
            using (var cluster = DseCluster.Builder()
                                 .AddContactPoint(CcmHelper.InitialContactPoint)
                                 .WithGraphOptions(new GraphOptions().SetName(GraphName))
                                 .Build())
            {
                var session = cluster.Connect();
                var rs      = session.ExecuteGraph(new SimpleGraphStatement("g.V().hasLabel('notALabel')"));

                var resultArray = rs.ToArray();
                Assert.AreEqual(0, resultArray.Length);
            }
        }
        public Guid Post([FromBody] User user)
        {
            IDseCluster cluster = DseCluster.Builder()
                                  .AddContactPoint("127.0.0.1")
                                  .Build();
            IDseSession session     = cluster.Connect();
            Guid        user_id     = Guid.NewGuid();
            var         insert_user = session.Prepare(
                "INSERT INTO driver_test.user (id, first_name, last_name) VALUES(?,?,?)"
                );
            RowSet results = session.Execute(insert_user.Bind(user_id, user.first_name, user.last_name));

            return(user_id);
        }
Exemplo n.º 23
0
        public void Should_Support_Object_As_Parameter()
        {
            var name        = "Albert Einstein";
            var year        = 1879;
            var field       = "Physics";
            var citizenship = new[] { "Kingdom of Württemberg", "Switzerland", "Austria", "Germany", "United States" };

            using (var cluster = DseCluster.Builder()
                                 .AddContactPoint(CcmHelper.InitialContactPoint)
                                 .WithGraphOptions(new GraphOptions().SetName(GraphName))
                                 .Build())
            {
                var session = cluster.Connect();

                var schemaScientistQuery = "" +
                                           "schema.propertyKey(\"year_born\").Int().create()\n" +
                                           "schema.propertyKey(\"field\").Text().create()\n" +
                                           "schema.propertyKey(\"scientist_name\").Text().create()\n" +
                                           "schema.propertyKey(\"country_name\").Text().create()\n" +
                                           "schema.vertexLabel(\"scientist\").properties(\"scientist_name\", \"year_born\", \"field\").create()\n" +
                                           "schema.vertexLabel(\"country\").properties(\"country_name\").create()\n" +
                                           "schema.edgeLabel(\"had_citizenship\").connection(\"scientist\", \"country\").create()";
                session.ExecuteGraph(new SimpleGraphStatement(schemaScientistQuery));

                session.ExecuteGraph(new SimpleGraphStatement("Vertex scientist = graph.addVertex(label, 'scientist', 'scientist_name', m.name, 'year_born', m.year_born, 'field', m.field);" +
                                                              " m.citizenship.each { c -> " +
                                                              "    Vertex country = graph.addVertex(label, 'country', 'country_name', c);" +
                                                              "    scientist.addEdge('had_citizenship', country);" +
                                                              "};", new { m = new { name = name, year_born = year, citizenship = citizenship, field = field } }));


                var    rs       = session.ExecuteGraph(new SimpleGraphStatement("g.V().hasLabel('scientist').has('scientist_name', name)", new { name = name }));
                Vertex einstein = rs.FirstOrDefault();
                Assert.NotNull(einstein);
                Assert.AreEqual("scientist", einstein.Label);
                Assert.AreEqual(name, einstein.Properties["scientist_name"].ToArray()[0].Get <string>("value"));
                Assert.AreEqual(year, einstein.Properties["year_born"].ToArray()[0].Get <int>("value"));
                Assert.AreEqual(field, einstein.Properties["field"].ToArray()[0].Get <string>("value"));

                var citizenships     = session.ExecuteGraph(new SimpleGraphStatement("g.V().hasLabel('scientist').has('scientist_name', name).outE('had_citizenship').inV().values('country_name');", new { name = name }));
                var citizenshipArray = citizenships.ToArray();
                Assert.AreEqual(citizenship.Length, citizenshipArray.Length);

                foreach (var countryName in citizenshipArray)
                {
                    Assert.True(citizenship.Contains(countryName.ToString()));
                }
            }
        }
Exemplo n.º 24
0
        static WarmPathFunction()
        {
            var contactPoints = Environment.GetEnvironmentVariable("CassandraContactPoints", EnvironmentVariableTarget.Process);
            var username      = Environment.GetEnvironmentVariable("CassandraUsername", EnvironmentVariableTarget.Process);
            var password      = Environment.GetEnvironmentVariable("CassandraPassword", EnvironmentVariableTarget.Process);

            tableName = Environment.GetEnvironmentVariable("CassandraTableName", EnvironmentVariableTarget.Process);

            IDseCluster cluster = DseCluster.Builder()
                                  .AddContactPoints(contactPoints.Split(','))
                                  .WithAuthProvider(new DsePlainTextAuthProvider(username, password))
                                  .Build();

            session = cluster.Connect();
        }
        public string FindSparkMaster()
        {
            Trace.TraceInformation("GraphMultiNodeTests: FindSparkMaster");
            using (var cluster = DseCluster.Builder()
                                 .AddContactPoint(TestClusterManager.InitialContactPoint)
                                 .WithLoadBalancingPolicy(DseLoadBalancingPolicy.CreateDefault())
                                 .Build())
            {
                var session = cluster.Connect();

                var sparksRS      = session.Execute(new SimpleStatement("call DseClientTool.getAnalyticsGraphServer();"));
                var result        = sparksRS.ToArray();
                var sparkLocation = ((SortedDictionary <string, string>)result.First()[0])["location"];
                var sparkHost     = sparkLocation.Split(':')[0];
                return(sparkHost);
            }
        }
Exemplo n.º 26
0
        public void Should_Support_Multiple_Named_Parameters()
        {
            using (var cluster = DseCluster.Builder()
                                 .AddContactPoint(CcmHelper.InitialContactPoint)
                                 .WithGraphOptions(new GraphOptions().SetName(GraphName))
                                 .Build())
            {
                var session = cluster.Connect();
                var rs      = session.ExecuteGraph(new SimpleGraphStatement("[a,b]", new { a = 10, b = 20 }));

                Assert.NotNull(rs);
                var resultArray = rs.ToArray();
                Assert.AreEqual(2, resultArray.Length);
                Assert.AreEqual(10, resultArray[0].ToInt32());
                Assert.AreEqual(20, resultArray[1].ToInt32());
            }
        }
        public Table <User> GetTable()
        {
            IDseCluster cluster = DseCluster.Builder()
                                  .AddContactPoint("127.0.0.1")
                                  .Build();
            IDseSession session = cluster.Connect();

            MappingConfiguration.Global.Define(
                new Map <User>()
                .TableName("user")
                .PartitionKey(u => u.Id)
                .Column(u => u.Id, cm => cm.WithName("id"))
                .Column(u => u.FirstName, cm => cm.WithName("first_name"))
                .Column(u => u.LastName, cm => cm.WithName("last_name")));
            var users = new Table <User>(session);

            return(users);
        }
Exemplo n.º 28
0
        public void Should_Support_Named_Parameters()
        {
            using (var cluster = DseCluster.Builder()
                                 .AddContactPoint(CcmHelper.InitialContactPoint)
                                 .WithGraphOptions(new GraphOptions().SetName(GraphName))
                                 .Build())
            {
                var session = cluster.Connect();
                var rs      = session.ExecuteGraph(new SimpleGraphStatement("g.V().has('name', namedParam)", new { namedParam = "marko" }));

                Assert.NotNull(rs);
                var resultArray = rs.ToArray();
                Assert.AreEqual(1, resultArray.Length);
                var vertex = resultArray[0].ToVertex();
                Assert.NotNull(vertex);
                Assert.AreEqual("person", vertex.Label);
                Assert.AreEqual("marko", vertex.Properties["name"].ToArray()[0].Get <string>("value"));
            }
        }
Exemplo n.º 29
0
 public void Should_Retrieve_Graph_Edges()
 {
     using (var cluster = DseCluster.Builder()
                          .AddContactPoint(CcmHelper.InitialContactPoint)
                          .WithGraphOptions(new GraphOptions().SetName(GraphName))
                          .Build())
     {
         var session     = cluster.Connect();
         var rs          = session.ExecuteGraph(new SimpleGraphStatement("g.E().hasLabel('created')"));
         var resultArray = rs.ToArray();
         Assert.AreEqual(4, resultArray.Length);
         foreach (Edge edge in resultArray)
         {
             Assert.NotNull(edge);
             Assert.AreEqual("created", edge.Label);
             Assert.True(edge.Properties.ContainsKey("weight"));
         }
         Assert.NotNull(rs);
     }
 }
Exemplo n.º 30
0
 public void Should_Retrieve_Graph_Vertices()
 {
     using (var cluster = DseCluster.Builder()
                          .AddContactPoint(CcmHelper.InitialContactPoint)
                          .WithGraphOptions(new GraphOptions().SetName(GraphName))
                          .Build())
     {
         var session     = cluster.Connect();
         var rs          = session.ExecuteGraph(new SimpleGraphStatement("g.V().has('name', 'marko').out('knows')"));
         var resultArray = rs.ToArray();
         Assert.AreEqual(2, resultArray.Length);
         foreach (Vertex v in resultArray)
         {
             Assert.NotNull(v);
             Assert.AreEqual("person", v.Label);
             Assert.True(v.Properties.ContainsKey("name"));
         }
         Assert.NotNull(rs);
     }
 }