舉報 
會員
Learning Apache Cassandra（Second Edition）
最新章節：
Wrapping up
IfyouareaNoSQLdeveloperandnewtoApacheCassandrawhowantstolearnitscommonaswellasnot-so-commonfeatures,thisbookisforyou.Alternatively,adeveloperwantingtoentertheworldofNoSQLwillfindthisbookuseful.Itdoesnotassumeanypriorexperienceincodingoranyframework.
最新章節
- Wrapping up
- Summary
- Security protects against vulnerabilities
- Security beyond authentication and authorization
- Authorization as a hedge against mistakes
- Authorization in action
品牌：中圖公司
上架時間：2021-07-02 19:01:29
出版社：Packt Publishing
本書數字版權由中圖公司提供，并由其授權上海閱文信息技術有限公司制作發行
- Wrapping up 更新時間：2021-07-03 00:20:28
- Summary
- Security protects against vulnerabilities
- Security beyond authentication and authorization
- Authorization as a hedge against mistakes
- Authorization in action
- Revoking access
- Viewing permissions
- Controlling access
- Viewing user accounts
- Changing a user's password
- Setting up a user
- Authentication in your application
- Authentication with cqlsh
- Authentication authorization and fault-tolerance
- Enabling authentication and authorization
- Authentication and Authorization
- Summary
- Other list operations
- Appending and prepending values to lists
- List columns in column families
- Map columns in column families
- Set columns in column families
- Collection columns in column families
- The empty cell
- The wide row data structure
- A complete mapping
- Compound primary keys in column families
- A model of column families: RowKey and cells
- Exploring cells
- The structure of a simple primary key table
- Using cassandra-cli
- Peeking under the Hood
- Summary
- Retry Policy
- TokenAwarePolicy
- DCAwareRoundRobinPolicy
- RoundRobinPolicy
- Load-balancing policy
- Driver policies
- Processing future results
- Execute asynchronously
- Asynchronous querying
- Building a SELECT statement
- Building an UPDATE statement
- Building an INSERT statement
- QueryBuilder API
- Prepared statements
- Querying
- Getting metadata
- Cluster API
- A simple query
- Application Development Using the Java Driver
- Summary
- Anti-entropy repair
- Read repair
- Hinted handoff
- Cassandra repair mechanisms
- The read path
- Compaction
- The write path
- Cassandra internals
- Consistency ANY
- Consistency QUORUM
- Write consistency
- Consistency in action
- Starting the 3-node cluster
- Cassandra-env.sh
- Cassandra.yaml
- Tuning configuration
- Tuning configuration options setting up a 3-node cluster
- Prerequisites
- 3 - node cluster
- Cassandra Multi-Node Cluster
- Summary
- Table configuration options
- Expiring columns with TTL
- Stumbling on tombstones
- Distributed deletion
- Overriding write timestamps
- Introspecting write timestamps
- Last-write-wins conflict resolution
- Handling conflicting data
- The CAP theorem
- Choosing the right consistency level
- Comparing consistency levels
- Local consistency levels
- Fault-tolerant immediate consistency with QUORUM
- Immediate consistency with ALL
- Eventual consistency with ONE
- Tuning consistency
- The anatomy of a successful request
- Consistency in Cassandra
- Immediate and eventual consistency
- Consistency
- Durable writes
- Replication strategy
- Snitch
- Multidata center cluster
- Gossip protocol
- Replication without a master
- Masterless replication
- Data replication in Cassandra
- Virtual nodes facilitate redistribution
- Virtual nodes
- Partition keys group data on the same node
- Partitioners
- Distributing partition tokens
- Cassandra's partitioning strategy - partition key tokens
- Data distribution in Cassandra
- How Cassandra Distributes Data
- Summary
- Standard aggregate functions
- User-defined aggregate functions
- User-defined functions
- Restarting Cassandra
- Modifying configuration
- Configuration location
- Cassandra configuration
- Counter columns need their own table
- Counter columns and deletion
- Setting and resetting counter columns
- Counters and upserts
- Updating a counter column
- Recording analytics observations
- The role of discrete observations
- The many possibilities for aggregation
- Precomputation versus read-time aggregation
- Answering the right question
- Recording aggregate analytics observations
- Slicing and dicing our data
- Using discrete analytics observations
- Recording discrete analytics observations
- Aggregating Time-Series Data
- Summary
- Comparing data structures
- Nested tuples/UDTs
- Nested collections
- Choosing between tuples and user-defined types
- Partial selection of user-defined types
- Indexing and querying user-defined types
- Adding data to a user-defined column
- Assigning a user-defined type to a column
- Creating a user-defined type
- User-defined types
- Indexing tuples
- Writing to tuples
- Creating a tuple column
- Working with tuples
- Performance of collection operations
- Unable to reuse collection names
- Reading a collection column from multiple rows
- Collection size limit
- Reading discrete values from collections
- The limitations of collections
- Secondary indexes on map columns
- Collections and secondary indexes
- Collections in inserts
- Removing values from maps
- Updating discrete values in a map
- Writing a map
- Using maps to store key-value pairs
- Removing elements from the list
- Writing data at a specific index
- Discrete list manipulation
- Writing a list
- Defining a list column
- Using lists for ordered non-unique values
- Collections and upserts
- Sets and uniqueness
- Removing values from a set
- Advanced set manipulation
- Reading and writing sets
- Defining collection columns
- Collection columns and concurrent updates
- Introducing concurrency
- Serializing the collection
- The problem with concurrent updates
- Collections Tuples and User-Defined Types
- Summary
- When lightweight transactions aren't necessary
- Lightweight transactions and their cost
- Optimistic locking and accidental updates
- Optimistic locking in action
- Optimistic locking with conditional updates
- Updates can create new rows
- Conditional inserts and lightweight transactions
- Another advantage of UUIDs
- Checking before inserting isn't enough
- Inserts can overwrite existing data
- Inserts updates and upserts
- Deleting table/keyspace with schema (DROP)
- Deleting table data (TRUNCATE)
- Syntactic sugar for deletion
- Deleting specific columns
- Missing columns in Cassandra
- Removing a value from a column
- Updating multiple rows
- Updating multiple columns
- Updating the existing rows
- Deleting columns
- Adding columns to tables
- Viewing a table schema in cqlsh
- Viewing a keyspace schema
- Expanding Your Data Model
- Summary
- Misuse of BATCH statements
- When to use unlogged batches
- Unlogged batches
- Logged batches
- Batching in Cassandra
- Write complexity and data integrity
- Displaying the home timeline
- Creating a status update
- Fully denormalizing the home timeline
- Read performance and write complexity
- Displaying the home timeline
- Partial denormalization
- Multiple partitions and read efficiency
- Ordering and pagination
- Generating the timeline
- A normalized approach
- Denormalizing Data for Maximum Performance
- Summary
- Adding a view
- Materialized views
- Secondary index lookup is not as efficient as primary key lookup
- Secondary indexes can only be tested for equality
- Secondary indexes can only have one column
- Limitations of secondary indexes
- Other uses of secondary indexes
- Adding a secondary index
- The form of the single table
- Using secondary indexes to avoid denormalization
- Unfollowing users
- Looking up follow relationships
- Denormalization
- Physical data model
- Logical data model (query-driven design)
- Conceptual data model (entity relationship model)
- Cassandra data modelling
- Storing follow relationships
- Inbound follows
- Outbound follows
- Modeling follow relationships
- Establishing Relationships
- Summary
- Building an autocomplete function
- SELECT JSON
- INSERT JSON
- JSON support
- Paginating over multiple partitions
- ORDER BY summary
- Limitations of ORDER BY
- Reversing clustering order in the schema
- Reversing clustering order at query time
- Reversing the order of rows
- Counting rows
- Paginating over rows in a partition
- Selecting a slice of a partition
- Creating time UUID ranges
- Retrieving status updates for a specific time range
- Restricting by part of a partition key
- Restricting by clustering column
- The limits of the WHERE keyword
- Looking up rows by partition
- Beyond Key-Value Lookup
- Summary
- Refining our mental model
- When to use static columns
- Static columns act like predefined joins
- Static-only inserts
- Interacting only with the static columns
- Working with static columns
- Defining static columns
- Coupling parents and children using static columns
- Compound keys represent parent-child relationships
- Composite partition key with multiple clustering columns
- Structure of composite partition key tables
- Composite partition key table
- Composite partition keys
- Multiple clustering columns
- Beyond two columns
- Anatomy of a single-column primary key
- Anatomy of a compound primary key
- Automatically generating UUIDs
- Looking up a specific status update
- Extracting timestamps
- Working with status updates
- UUIDs and timestamps
- The structure of the status updates table
- Creating a table with a compound primary key
- A table for status updates
- Organizing Related Data
- Summary
- Developing a mental model for Cassandra
- Inserts are always upserts
- Paginating through results
- Retrieving all the rows
- Selecting more than one row
- Missing rows
- Selecting data
- Partial inserts
- Writing data does not yield feedback
- Inserting data
- The purpose of types
- Other data types
- Collections
- Blobs
- Booleans
- UUIDs
- Timestamp
- Floating point and decimal numbers
- Integers
- Strings
- The type system
- Table and column options
- Structuring of tables
- Creating the users table
- How to configure keyspaces
- The First Table
- Summary
- New features in Cassandra 2.2 3.0 and 3.X
- Inserting and reading data
- Creating a table
- Selecting a keyspace
- Creating a keyspace
- Getting started with CQL
- Interacting with Cassandra
- CQL—the Cassandra Query Language
- Bootstrapping the project
- Installing the binary tarball
- Installing on Mac OS X
- Installing on Windows
- Installing on RHEL-based systems
- Installing on Debian-based systems (Ubuntu)
- Installing the JDK
- Installing Cassandra
- Comparing Cassandra to the alternatives
- Multidata center replication
- Lightweight transactions
- Rich and flexible data model
- MapReduce and Spark
- Relational joins
- Discretely writable collections
- Immediate consistency
- Efficient result ordering
- Materialized views
- Secondary indexes
- Structured records
- Write optimization
- High availability
- Horizontal scalability
- What is Cassandra and why Cassandra?
- How to handle big data
- Why not relational databases?
- Challenges of modern applications
- What is big data?
- Getting Up and Running with Cassandra
- Questions
- Piracy
- Errata
- Downloading the color images of this book
- Downloading the example code
- Customer support
- Reader feedback
- Conventions
- Who this book is for
- What you need for this book
- What this book covers
- Preface
- Customer Feedback
- www.PacktPub.com
- About the Reviewer
- About the Author
- Credits
- 版權信息
- 封面
- 封面
- 版權信息
- Credits
- About the Author
- About the Reviewer
- www.PacktPub.com
- Customer Feedback
- Preface
- What this book covers
- What you need for this book
- Who this book is for
- Conventions
- Reader feedback
- Customer support
- Downloading the example code
- Downloading the color images of this book
- Errata
- Piracy
- Questions
- Getting Up and Running with Cassandra
- What is big data?
- Challenges of modern applications
- Why not relational databases?
- How to handle big data
- What is Cassandra and why Cassandra?
- Horizontal scalability
- High availability
- Write optimization
- Structured records
- Secondary indexes
- Materialized views
- Efficient result ordering
- Immediate consistency
- Discretely writable collections
- Relational joins
- MapReduce and Spark
- Rich and flexible data model
- Lightweight transactions
- Multidata center replication
- Comparing Cassandra to the alternatives
- Installing Cassandra
- Installing the JDK
- Installing on Debian-based systems (Ubuntu)
- Installing on RHEL-based systems
- Installing on Windows
- Installing on Mac OS X
- Installing the binary tarball
- Bootstrapping the project
- CQL—the Cassandra Query Language
- Interacting with Cassandra
- Getting started with CQL
- Creating a keyspace
- Selecting a keyspace
- Creating a table
- Inserting and reading data
- New features in Cassandra 2.2 3.0 and 3.X
- Summary
- The First Table
- How to configure keyspaces
- Creating the users table
- Structuring of tables
- Table and column options
- The type system
- Strings
- Integers
- Floating point and decimal numbers
- Timestamp
- UUIDs
- Booleans
- Blobs
- Collections
- Other data types
- The purpose of types
- Inserting data
- Writing data does not yield feedback
- Partial inserts
- Selecting data
- Missing rows
- Selecting more than one row
- Retrieving all the rows
- Paginating through results
- Inserts are always upserts
- Developing a mental model for Cassandra
- Summary
- Organizing Related Data
- A table for status updates
- Creating a table with a compound primary key
- The structure of the status updates table
- UUIDs and timestamps
- Working with status updates
- Extracting timestamps
- Looking up a specific status update
- Automatically generating UUIDs
- Anatomy of a compound primary key
- Anatomy of a single-column primary key
- Beyond two columns
- Multiple clustering columns
- Composite partition keys
- Composite partition key table
- Structure of composite partition key tables
- Composite partition key with multiple clustering columns
- Compound keys represent parent-child relationships
- Coupling parents and children using static columns
- Defining static columns
- Working with static columns
- Interacting only with the static columns
- Static-only inserts
- Static columns act like predefined joins
- When to use static columns
- Refining our mental model
- Summary
- Beyond Key-Value Lookup
- Looking up rows by partition
- The limits of the WHERE keyword
- Restricting by clustering column
- Restricting by part of a partition key
- Retrieving status updates for a specific time range
- Creating time UUID ranges
- Selecting a slice of a partition
- Paginating over rows in a partition
- Counting rows
- Reversing the order of rows
- Reversing clustering order at query time
- Reversing clustering order in the schema
- Limitations of ORDER BY
- ORDER BY summary
- Paginating over multiple partitions
- JSON support
- INSERT JSON
- SELECT JSON
- Building an autocomplete function
- Summary
- Establishing Relationships
- Modeling follow relationships
- Outbound follows
- Inbound follows
- Storing follow relationships
- Cassandra data modelling
- Conceptual data model (entity relationship model)
- Logical data model (query-driven design)
- Physical data model
- Denormalization
- Looking up follow relationships
- Unfollowing users
- Using secondary indexes to avoid denormalization
- The form of the single table
- Adding a secondary index
- Other uses of secondary indexes
- Limitations of secondary indexes
- Secondary indexes can only have one column
- Secondary indexes can only be tested for equality
- Secondary index lookup is not as efficient as primary key lookup
- Materialized views
- Adding a view
- Summary
- Denormalizing Data for Maximum Performance
- A normalized approach
- Generating the timeline
- Ordering and pagination
- Multiple partitions and read efficiency
- Partial denormalization
- Displaying the home timeline
- Read performance and write complexity
- Fully denormalizing the home timeline
- Creating a status update
- Displaying the home timeline
- Write complexity and data integrity
- Batching in Cassandra
- Logged batches
- Unlogged batches
- When to use unlogged batches
- Misuse of BATCH statements
- Summary
- Expanding Your Data Model
- Viewing a keyspace schema
- Viewing a table schema in cqlsh
- Adding columns to tables
- Deleting columns
- Updating the existing rows
- Updating multiple columns
- Updating multiple rows
- Removing a value from a column
- Missing columns in Cassandra
- Deleting specific columns
- Syntactic sugar for deletion
- Deleting table data (TRUNCATE)
- Deleting table/keyspace with schema (DROP)
- Inserts updates and upserts
- Inserts can overwrite existing data
- Checking before inserting isn't enough
- Another advantage of UUIDs
- Conditional inserts and lightweight transactions
- Updates can create new rows
- Optimistic locking with conditional updates
- Optimistic locking in action
- Optimistic locking and accidental updates
- Lightweight transactions and their cost
- When lightweight transactions aren't necessary
- Summary
- Collections Tuples and User-Defined Types
- The problem with concurrent updates
- Serializing the collection
- Introducing concurrency
- Collection columns and concurrent updates
- Defining collection columns
- Reading and writing sets
- Advanced set manipulation
- Removing values from a set
- Sets and uniqueness
- Collections and upserts
- Using lists for ordered non-unique values
- Defining a list column
- Writing a list
- Discrete list manipulation
- Writing data at a specific index
- Removing elements from the list
- Using maps to store key-value pairs
- Writing a map
- Updating discrete values in a map
- Removing values from maps
- Collections in inserts
- Collections and secondary indexes
- Secondary indexes on map columns
- The limitations of collections
- Reading discrete values from collections
- Collection size limit
- Reading a collection column from multiple rows
- Unable to reuse collection names
- Performance of collection operations
- Working with tuples
- Creating a tuple column
- Writing to tuples
- Indexing tuples
- User-defined types
- Creating a user-defined type
- Assigning a user-defined type to a column
- Adding data to a user-defined column
- Indexing and querying user-defined types
- Partial selection of user-defined types
- Choosing between tuples and user-defined types
- Nested collections
- Nested tuples/UDTs
- Comparing data structures
- Summary
- Aggregating Time-Series Data
- Recording discrete analytics observations
- Using discrete analytics observations
- Slicing and dicing our data
- Recording aggregate analytics observations
- Answering the right question
- Precomputation versus read-time aggregation
- The many possibilities for aggregation
- The role of discrete observations
- Recording analytics observations
- Updating a counter column
- Counters and upserts
- Setting and resetting counter columns
- Counter columns and deletion
- Counter columns need their own table
- Cassandra configuration
- Configuration location
- Modifying configuration
- Restarting Cassandra
- User-defined functions
- User-defined aggregate functions
- Standard aggregate functions
- Summary
- How Cassandra Distributes Data
- Data distribution in Cassandra
- Cassandra's partitioning strategy - partition key tokens
- Distributing partition tokens
- Partitioners
- Partition keys group data on the same node
- Virtual nodes
- Virtual nodes facilitate redistribution
- Data replication in Cassandra
- Masterless replication
- Replication without a master
- Gossip protocol
- Multidata center cluster
- Snitch
- Replication strategy
- Durable writes
- Consistency
- Immediate and eventual consistency
- Consistency in Cassandra
- The anatomy of a successful request
- Tuning consistency
- Eventual consistency with ONE
- Immediate consistency with ALL
- Fault-tolerant immediate consistency with QUORUM
- Local consistency levels
- Comparing consistency levels
- Choosing the right consistency level
- The CAP theorem
- Handling conflicting data
- Last-write-wins conflict resolution
- Introspecting write timestamps
- Overriding write timestamps
- Distributed deletion
- Stumbling on tombstones
- Expiring columns with TTL
- Table configuration options
- Summary
- Cassandra Multi-Node Cluster
- 3 - node cluster
- Prerequisites
- Tuning configuration options setting up a 3-node cluster
- Tuning configuration
- Cassandra.yaml
- Cassandra-env.sh
- Starting the 3-node cluster
- Consistency in action
- Write consistency
- Consistency QUORUM
- Consistency ANY
- Cassandra internals
- The write path
- Compaction
- The read path
- Cassandra repair mechanisms
- Hinted handoff
- Read repair
- Anti-entropy repair
- Summary
- Application Development Using the Java Driver
- A simple query
- Cluster API
- Getting metadata
- Querying
- Prepared statements
- QueryBuilder API
- Building an INSERT statement
- Building an UPDATE statement
- Building a SELECT statement
- Asynchronous querying
- Execute asynchronously
- Processing future results
- Driver policies
- Load-balancing policy
- RoundRobinPolicy
- DCAwareRoundRobinPolicy
- TokenAwarePolicy
- Retry Policy
- Summary
- Peeking under the Hood
- Using cassandra-cli
- The structure of a simple primary key table
- Exploring cells
- A model of column families: RowKey and cells
- Compound primary keys in column families
- A complete mapping
- The wide row data structure
- The empty cell
- Collection columns in column families
- Set columns in column families
- Map columns in column families
- List columns in column families
- Appending and prepending values to lists
- Other list operations
- Summary
- Authentication and Authorization
- Enabling authentication and authorization
- Authentication authorization and fault-tolerance
- Authentication with cqlsh
- Authentication in your application
- Setting up a user
- Changing a user's password
- Viewing user accounts
- Controlling access
- Viewing permissions
- Revoking access
- Authorization in action
- Authorization as a hedge against mistakes
- Security beyond authentication and authorization
- Security protects against vulnerabilities
- Summary
- Wrapping up 更新時間：2021-07-03 00:20:28
