C# ISession.Execute方法代码示例

 public void SetupFixture()
 {
     Diagnostics.CassandraTraceSwitch.Level = TraceLevel.Info;
     //Using a mirroring handler, the server will reply providing the same payload that was sent
     var jvmArgs = new [] { "-Dcassandra.custom_query_handler_class=org.apache.cassandra.cql3.CustomPayloadMirroringQueryHandler" };
     var testCluster = TestClusterManager.GetTestCluster(1, 0, false, DefaultMaxClusterCreateRetries, true, true, 0, jvmArgs);
     Session = testCluster.Session;
     Session.Execute(String.Format(TestUtils.CreateKeyspaceSimpleFormat, Keyspace, 1));
     Session.Execute(String.Format(TestUtils.CreateTableSimpleFormat, Table));
 }

 public void CreateMultiDcSchema(ISession session, int dc1RF = 1, int dc2RF = 1)
 {
     session.Execute(String.Format(TestUtils.CreateKeyspaceGenericFormat, DefaultKeyspace, "NetworkTopologyStrategy",
                                       string.Format("'dc1' : {0}, 'dc2' : {1}", dc1RF, dc2RF)));
     TestUtils.WaitForSchemaAgreement(session.Cluster);
     session.ChangeKeyspace(DefaultKeyspace);
     TestUtils.WaitForSchemaAgreement(session.Cluster);
     session.Execute(String.Format("CREATE TABLE {0} (k int PRIMARY KEY, i int)", TableName));
     TestUtils.WaitForSchemaAgreement(session.Cluster);
 }

        public void Execute(ISession session)
        {
            if (_animal.Id > 0)
            {
                session.Execute("UPDATE Animals SET Name = @Name, CommonName = @CommonName WHERE Id = @Id", new { _animal.Id, _animal.Name, _animal.CommonName });
                return;
            }

            session.Execute("INSERT INTO Animals (Name, CommonName) VALUES (@Name, @CommonName)", new { _animal.Name, _animal.CommonName });
        }

        protected override void TestFixtureSetUp()
        {
            if (CassandraVersion < Version.Parse("2.1.0"))
                Assert.Ignore("Requires Cassandra version >= 2.1");
            
            base.TestFixtureSetUp();
            _session = Session;

            _session.Execute(String.Format(TestUtils.CreateKeyspaceSimpleFormat, _uniqueKeyspaceName, 1));
            _session.ChangeKeyspace(_uniqueKeyspaceName);
            _session.Execute("CREATE TYPE song (id uuid, title text, artist text)");
            _session.UserDefinedTypes.Define(UdtMap.For<Song>());
        }

 public void CreateSchema(ISession session, int replicationFactor)
 {
     try
     {
         session.Execute(String.Format(TestUtils.CreateKeyspaceSimpleFormat, DefaultKeyspace, replicationFactor));
     }
     catch (AlreadyExistsException)
     {
     }
     TestUtils.WaitForSchemaAgreement(session.Cluster);
     session.ChangeKeyspace(DefaultKeyspace);
     session.Execute(String.Format("CREATE TABLE {0} (k int PRIMARY KEY, i int)", TableName));
     TestUtils.WaitForSchemaAgreement(session.Cluster);
 }

        protected override void TestFixtureSetUp()
        {
            base.TestFixtureSetUp();
            _session = Session;

            _session.Execute(String.Format(TestUtils.CreateKeyspaceSimpleFormat, _uniqueKeyspaceName, 1));
            _session.ChangeKeyspace(_uniqueKeyspaceName);
            _session.Execute("CREATE TYPE song (id uuid, title text, artist text)");
            _session.Execute("CREATE TABLE albums (id uuid primary key, name text, songs list<frozen<song>>, publishingdate timestamp)");
            _session.Execute(
                new SimpleStatement(
                    "INSERT INTO albums (id, name, songs) VALUES (?, 'Legend', [{id: uuid(), title: 'Africa Unite', artist: 'Bob Marley'}])",
                    _sampleId));
            _session.UserDefinedTypes.Define(UdtMap.For<Song>());
        }

 public Action GetInsertAction(ISession session, object bindableStatement, ConsistencyLevel consistency, int rowsPerId)
 {
     Action action = () =>
     {
         Trace.TraceInformation("Starting inserting from thread {0}", Thread.CurrentThread.ManagedThreadId);
         var id = Guid.NewGuid();
         for (var i = 0; i < rowsPerId; i++)
         {
             var paramsArray = new object[] { id, DateTime.Now, DateTime.Now.ToString() };
             IStatement statement = null;
             if (bindableStatement is SimpleStatement)
             {
                 statement = ((SimpleStatement)bindableStatement).Bind(paramsArray).SetConsistencyLevel(consistency);
             }
             else if (bindableStatement is PreparedStatement)
             {
                 statement = ((PreparedStatement)bindableStatement).Bind(paramsArray).SetConsistencyLevel(consistency);
             }
             else
             {
                 throw new Exception("Can not bind a statement of type " + bindableStatement.GetType().FullName);
             }
             session.Execute(statement);
         }
         Trace.TraceInformation("Finished inserting from thread {0}", Thread.CurrentThread.ManagedThreadId);
     };
     return action;
 }

 private static void AssertCanQuery(ISession session)
 {
     for (var i = 0; i < 10; i++)
     {
         Assert.DoesNotThrow(() => session.Execute("SELECT key FROM system.local"));
     }
 }

 internal static void ExecuteSyncQuery(ISession session, string query, ConsistencyLevel consistency, List<object[]> expectedValues = null,
                                       string messageInstead = null)
 {   
     var ret = session.Execute(query, consistency);
     if (expectedValues != null)
     {
         valueComparator(ret, expectedValues);
     }
 }

        public static void CreateForumTables(ISession session)
        {
            var createTopicCql = @"
                CREATE TABLE driver_samples_kp.topics (
                    topic_id uuid PRIMARY KEY,
                    topic_title text,
                    topic_date timestamp
                )";
            session.Execute(createTopicCql);

            var createMessageCql = @"
                CREATE TABLE driver_samples_kp.messages (
                    topic_id uuid,
                    message_date timestamp,
                    message_body text,
                    PRIMARY KEY (topic_id, message_date)
                )";
            session.Execute(createMessageCql);
        }

 public Action GetSelectAction(ISession session, string query, ConsistencyLevel consistency, int executeLength)
 {
     Action action = () =>
     {
         for (var i = 0; i < executeLength; i++)
         {
             var rs = session.Execute(new SimpleStatement(query).SetPageSize(500).SetConsistencyLevel(consistency).SetRetryPolicy(DowngradingConsistencyRetryPolicy.Instance));
             //Count will iterate through the result set and it will likely to page results
             //Assert.True(rs.Count() > 0);
         }
     };
     return action;
 }

 private static void CreateTimeSeriesTable(ISession session)
 {
     //These are not the codez you are looking for ...
     //Boring code just intended to create the schema
     var createCql = @"
         CREATE TABLE driver_samples_kp.temperature_by_day (
            weatherstation_id text,
            date text,
            event_time timestamp,
            temperature decimal,
            PRIMARY KEY ((weatherstation_id,date),event_time)
         )";
     session.Execute(createCql);
 }

        private ITestCluster SetupSessionAndCluster(int nodes, Dictionary<string, string> replication = null)
        {
            ITestCluster testCluster = TestClusterManager.GetTestCluster(nodes);
            _session = testCluster.Session;
            _ksName = TestUtils.GetUniqueKeyspaceName();
            _session.CreateKeyspace(_ksName, replication);
            TestUtils.WaitForSchemaAgreement(_session.Cluster);
            _session.ChangeKeyspace(_ksName);
            _table = new Table<ManyDataTypesEntity>(_session, new MappingConfiguration());
            _table.Create();
            _defaultPocoList = ManyDataTypesEntity.GetDefaultAllDataTypesList();
            _preparedStatement = _session.Prepare(_preparedInsertStatementAsString);
            foreach (var manyDataTypesEntity in _defaultPocoList)
                _session.Execute(GetBoundInsertStatementBasedOnEntity(manyDataTypesEntity));

            return testCluster;
        }

        /*
         * Function to attempt log in to a user account
         * @PARAMETERS: - song: the song to add
         * @RETURNS: The User who has been logged in - null if unsuccesful
         * @AUTHORS: Andrew Davis and Matt Malone
         * NOTE - Commented code left in by Matt - just in case it breaks
         */
        public bool doInsertTrack(Song song, ISession session)
        {
            try
            {
                // Call to initialise cluster connection
                //init();

                ///

                Guid tid = song.getSongID();
                String artist = song.getArtist();
                String album = song.getAlbum();
                int year = song.getYear();
                String genre = song.getGenre();
                String file_loc = song.getFileLocation();
                int length = song.getLength();
                String trackname = song.getTrackName();

                // Connect to cluster
                //ISession session = cluster.Connect("maltmusic");

                //Guid tid = Guid.NewGuid();

                // Prepare and bind statement passing in username
                String todo = ("insert into tracks (\n" +
                  "track_id, artist, album, year,genre, file_loc,length,track_name)\n" +
                 "values (:tid, :art,:alb,:yr,:gnr,:floc,:len,:tnm) if not exists");

                PreparedStatement ps = session.Prepare(todo);

                BoundStatement bs = ps.Bind(tid, artist, album, year, genre, file_loc, length, trackname);

                // Execute Query
                session.Execute(bs);
                //session.Dispose();
                return true;

                // Catch exceptions
            }
            catch (Exception ex)
            {
                Console.WriteLine("SOMETHING WENT WRONG in INSERT TRACK: " + ex.Message);
                return false;
            }
        }

        /// <summary>
        /// Creates the schema if it doesn't exist.
        /// </summary>
        public static void CreateSchemaIfNotExists(ISession session)
        {
            var cqlStatements = new List<string>();

            // Read the CQL script in from the embedded resource
            using (var stream = CqlAssembly.GetManifestResourceStream(CqlScript))
            {
                if (stream == null)
                    throw new InvalidOperationException(string.Format("Could not find CQL script resource {0}", CqlScript));

                using (var reader = new StreamReader(stream))
                {
                    string currentLine;
                    var cqlStatement = new StringBuilder();
                    while ((currentLine = reader.ReadLine()) != null)
                    {
                        // Do some basic parsing
                        currentLine = currentLine.Trim();
                        
                        // Skip comment lines and empty lines
                        if (currentLine.StartsWith("//") || currentLine == string.Empty)
                            continue;

                        // Add line to current cql statement
                        cqlStatement.AppendFormat("{0} ", currentLine);

                        // If the line ends with a semi-colon, consider it the end of the statement
                        if (currentLine.EndsWith(";"))
                        {
                            cqlStatements.Add(cqlStatement.ToString());
                            cqlStatement.Clear();
                        }
                    }
                }
            }

            // Execute the CQL statements we parsed to create the schema
            foreach (string cql in cqlStatements)
            {
                session.Execute(cql);
            }
        }