%{search_type} search results

• Introduction
• Background
• ACQUA : approximate continuous query answering in RSP
• Handling queries with a FILTER clause
• Rank aggregation in queries with a FILTER clause
• Handling top-k queries
• Conclusion.

This book examines the problem of relevant query answering over the Web and provides a comprehensive overview of relevant query answering over streaming and distributed data. In recent years, Web applications that combine highly dynamic data streams with data distributed over the Web to provide relevant answers have attracted increasing attention. Answering in a timely fashion, i.e., reactively, is one of the most important performance indicators, especially when the distributed data is evolving. The book proposes a solution that retains a local replica of the distributed data and offers various maintenance policies to refresh the replica over time. A limited refresh budget guarantees the reactiveness of the system. Focusing on stream processing and Semantic Web, it appeals to scientists and graduate students in the field.
(source: Nielsen Book Data)

• SQL Query Performance Tuning
• System Performance Analysis
• SQL Query Performance Analysis
• Index Analysis
• Database Engine Tuning Advisor
• Lookup Analysis
• Statistics Analysis
• Fragmentation Analysis
• Execution Plan Cache Analysis
• Query Recompilation
• Query Design Analysis
• Blocking Analysis
• Deadlock Analysis
• Cursor Cost Analysis
• Database Performance Testing
• Database Workload Optimization
• SQL Server Optimization Checklist.

Queries not running fast enough? Tired of the phone calls from frustrated users? Grant Fritchey's book SQL Server 2012 Query Performance Tuning is the answer to your SQL Server query performance problems. The book is revised to cover the very latest in performance optimization features and techniques. It is current with SQL Server 2012. It provides the tools you need to approach your queries with performance in mind. SQL Server 2012 Query Performance Tuning leads you through understanding the causes of poor performance, how to identify them, and how to fix them. You'll learn to be proactive in establishing performance baselines using tools like Performance Monitor and Extended Events. You'll learn to recognize bottlenecks and defuse them before the phone rings. You'll learn some quick solutions too, but emphasis is on designing for performance and getting it right, and upon heading off trouble before it occurs. Delight your users. Silence that ringing phone. Put the principles and lessons from SQL Server 2012 Query Performance Tuning into practice today. Establish performance baselines and monitor against them Troubleshoot and eliminate bottlenecks that frustrate users Plan ahead to achieve the right level of performance.
(source: Nielsen Book Data)

• Introduction to Process Querying.- Part I: Event Log Querying.- BP-SPARQL: A Query Language for Summarizing and Analyzing Big Process Data.- Data-Aware Process Oriented Query Language.- Process Instance Query Language and the Process Querying Framework.- Part II: Process Model Querying.- The Diagramed Model Query Language 2
• .0: Design, Implementation, and Evaluation.- VM*: A Family of Visual Model Manipulation Languages.- The BPMN Visual Query Language and Process Querying Framework.- Retrieving, Abstracting, and Changing Business Process Models with PQL.- QuBPAL: Querying Business Process Knowledge.- CRL and the Design-Time Compliance Management Framework.- Process Query Language.- Part III: Event Log and Process Model Querying.- Business Process Query Language.- Celonis PQL: A Query Language for Process Mining.- Part IV: Other Process Querying Methods.- Process Querying Using Process Model Similarity.- Logic-Based Approaches for Process Querying.- Process Model Similarity Techniques for Process Querying.- Complex Event Processing Methods for Process Querying.- Process Querying: Methods, Techniques, and Applications.
• (source: Nielsen Book Data)

This book presents a framework for developing as well as a comprehensive collection of state-of-the-art process querying methods. Process querying combines concepts from Big Data and Process Modeling and Analysis with Business Process Intelligence and Process Analytics to study techniques for retrieving and manipulating models of real-world and envisioned processes to organize and extract process-related information for subsequent systematic use. The book comprises sixteen contributed chapters distributed over four parts and two auxiliary chapters. The auxiliary chapters by the editor provide an introduction to the area of process querying and a summary of the presented methods, techniques, and applications for process querying. The introductory chapter also examines a process querying framework. The contributed chapters present various process querying methods, including discussions on how they instantiate the framework components, thus supporting the comparison of the methods. The four parts are due to the distinctive features of the methods they include. The first three are devoted to querying event logs generated by IT-systems that support business processes at organizations, querying process designs captured in process models, and methods that address querying both event logs and process models. The methods in these three parts usually define a language for specifying process queries. The fourth part discusses methods that operate over inputs other than event logs and process models, e.g., streams of process events, or do not develop dedicated languages for specifying queries, e.g., methods for assessing process model similarity. This book is mainly intended for researchers. All the chapters in this book are contributed by active researchers in the research disciplines of business process management, process mining, and process querying. They describe state-of-the-art methods for process querying, discuss use cases of process querying, and suggest directions for future work for advancing the field. Yet, also other groups like business or data scientists and other professionals, lecturers, graduate students, and tool vendors will find relevant information for their distinctive needs. Chapter "Celonis PQL: A Query Language for Process Mining" is available open access under a Creative Commons Attribution 4.0 International License via link.springer.com.
(source: Nielsen Book Data)

• 1. SQL Query Performance Tuning
• 2. Memory Performance Analysis
• 3. Disk Performance Analysis
• 4. CPU Performance Analysis
• 5. Creating a Baseline
• 6. SQL Query Performance
• 7. SQL Query Performance
• 8. Index Architecture and Behavior
• 9. Index Analysis
• 10. Database Engine Tuning Advisor
• 11. Key Lookups and Solutions
• 12. Statistics, Data Distribution, and Cardinality
• 13. Index Fragmentation
• 14. Execution Plan Generation
• 15. Execution Plan Cache Behavior
• 16. Parameter Sniffing
• 17. Query Recompilation
• 18. Query Design Analysis
• 19. Reduce Query Resource Use
• 20. Blocking and Blocked Processes
• 21. Causes and Solutions for Deadlocks
• 22. Row-By-Row Processing
• 23. Memory-Optimized OLTP Tables and Procedures
• 24. Database Performance Testing
• 25. Database Workload Optimization
• 26. SQL Server Optimization Checklist.
• (source: Nielsen Book Data)

Queries not running fast enough? Wondering about the in-memory database features in 2014? Tired of phone calls from frustrated users? Grant Fritchey's book SQL Server Query Performance Tuning is the answer to your SQL Server query performance problems. The book is revised to cover the very latest in performance optimization features and techniques, especially including the newly-added, in-memory database features formerly known under the code name Project Hekaton. This book provides the tools you need to approach your queries with performance in mind. SQL Server Query Performance Tuning leads you through understanding the causes of poor performance, how to identify them, and how to fix them. You'll learn to be proactive in establishing performance baselines using tools like Performance Monitor and Extended Events. You'll learn to recognize bottlenecks and defuse them before the phone rings. You'll learn some quick solutions too, but emphasis is on designing for performance and getting it right, and upon heading off trouble before it occurs. Delight your users. Silence that ringing phone. Put the principles and lessons from SQL Server Query Performance Tuning into practice today. Covers the in-memory features from Project Hekaton Helps establish performance baselines and monitor against them Guides in troubleshooting and eliminating of bottlenecks that frustrate users.
(source: Nielsen Book Data)

The IBM® DB2® Analytics Accelerator for IBM z/OS® is a high-performance appliance that integrates the IBM zEnterprise® infrastructure with IBM PureData"!for Analytics, powered by IBM Netezza® technology. With this integration, you can accelerate data-intensive and complex queries in a DB2 for z/OS highly secure and available environment. DB2 and the Analytics Accelerator appliance form a self-managing hybrid environment running online transaction processing and online transactional analytical processing concurrently and efficiently. These online transactions run together with business intelligence and online analytic processing workloads. DB2 Analytics Accelerator V4.1 expands the value of high-performance analytics. DB2 Analytics Accelerator V4.1 opens to static Structured Query Language (SQL) applications and row set processing, minimizes data movement, reduces latency, and improves availability. This IBM Redbooks® publication provides technical decision-makers with an understanding of the benefits of version 4.1 of the Analytics Accelerator with DB2 11 for z/OS. It describes the installation of the new functions, and the advantages to existing analytical processes as measured in our test environment. This book also introduces the DB2 Analytics Accelerator Loader V1.1, a tool that facilitates the data population of the DB2 Analytics Accelerator

• 1. Query Performance Tuning
• 2. Execution Plan Generation and the Query Optimizer
• 3. Methods for Capturing Query Performance Metrics
• 4. Analyzing Query Behavior Using Execution Plans
• 5. Statistics, Data Distribution and Cardinality
• 6. Using Query Store for Query Performance and Execution Plans
• 7. Execution Plan Cache Behavior
• 8. Query Recompilation
• 9. Index Architecture
• 10. Index Behaviors
• 11. Key Lookups and Solutions
• 12. Dealing with Index Fragmentation
• 13. Parameter Sensitive Queries: Causes and Solutions
• 14. Query Design Analysis
• 15. Reduce Query Resource Use
• 16. Blocking and Blocked Processes
• 17. Causes and Solutions for Deadlocks
• 18. Row-By-Row Processing from Cursors and Other Causes
• 19. Memory-Optimized OLTP Tables and Procedures
• 20. Graph Databases
• 21. Intelligent Query Processing
• 22. Automated Tuning in Azure and SQL Server
• 23. A Query Tuning Methodology.
• (source: Nielsen Book Data)

Troubleshoot slow-performing queries and make them run faster. Database administrators and SQL developers are constantly under pressure to provide more speed. This new edition has been redesigned and rewritten from scratch based on the last 15 years of learning, knowledge, and experience accumulated by the author. The book Includes expanded information on using extended events, automatic execution plan correction, and other advanced features now available in SQL Server. These modern features are covered while still providing the necessary fundamentals to better understand how statistics and indexes affect query performance. The book gives you knowledge and tools to help you identify poorly performing queries and understand the possible causes of that poor performance. The book also provides mechanisms for resolving the issues identified, whether on-premises, in containers, or on cloud platform providers. You'll learn about key fundamentals, such as statistics, data distribution, cardinality, and parameter sniffing. You'll learn to analyze and design your indexes and your queries using best practices that ward off performance problems before they occur. You'll also learn to use important modern features, such as Query Store to manage and control execution plans, the automated performance tuning feature set, and memory-optimized OLTP tables and procedures. You will be able to troubleshoot in a systematic way. Query tuning doesn't have to be difficult. This book helps you to make it much easier. What You Will Learn Use Query Store to understand and easily change query performance Recognize and eliminate bottlenecks leading to slow performance Tune queries whether on-premises, in containers, or on cloud platform providers Implement best practices in T-SQL to minimize performance risk Design in the performance that you need through careful query and index design Understand how built-in, automatic tuning can assist your performance enhancement efforts Protect query performance during upgrades to the newer versions of SQL Server Who This Book Is For Developers and database administrators with responsibility for query performance in SQL Server environments, and anyone responsible for writing or creating T-SQL queries and in need of insight into bottlenecks (including how to identify them, understand them, and eliminate them).
(source: Nielsen Book Data)

• Intro
• Title Page
• Abstract
• Contents
• Foundations
• Introduction
• Motivation
• Problem Statement
• Challenges
• Hypotheses
• Contributions
• Outline
• Preliminaries
• The Semantic Web, Linked Data, and Knowledge Graphs
• The Resource Description Framework
• The SPARQL Protocol and RDF Query Language
• Linked Data Fragments
• Foundations of Query Processing
• Sample-based Knowledge Graph Profiling
• Related Work: Knowledge Graph Profiling and Sampling
• Performance Profiling
• Statistical Profiling
• Sampling from Graphs

• Performance Profiling of Triple Pattern Fragments
• Introduction
• Motivating Example
• Triple Pattern Fragments Profiler
• Evaluation
• Conclusion
• Statistical Profiling for Federated Query Processing
• Introduction
• Problem Statement
• Characteristic Sets Profile Feature Estimation
• Estimation-based Federated Query Planning
• Evaluation
• Conclusion
• Decentralized Query Processing over Knowledge Graphs
• Related Work: Decentralized Query Processing
• Single Knowledge Graphs
• Multiple Knowledge Graphs
• Robust Query Processing in Relational Databases

• Robust Query Processing over Linked Data Fragments
• Introduction
• Motivating Example
• Robust Query Planning
• A New Class of Adaptive Join Operators
• Evaluation
• Conclusion
• Federated Query Processing over Heterogeneous Linked Data Fragments
• Introduction
• Motivating Example
• Federations of Linked Data Fragment Services
• Conceptual Framework
• Illustration of the Framework
• Evaluation
• Conclusion
• Conclusion
• Summary
• Outlook
• Bibliography
• Notation
• Acronyms
• Prefixes
• Additional Material
• Chapter 4
• Chapter 5
• Efficiency of CSPF Computation

• Preface Interactive Edition Introduction Basic Concepts Query Folding Query Planning Master Schema Management Appendix References Index Author Biography.
• (source: Nielsen Book Data)

Data integration is a critical problem in our increasingly interconnected but inevitably heterogeneous world. There are numerous data sources available in organizational databases and on public information systems like the World Wide Web. Not surprisingly, the sources often use different vocabularies and different data structures, being created, as they are, by different people, at different times, for different purposes. The goal of data integration is to provide programmatic and human users with integrated access to multiple, heterogeneous data sources, giving each user the illusion of a single, homogeneous database designed for his or her specific need. The good news is that, in many cases, the data integration process can be automated. This book is an introduction to the problem of data integration and a rigorous account of one of the leading approaches to solving this problem, viz., the relational logic approach. Relational logic provides a theoretical framework for discussing data integration. Moreover, in many important cases, it provides algorithms for solving the problem in a computationally practical way. In many respects, relational logic does for data integration what relational algebra did for database theory several decades ago. A companion web site provides interactive demonstrations of the algorithms.
(source: Nielsen Book Data)

• Introduction - The Robustness Problem of Information Retrieval Basic Concepts Query Performance Prediction Methods Pre-Retrieval Prediction Methods Post-Retrieval Prediction Methods Combining Predictors A General Model for Query Difficulty Applications of Query Difficulty Estimation Summary and Conclusions.
• (source: Nielsen Book Data)

Many information retrieval (IR) systems suffer from a radical variance in performance when responding to users' queries. Even for systems that succeed very well on average, the quality of results returned for some of the queries is poor. Thus, it is desirable that IR systems will be able to identify ""difficult"" queries so they can be handled properly. Understanding why some queries are inherently more difficult than others is essential for IR, and a good answer to this important question will help search engines to reduce the variance in performance, hence better servicing their customer needs. Estimating the query difficulty is an attempt to quantify the quality of search results retrieved for a query from a given collection of documents. This book discusses the reasons that cause search engines to fail for some of the queries, and then reviews recent approaches for estimating query difficulty in the IR field. It then describes a common methodology for evaluating the prediction quality of those estimators, and experiments with some of the predictors applied by various IR methods over several TREC benchmarks. Finally, it discusses potential applications that can utilize query difficulty estimators by handling each query individually and selectively, based upon its estimated difficulty.
(source: Nielsen Book Data)

"Data uncertainty widely exists in many applications, and an uncertain data stream is a series of uncertain tuples that arrive rapidly. However, traditional techniques for deterministic data streams cannot be applied to deal with data uncertainty directly due to the exponential growth of possible solution space. "This book provides a comprehensive overview of the authors' work on querying and mining uncertain data streams. Its contents include some important discoveries dealing with typical topics such as top-k query, ER-Topk query, rarity estimation, set similarity, and clustering. Querying and Mining Uncertain Data Streams is written for professionals, researchers, and graduate students in data mining and its various related fields. Contents: Introduction; Queries Over the Sliding-window Model ; Query Over the Landmark Model ; Rarity Estimation ; Set similarity; Clustering; Conclusion. Readership: Students and Professionals involved in data mining, big data, and data gathering. Key Features: The first book on uncertain data stream management. There exist significant contributions on typical topics."-- Provided by publisher.

• 1. Why Optimize
• ?2. Theory - Yes, We Need It
• !3. Even More Theory Algorithm
• s4. Understanding Execution Plan
• s5. Short Queries and Indexe
• s6. Long Queries and Full Scan
• s7. Long Queries: Additional Technique
• s8. Optimizing Data Modificatio
• n9. Design Matter
• s10. Application Development and Performanc
• e11. Function
• s12. Dynamic SQ
• L13. Avoiding the Pitfalls of Object-Relational Mappin
• g14. More Complex Filtering and Searc
• h15. Ultimate Optimization Algorithm
• 16. Conclusion.
• (source: Nielsen Book Data)

Write optimized queries. This book helps you write queries that perform fast and deliver results on time. You will learn that query optimization is not a dark art practiced by a small, secretive cabal of sorcerers. Any motivated professional can learn to write efficient queries from the get-go and capably optimize existing queries. You will learn to look at the process of writing a query from the database engine's point of view, and know how to think like the database optimizer. The book begins with a discussion of what a performant system is and progresses to measuring performance and setting performance goals. It introduces different classes of queries and optimization techniques suitable to each, such as the use of indexes and specific join algorithms. You will learn to read and understand query execution plans along with techniques for influencing those plans for better performance. The book also covers advanced topics such as the use of functions and procedures, dynamic SQL, and generated queries. All of these techniques are then used together to produce performant applications, avoiding the pitfalls of object-relational mappers. What You Will Learn Identify optimization goals in OLTP and OLAP systems Read and understand PostgreSQL execution plans Distinguish between short queries and long queries Choose the right optimization technique for each query type Identify indexes that will improve query performance Optimize full table scans Avoid the pitfalls of object-relational mapping systems Optimize the entire application rather than just database queries Who This Book Is For IT professionals working in PostgreSQL who want to develop performant and scalable applications, anyone whose job title contains the words "database developer" or "database administrator" or who is a backend developer charged with programming database calls, and system architects involved in the overall design of application systems running against a PostgreSQL database.
(source: Nielsen Book Data)

• Preface
• Live Soft-Matter Quantum Computing
• Studying Different Heuristic Searches to Solve a Real-World Frequency Assignment Problem
• Emergence & Advances of Quantum Search
• Efficient Implementations of Bi-Level Programming Methods for Continuous Network Design Problems
• A Hybrid Intelligent Technique Combines Neural Networks & Tabu Search Methods for Forecasting
• Lu Hancock: A Best First Search to Process Single-Destination Multiple-Origin Route Query in a Graph
• Some Heuristic Approaches for Solving Non-Convex Optimization Problems
• Evolutionary Algorithm Based on Concept of Stochastic Schemata Exploiter
• Index.
• (source: Nielsen Book Data)

In computer science, a search algorithm, is an algorithm for finding an item with specified properties among a collection of items. The items may be stored individually as records in a database; or may be elements of a search space defined by a mathematical formula or procedure, such as the roots of an equation with integer variables; or a combination of the two, such as the Hamiltonian circuits of a graph. This book presents research data in the study of computer search algorithms, including live soft-matter quantum computing; heuristic searches applied to the resolution of a relevant optimisation problem from the telecommunications domain; the emergence and advances of quantum search algorithms; an equilibrium network design problem for road traffic network; artificial neural networks; and evolutionary algorithms based on the concept of stochastic schemata exploiter.
(source: Nielsen Book Data)

• Part 1. An Introduction to Temporal Data Management
• Chapter 1. A Brief History of Temporal Data Management
• Chapter 2. A Taxonomy of Bi-Temporal Data Management Methods
• Part 2. An Introduction to Asserted Versioning
• Chapter 3. The Origins of Asserted Versioning: Computer Science Research
• Chapter 4. The Origins of Asserted Versioning: IT Best Practices
• Chapter 5. The Core Concepts of Asserted Versioning
• Chapter 6. Diagrams and Other Notations
• Chapter 7. The Basic Scenario
• Part 3. Designing, Maintaining and Querying Asserted Version Databases
• Chapter 8. Designing and Generating Asserted Versioning Databases
• Chapter 9. An Introduction to Temporal Transactions Chapter 10.Temporal Transactions on Single Tables
• Chapter 11. Temporal Transactions on Multiple Tables
• Chapter 12. Deferred Assertions and Other Pipeline Datasets
• Chapter 13. Re-Presenting Internalized Pipeline Datasets
• Chapter 14. Allen Relationship and Other Queries
• Chapter 15. Optimizing Asserted Versioning Databases
• Chapter 16. Conclusion Appendix: Bibliographical Essay.
• (source: Nielsen Book Data)

Managing Time in Relational Databases: How to Design, Update and Query Temporal Data introduces basic concepts that will enable businesses to develop their own framework for managing temporal data. It discusses the management of uni-temporal and bi-temporal data in relational databases, so that they can be seamlessly accessed together with current data; the encapsulation of temporal data structures and processes; ways to implement temporal data management as an enterprise solution; and the internalization of pipeline datasets. The book is organized into three parts. Part 1 traces the history of temporal data management and presents a taxonomy of bi-temporal data management methods. Part 2 provides an introduction to Asserted Versioning, covering the origins of Asserted Versioning; core concepts of Asserted Versioning; the schema common to all asserted version tables, as well as the various diagrams and notations used in the rest of the book; and how the basic scenario works when the target of that activity is an asserted version table. Part 3 deals with designing, maintaining, and querying asserted version databases. It discusses the design of Asserted Versioning databases; temporal transactions; deferred assertions and other pipeline datasets; Allen relationships; and optimizing Asserted Versioning databases.
(source: Nielsen Book Data)

• Preface to the First Edition Preface to the Second Edition Acknowledgments Queries and Views Query Containment and Equivalence Finding Equivalent Rewritings Maximally Contained Rewritings (MCRs) Answering Queries in Presence of Dependencies Answering Queries in Data Exchange Answering Queries Using Views XPath Queries and Views Tree-Structured Records Queried with SQL Dialect Bibliographical Notes for Chapters 1-7 Conclusion for Chapters 1-7 Bibliography Authors' Biographies.
• (source: Nielsen Book Data)

The topic of using views to answer queries has been popular for a few decades now, as it cuts across domains such as query optimization, information integration, data warehousing, website design and, recently, database-as-a-service and data placement in cloud systems. This book assembles foundational work on answering queries using views in a self-contained manner, with an effort to choose material that constitutes the backbone of the research. It presents efficient algorithms and covers the following problems: query containment; rewriting queries using views in various logical languages; equivalent rewritings and maximally contained rewritings; and computing certain answers in the data-integration and data-exchange settings. Query languages that are considered are fragments of SQL, in particular select-project-join queries, also called conjunctive queries (with or without arithmetic comparisons or negation), and aggregate SQL queries. This second edition includes two new chapters that refer to tree-like data and respective query languages. Chapter 8 presents the data model for XML documents and the XPath query language, and Chapter 9 provides a theoretical presentation of tree-like data model and query language where the tuples of a relation share a tree-structured schema for that relation and the query language is a dialect of SQL with evaluation techniques appropriately modified to fit the richer schema.
(source: Nielsen Book Data)

• Intro; Title Page; Acknowledgments; Contents; Abstract; Introduction; Federated SPARQL Query Processing; The Need for Efficient Source Selection; The Need for More Comprehensive SPARQL Benchmarks; Contributions; Chapter Overview; Basic Concepts and Notation; Semantic Web; URIs, RDF; SPARQL Query Language; Triplestore; SPARQL Syntax, Semantic and Notation; State of the Art; Federation systems evaluations; Benchmarks; Federated engines public survey; Survey Design; Discussion of the survey results; Details of selected systems; Overview of the selected approaches; Performance Variables.

• EvaluationExperimental setup; Evaluation criteria; Experimental results; Discussion; Effect of the source selection time; Effect of the data partitioning; Hypergraph-Based Source Selection; Problem Statement; HiBISCuS; Queries as Directed Labelled Hypergraphs; Data Summaries; Source Selection Algorithm; Pruning approach; Evaluation; Experimental Setup; Experimental Results; Trie-based Source Selection; TBSS; TBSS Data Summaries; TBSS Source Selection Algorithm; TBSS Pruning approach; QUETSAL; Quetsal's Architecture; Quetsal's SPARQL 1.1 Query Re-writing; Evaluation; Experimental Setup.

• Experimental ResultsDuplicate-Aware Source Selection; DAW; Min-Wise Independent Permutations (MIPs); DAW Index; DAW Federated Query Processing; Experimental Evaluation; Experimental Setup; Experimental Results; Policy-Aware Source Selection; Motivating Scenario; Methodology and Architecture; Evaluation; Experimental Setup; Experimental Results; Data Distribution-Based Source Selection; Motivation; Biological query example; Methods; Transforming TCGA data to RDF; Linking TCGA to the LOD cloud; TCGA data workflow and schema; Data distribution and load balancing.

• TopFed federated query processing approachSource selection; Results and discussion; Evaluation; Availability of supporting data; LargeRDFBench: SPARQL Federation Benchmark; Background; The Need of More Comprehensive SPARQL Federation Benchmark; Benchmark Description; Benchmark Datasets; Benchmark Queries; Performance Metrics; Evaluation; Experimental Setup; SPARQL 1.0 Experimental Results; SPARQL 1.1 Experimental Results; FEASIBLE: SPARQL Benchmarks Generation Framework; Key SPARQL Features; A Comparison of Existing Triple Stores Benchmarks and Query Logs; FEASIBLE Benchmark Generation.

• Data Set CleaningNormalization of Features Vectors; Query Selection; Complexity Analysis; Evaluation and Results; Composite Error Estimation; Experimental Setup; Experimental Results; Conclusion; HiBISCuS; TBSS/Quetsal; DAW; SAFE; TopFed; LargeRDFBench; FEASIBLE; Bibliography.

• Part I. Getting Starte
• d1. MySQL Performance Tunin
• g2. Query Tuning Methodolog
• y3. Benchmarking with Sysbenc
• h4. Test Data Part II. Sources of Informatio
• n5. The Performance Schem
• a6. The sys Schem
• a7. The Information Schem
• a8. SHOW Statement
• s9. The Slow Query Log Part III. Tool
• s10. MySQL Enterprise Monito
• r11. MySQL Workbenc
• h12. MySQL Shell Part IV. Schema Considerations and the Query Optimize
• r13. Data Type
• s14. Indexe
• s15. Index Statistic
• s16. Histogram
• s17. The Query Optimize
• r18. Locking Theory and Monitoring Part V. Query Analysi
• s19. Finding Candidate Queries for Optimizatio
• n20. Analyzing Querie
• s21. Transaction
• s22. Diagnosing Lock Contention Part VI. Improving the Querie
• s23. Configuratio
• n24. Change the Query Pla
• n25. DDL and Bulk Data Loa
• d26. Replicatio
• n27. Caching.
• (source: Nielsen Book Data)

Identify, analyze, and improve poorly performing queries that damage user experience and lead to lost revenue for your business. This book will help you make query tuning an integral part of your daily routine through a multi-step process that includes monitoring of execution times, identifying candidate queries for optimization, analyzing their current performance, and improving them to deliver results faster and with less overhead. Author Jesper Krogh systematically discusses each of these steps along with the data sources and the tools used to perform them. MySQL 8 Query Performance Tuning aims to help you improve query performance using a wide range of strategies. You will know how to analyze queries using both the traditional EXPLAIN command as well as the new EXPLAIN ANALYZE tool. You also will see how to use the Visual Explain feature to provide a visually-oriented view of an execution plan. Coverage of indexes includes indexing strategies and index statistics, and you will learn how histograms can be used to provide input on skewed data distributions that the optimizer can use to improve query performance. You will learn about locks, and how to investigate locking issues. And you will come away with an understanding of how the MySQL optimizer works, including the new hash join algorithm, and how to change the optimizer's behavior when needed to deliver faster execution times. You will gain the tools and skills needed to delight application users and to squeeze the most value from corporate computing resources. What You Will Learn Monitor query performance to identify poor performers Choose queries to optimize that will provide the greatest gain Analyze queries using tools such as EXPLAIN ANALYZE and Visual Explain Improve slow queries through a wide range of strategies Properly deploy indexes and histograms to aid in creating fast execution plans Understand and analyze locks to resolve contention and increase throughput Who This Book Is For Database administrators and SQL developers who are familiar with MySQL and need to participate in query tuning. While some experience with MySQL is required, no prior knowledge of query performance tuning is needed.
(source: Nielsen Book Data)

• Table of Contents; Preface; Audience; Contents of This Book; Conventions Used in This Book; Using Code Examples; Safari® Books Online; How to Contact Us; Acknowledgments;
• Chapter 1. Introducing the DbContext API; Getting the DbContext API into Your Project; Looking at Some Highlights of the DbContext API; Reducing and Simplifying Ways to Work with a Set; Retrieving an Entity Using ID with DbSet.Find; Avoiding Trolling Around the Guts of Entity Framework; Working with the BreakAway Model; Getting the Sample Solution; Getting DbContext from an EDMX Model

• Ensuring DbContext Instances Get Disposed
• Chapter 2. Querying with DbContext; Writing Queries with LINQ to Entities; Querying All the Data from a Set; Using LINQ for Sorting, Filtering, and More; Finding a Single Object; Querying Local Data; Using the Load Method to Bring Data into Memory; Running LINQ Queries Against Local; Working with the ObservableCollection Returned by Local; Loading Related Data; Lazy Loading; Understanding the downsides of lazy loading; Eager Loading; Understanding the downsides of eager loading; Using Include in LINQ queries; Explicit Loading

• Checking If a Navigation Property Has Been LoadedQuerying Contents of a Collection Navigation Property; Explicit Loading a Subset of the Contents of a Navigation Property;
• Chapter 3. Adding, Changing, and Deleting Entities; Working with Single Entities; Adding New Entities; Changing Existing Entities; Deleting Existing Entities; Deleting without loading from the database; Deleting an object with related data; Multiple Changes at Once; The "Find or Add" Pattern; Working with Relationships; Adding a Relationship Between Objects; Changing a Relationship Between Objects

• Removing a Relationship Between ObjectsWorking with Change Tracking; Using Snapshot Change Tracking; Understanding When Automatic Change Detection Occurs; Controlling When DetectChanges Is Called; Using DetectChanges to Trigger Relationship Fix-up; Enabling and Working with Change Tracking Proxies; Ensuring the New Instances Get Proxies; Creating Proxy Instances for Derived Types; Fetching Entities Without Change Tracking;
• Chapter 4. Working with Disconnected Entities Including N-Tier Applications; A Simple Operation on a Disconnected Graph; Exploring the Challenges of N-Tier

• Using Existing N-Tier Frameworks That Support Graph ModificationUsing Explicit Operations on the Server Side; Replaying Changes on the Server; Understanding How DbContext Responds to Setting the State of a Single Entity; Marking a New Entity as Added; Marking an Existing Entity as Unchanged; Marking an Existing Entity as Modified; Registering an Existing Entity for Deletion; Using a stub entity to mark for deletion; Working with Relationships with and Without Foreign Keys; Benefiting from foreign key properties; Using navigation properties to define relationships

In addition to Code First, EF 4.1 introduces simpler EF coding patterns with the DbContext, DbSet, ChangeTracker and Validation APIs. This second mini-book will take the reader on a tour of these new features and how to take advantage of them. These new classes and APIs let the user focus on the most common coding tasks with Entity Framework and streamlines access to patterns which are frequently used, but were previously non-intuitive and complicated to code. With the new features in hand, the reader will then see how to leverage EF 4.1 in a variety of applications - client applications, web applications, services - and architectures from drag & drop to enterprise apps with repositories, Unit of Work and automated testing.
(source: Nielsen Book Data)