PHP Type::int方法代码示例

 /**
  * @param array  $values
  * @param string $key
  * @param int    $default
  * @return int
  */
 public static function int(array $values, $key, $default = 0)
 {
     if (isset($values[$key])) {
         return Type::int($values[$key]);
     }
     return $default;
 }

 /**
  * Composite Cassandra types (list, map, set, tuple, and UDT) to be used by
  * data providers
  */
 public function compositeCassandraTypes()
 {
     $collectionType = Type::collection(Type::varchar());
     $setType = Type::set(Type::varchar());
     $mapType = Type::map(Type::varchar(), Type::int());
     $tupleType = Type::tuple(Type::varchar(), Type::int(), Type::bigint());
     $userType = Type::userType("a", Type::varchar(), "b", Type::int(), "c", Type::bigint());
     $userType = $userType->withName(self::userTypeString($userType));
     return array(array($collectionType, array($collectionType->create("a", "b", "c"), $collectionType->create("d", "e", "f"), $collectionType->create("x", "y", "z"))), array($setType, array($setType->create("a", "b", "c"), $setType->create("d", "e", "f"), $setType->create("x", "y", "z"))), array($mapType, array($mapType->create("a", 1, "b", 2, "c", 3), $mapType->create("d", 4, "e", 5, "f", 6), $mapType->create("x", 7, "y", 8, "z", 9))), array($tupleType, array($tupleType->create("a", 1, new Bigint(2)), $tupleType->create("b", 3, new Bigint(4)), $tupleType->create("c", 5, new Bigint(6)))), array($userType, array($userType->create("a", "x", "b", 1, "c", new Bigint(2)), $userType->create("a", "y", "b", 3, "c", new Bigint(4)), $userType->create("a", "z", "b", 5, "c", new Bigint(6)))));
 }

 /**
  * Int tests
  */
 public function testInt()
 {
     $this->assertSame(1, Type::int(1));
     $this->assertSame(1, Type::int(1.2));
     $this->assertSame(0, Type::int(0.2));
     $this->assertSame(1, Type::int('1'));
     $this->assertSame(0, Type::int('test1'));
     $this->assertSame(1, Type::int('1test2'));
     $this->assertSame(0, Type::int([]));
     $this->assertSame(1, Type::int(['test']));
     $this->assertTrue(Type::isInt(1));
     $this->assertFalse(Type::isInt('1'));
     $this->assertFalse(Type::isInt(1.2));
     $this->assertFalse(Type::isInt([]));
 }

 public function notEqualTypes()
 {
     $setType = Type::set(Type::int());
     return array(array(Type::collection(Type::int())->create(), Type::collection(Type::varchar())->create()), array(Type::collection(Type::int())->create(1, 2, 3), Type::collection(Type::int())->create(4, 5, 6)), array(Type::collection(Type::int())->create(1, 2, 3), Type::collection(Type::int())->create(1)), array(Type::collection(Type::varchar())->create('a', 'b', 'c'), Type::collection(Type::varchar())->create('a', 'b', 'd')), array(Type::collection($setType)->create($setType->create(1, 2, 3)), Type::collection($setType)->create($setType->create(4, 5, 6))));
 }

 /**
  * Bind statement with an null map
  */
 public function testEmpty()
 {
     $mapType = Type::map(Type::int(), Type::int());
     $this->createTableInsertAndVerifyValueByIndex($mapType, null);
     $this->createTableInsertAndVerifyValueByName($mapType, null);
 }

 /**
  * Partial user type
  *
  * This test will ensure that partial user types return the correct value.
  *
  * @test
  * @ticket PHP-58
  */
 public function testPartial()
 {
     $userType = Type::userType("a", Type::int(), "b", Type::varchar(), "c", Type::bigint());
     $userType = $userType->withName(self::userTypeString($userType));
     $this->createUserType($userType);
     $user = $userType->create();
     $user->set("a", 99);
     $this->createTableInsertAndVerifyValueByIndex($userType, $user);
     $user = $userType->create();
     $user->set("b", "abc");
     $this->createTableInsertAndVerifyValueByIndex($userType, $user);
     $user = $userType->create();
     $user->set("c", new Bigint("999999999999"));
     $this->createTableInsertAndVerifyValueByIndex($userType, $user);
 }

 /**
  * Invalid datatypes for tuples.
  *
  * This test will ensure that an exception will occur when an invalid
  * datatype is used inside a tuple; issues from the server.
  *
  * @test
  * @ticket PHP-58
  * @expectedException \Cassandra\Exception\InvalidQueryException
  */
 public function testInvalidType()
 {
     $validType = Type::tuple(Type::int());
     $invalidType = Type::tuple(Type::varchar());
     $tableName = $this->createTable($validType);
     $options = new ExecutionOptions(array('arguments' => array("key", $invalidType->create("value"))));
     $this->insertValue($tableName, $options);
 }

 /**
  * Assert the `user_defined_aggregate` aggregate
  */
 protected function assertUserDefinedAggregate()
 {
     // Get the UDA from the current keyspace
     $keyspace = $this->session->schema()->keyspace($this->keyspaceName);
     $function = $keyspace->aggregate("user_defined_aggregate", Type::int());
     $expectedArgumentTypes = array("int");
     // Assert the UDA
     $this->assertEquals("user_defined_aggregate", $function->simpleName());
     $argumentTypes = array();
     foreach ($function->argumentTypes() as $argumentType) {
         $argumentTypes[] = "{$argumentType}";
     }
     $this->assertEquals($expectedArgumentTypes, $argumentTypes);
     $this->assertUserDefinedFunctionsEqual("user_defined_function", $function->stateFunction());
     $this->assertUserDefinedFunctionsEqual("uda_udf_final", $function->finalFunction());
     $this->assertEquals(0, $function->initialCondition());
     $this->assertEquals("int", $function->stateType());
     $this->assertEquals("int", $function->returnType());
     $this->assertEquals("user_defined_aggregate(int)", $function->signature());
     // Assert the UDFs
     $this->assertUserDefinedFunction();
     $this->assertAggregateUserDefinedFunction();
 }

 /**
  * Paging advancement does not create memory leak
  *
  * This test will ensure that the driver does not create memory leaks
  * associated advancing to the next page of results.
  *
  * @test
  * @ticket PHP-101
  */
 public function testNoPagingMemoryLeak()
 {
     // Create the user types and table for the test
     $this->session->execute(new SimpleStatement("DROP TABLE {$this->tableNamePrefix}"));
     $this->session->execute(new SimpleStatement("CREATE TYPE price_history (time timestamp, price float)"));
     $priceHistory = Type::userType("time", Type::timestamp(), "price", Type::float());
     $this->session->execute(new SimpleStatement("CREATE TYPE purchase_stats (day_of_week int, total_purchases int)"));
     $purchaseStats = Type::userType("day_of_week", Type::int(), "total_purchases", Type::int());
     $this->session->execute(new SimpleStatement("CREATE TABLE {$this->tableNamePrefix} (id uuid PRIMARY KEY,\n                history frozen<price_history>, stats frozen<purchase_stats>,\n                comments text)"));
     // Populate the table with some random data
     $totalInserts = 500;
     $statement = $this->session->prepare("INSERT INTO {$this->tableNamePrefix}\n            (id, history, stats, comments) VALUES (?, ?, ?, ?)");
     foreach (range(1, $totalInserts) as $i) {
         // Create the values for the insert
         $history = $priceHistory->create("time", new Timestamp(mt_rand(1270094400000, 1459483200000)), "price", new Float(mt_rand(1, 1000) / 100));
         $stats = $purchaseStats->create("day_of_week", mt_rand(0, 6), "total_purchases", mt_rand(0, 1000));
         $values = array(new Uuid(), $history, $stats, $this->randomString());
         $options = new ExecutionOptions(array("arguments" => $values));
         $this->session->execute($statement, $options);
     }
     // Select all the rows in the table using paging
     $statement = new SimpleStatement("SELECT * FROM {$this->tableNamePrefix}");
     $options = new ExecutionOptions(array("page_size" => 2));
     $rows = $this->session->execute($statement, $options);
     // Validate paging and ensure all the rows were read
     $count = $this->validatePageResults($rows);
     $this->assertEquals($totalInserts, $count);
 }

 /**
  * Bind statment with an null set
  */
 public function testNull()
 {
     $setType = Type::set(Type::int());
     $this->createTableInsertAndVerifyValueByIndex($setType, null);
     $this->createTableInsertAndVerifyValueByName($setType, null);
 }

 public function notEqualTypes()
 {
     $setType = Type::set(Type::int());
     return array(array(Type::userType('a', Type::int(), 'b', Type::varchar(), 'c', Type::varint())->create(), Type::userType('a', Type::int(), 'b', Type::varchar(), 'c', Type::bigint())->create()), array(Type::userType('a', Type::int(), 'b', Type::varchar(), 'c', Type::bigint())->create(), Type::userType('x', Type::int(), 'y', Type::varchar(), 'z', Type::bigint())->create()), array(Type::userType('a', Type::int(), 'b', Type::varchar(), 'c', Type::bigint())->create('a', 1, 'b', 'x', 'c', new Bigint(99)), Type::userType('a', Type::int(), 'b', Type::varchar(), 'c', Type::bigint())->create('a', 2, 'b', 'y', 'c', new Bigint(999))), array(Type::userType('a', $setType, 'b', Type::varchar())->create('a', $setType->create(1, 2, 3), 'b', 'x'), Type::userType('a', $setType, 'b', Type::varchar())->create('a', $setType->create(4, 5, 6), 'b', 'x')));
 }

 public function notEqualTypes()
 {
     $setType = Type::set(Type::int());
     return array(array(Type::tuple(Type::int(), Type::varchar(), Type::varint())->create(), Type::tuple(Type::int(), Type::varchar(), Type::bigint())->create()), array(Type::tuple(Type::int(), Type::varchar(), Type::bigint())->create(1, 'a', new Bigint(99)), Type::tuple(Type::int(), Type::varchar(), Type::bigint())->create(2, 'b', new Bigint(99))), array(Type::tuple($setType, Type::varchar())->create($setType->create(1, 2, 3), 'a'), Type::tuple($setType, Type::varchar())->create($setType->create(4, 5, 6), 'a')));
 }