OQL is a SQL-like language for querying objects and data in Geode. It allows querying on any object attributes and invoking methods. Indexes can significantly improve query performance and avoid scanning entire regions. Different types of indexes include functional, functional compact, key, hash, and map indexes. Partitioned and colocated regions can be queried using functions or equijoins with some restrictions. General tips include matching from clauses to indexes, ordering AND filters by selectivity, and using hints to prefer indexes.
This document discusses various techniques for optimizing Core Data performance and memory usage. It covers topics like thread safety in Core Data, multithreading strategies using notifications or parent-child managed object contexts, different fetch request options like batch size and result type, using expressions and grouping for fetching, prefetching relationships, optimizing predicates by using numerical comparisons first and beginswith/endswith, and printing SQL logs for debugging.
JDBC is used to connect Java applications to databases. It uses drivers specific to each database type. The key steps are: 1) loading the driver, 2) defining the connection URL, 3) establishing a connection, 4) creating statements to execute queries or updates, 5) processing result sets, and 6) closing connections. Prepared statements are useful for queries executed multiple times to avoid recompilation. Transactions allow grouping statements that must all succeed or fail together to maintain database consistency.
Spring Data is a high level SpringSource project whose purpose is to unify and ease the access to different kinds of persistence stores, both relational database systems and NoSQL data stores.
The document describes developing an advanced Enterprise Java Bean that allows a user to enter registration details in a Registration.jsp form. The data entered by the user is then stored in a database.
Registration.jsp collects the user input fields like username, password, first name, last name and email from the request parameters. JDBC is used to connect to a MySQL database and a prepared statement is executed to insert the user details into a database table. On successful insertion, a message is displayed confirming successful registration.
Performance improvement strategies in Redux. Use memoized selectors to avoid redundant derivations in your mapStateToProps. Divide and flatten your reducers to prevent unnecessary re-renders of components.
This document discusses filtering data in Direct to Web (D2W) by limiting the visibility of data based on the current user or company. It presents two solutions:
1. Modifying fetch specifications at the editing context level to add relationship qualifiers restricting results to the current company. This works but is low-level.
2. Using query and relationship components in D2W that call business logic to generate the appropriate qualifiers and restricted data sources. This provides a cleaner, more reusable approach compared to the first solution.
The document also discusses enhancing relationship components to support restricting fetch specifications to simplify generating qualifiers across different entities and relationships. In summary, it focuses on programmatically filtering data in D2
This document describes a Selenium WebDriver data driven framework. It uses external files to store test data and object identifiers to make the framework more flexible and maintainable. The framework includes Java classes for reading test data from Excel files, retrieving object identifiers from property files, and implementing common test functions. Tests are implemented as Java classes that utilize the framework classes to login to a test application, retrieve test data, and verify application behavior.
This document discusses various techniques for optimizing Core Data performance and memory usage. It covers topics like thread safety in Core Data, multithreading strategies using notifications or parent-child managed object contexts, different fetch request options like batch size and result type, using expressions and grouping for fetching, prefetching relationships, optimizing predicates by using numerical comparisons first and beginswith/endswith, and printing SQL logs for debugging.
JDBC is used to connect Java applications to databases. It uses drivers specific to each database type. The key steps are: 1) loading the driver, 2) defining the connection URL, 3) establishing a connection, 4) creating statements to execute queries or updates, 5) processing result sets, and 6) closing connections. Prepared statements are useful for queries executed multiple times to avoid recompilation. Transactions allow grouping statements that must all succeed or fail together to maintain database consistency.
Spring Data is a high level SpringSource project whose purpose is to unify and ease the access to different kinds of persistence stores, both relational database systems and NoSQL data stores.
The document describes developing an advanced Enterprise Java Bean that allows a user to enter registration details in a Registration.jsp form. The data entered by the user is then stored in a database.
Registration.jsp collects the user input fields like username, password, first name, last name and email from the request parameters. JDBC is used to connect to a MySQL database and a prepared statement is executed to insert the user details into a database table. On successful insertion, a message is displayed confirming successful registration.
Performance improvement strategies in Redux. Use memoized selectors to avoid redundant derivations in your mapStateToProps. Divide and flatten your reducers to prevent unnecessary re-renders of components.
This document discusses filtering data in Direct to Web (D2W) by limiting the visibility of data based on the current user or company. It presents two solutions:
1. Modifying fetch specifications at the editing context level to add relationship qualifiers restricting results to the current company. This works but is low-level.
2. Using query and relationship components in D2W that call business logic to generate the appropriate qualifiers and restricted data sources. This provides a cleaner, more reusable approach compared to the first solution.
The document also discusses enhancing relationship components to support restricting fetch specifications to simplify generating qualifiers across different entities and relationships. In summary, it focuses on programmatically filtering data in D2
This document describes a Selenium WebDriver data driven framework. It uses external files to store test data and object identifiers to make the framework more flexible and maintainable. The framework includes Java classes for reading test data from Excel files, retrieving object identifiers from property files, and implementing common test functions. Tests are implemented as Java classes that utilize the framework classes to login to a test application, retrieve test data, and verify application behavior.
This document discusses using JSP and SQL to build a web application. It covers using servlets and JavaBeans to handle requests and responses. It also discusses using DAO objects to access a database, and using SQL commands like INSERT to add records to tables. Specific steps shown include creating a database table in Navicat, building JavaBeans with getters and setters, creating a DAO class to insert data, and using servlets to pass objects between the JSP page and DAO class.
This document describes KAAccessControl, a framework for managing user access control and permissions. It provides concise summaries in 3 sentences or less that provide the high level and essential information from the document.
The framework allows defining roles, profiles, lists and managing user permissions through annotations and configuration files. It handles authentication but does not provide the authentication mechanism. The framework manages the current user's profile and permissions and allows impersonating other users through its user service class. Components check permissions by annotating allowed roles and querying the framework's access control services.
The document outlines the content of a Java threading module which includes processes, threads, creating threads using the Thread class and Runnable interface, thread priority, and network server thread programming. It provides code examples of defining and starting threads using both Thread and Runnable, setting thread priority, and creating a multi-threaded network server using threads to handle client connections and requests.
Hibernate provides object relational mapping and allows working with data at the object level rather than directly with SQL. It abstracts the underlying database, handles change detection and caching. The session factory handles connection pooling and caching of mappings. The session represents a unit of work and tracks changes to objects, flushing updates to the database at the end of the session. The first level cache tracks changes to objects within a session. Query caching caches query results to improve performance. The second level cache caches objects beyond a single session.
New methods for exploiting ORM injections in Java applicationsMikhail Egorov
This document summarizes new methods for exploiting ORM injections in Java applications. It begins with introductions to ORM, JPA, and common ORM libraries. It then outlines several exploitation techniques, including using special functions in EclipseLink and TopLink to call database functions, abusing string handling and quote processing in OpenJPA, and leveraging features in Hibernate and specific databases like string escaping, quoted strings, magic functions, and Unicode delimiters. Code examples and demonstrations are provided for most of the techniques.
This document discusses using JavaServer Pages (JSP) and Structured Query Language (SQL) to build a web application that interacts with a database. It describes using JSP to generate HTML and JavaBeans to hold data, DAO objects to access the database, and SQL commands like INSERT to add records to database tables. It provides steps for creating a database table using Navicat and generating JavaBeans and DAO classes to insert member data into the database table from a JSP servlet.
The document discusses using Hibernate, an object-relational mapping framework, to provide object persistence and retrieval by mapping Java objects to database tables. It explains what Hibernate does, its features like object-relational mapping and transaction management, and provides examples of persisting and retrieving objects using Hibernate's API. The document also shows how to configure a Hibernate project and map classes and associations between objects and database tables.
The document discusses basic JDBC programming concepts including connecting to a database, executing SQL statements using Statement, PreparedStatement, and ResultSet objects, and mapping between Java and SQL data types. Key methods for connecting to a database, executing queries and updates, retrieving results, and setting parameters in PreparedStatements are described.
The document discusses reactive application patterns and principles. It describes how Akka actors can be used to build message-driven, resilient, elastic, and responsive applications. It provides an example of using Play, Akka Cluster Sharding to build a reactive user management system that is horizontally scalable and always available.
JDBC is an API that allows Java programs to connect to databases. It provides methods for establishing a connection, executing SQL statements, and retrieving results. The basic steps are to load a database driver, connect to the database, create statements to send queries and updates, get result sets, and close connections. JDBC supports accessing many types of data sources and provides metadata about the database schema.
The document provides information about JavaScript and the Document Object Model (DOM). It discusses how JavaScript can dynamically access and update HTML elements using the DOM. It explains that all HTML elements are defined as objects in the DOM that can be accessed and manipulated using JavaScript properties and methods. The document provides examples of how to select elements, modify attributes and styles, add and remove elements, and handle events. It also covers common JavaScript objects like Date, Math, and built-in constructors.
This document provides an overview of JSON (JavaScript Object Notation) including its syntax, values, objects, arrays, and uses for exchanging and storing data. JSON is a lightweight data format that is easy for humans to read and write and easy for machines to parse and generate. The document also discusses using JSON with XMLHttpRequest to make HTTP requests to a web server and retrieve JSON data to display on a web page without reloading.
The document contains details of 9 practical assignments for an Advance Java course. Each practical assignment involves developing a Java program or application to demonstrate a concept. For example, Practical 01 involves creating a program to select stationary products and display prices; Practical 02 creates an editable employee table; Practical 03 uses a split pane to display planet images; and so on. The final practical involves developing a room reservation system using Enterprise Java Beans.
Hibernate, created by Gavin King, known as the best and dominated object/relational persistence (ORM) tool for Java developers (Now is support .NET). It provides many elegant and innovative ways to simplifies the relational database handling task in Java.
Hibernate is great at a lot of things, but its something that needs to be used appropriately. In this tutorials, it providing many step by step examples and explanations on using Hibernate3
- Hibernate is an ORM tool that uses POJO objects and allows working with objects instead of directly with the database.
- It uses a SessionFactory to provide Sessions which represent a single unit of work and handles dirty checking. Mapping is defined in XML files.
- Hibernate supports complex queries using the Criteria interface to create restrictions and conditions equivalent to SQL queries.
As your data grows, the need to establish proper indexes becomes critical to performance. MongoDB supports a wide range of indexing options to enable fast querying of your data, but what are the right strategies for your application?
In this talk we’ll cover how indexing works, the various indexing options, and use cases where each can be useful. We'll dive into common pitfalls using real-world examples to ensure that you're ready for scale.
Introduction to Active Record - Silicon Valley Ruby Conference 2007Rabble .
Active Record is an object-relational mapping (ORM) pattern that allows developers to interact with a database using objects rather than SQL queries. It establishes a direct association between classes and database tables, and between class objects and table rows. The key characteristics of Active Record include directly mapping classes to tables, objects to rows, and using finders and setters to encapsulate data access. The Ruby on Rails framework includes an implementation of Active Record to provide data modeling and database access functions.
ORM2Pwn: Exploiting injections in Hibernate ORMMikhail Egorov
Mikhail Egorov and Sergey Soldatov presented their research on exploiting injections in Hibernate ORM. They demonstrated that while Hibernate Query Language (HQL) is more limited than SQL, it is possible to exploit HQL injections to conduct SQL injections on popular databases like MySQL, PostgreSQL, Oracle, and Microsoft SQL Server. They did this by leveraging features of Hibernate and the databases like how Hibernate handles string escaping and allows unicode characters in identifiers. Their talk provided examples of exploiting each database and a takeaway that Hibernate is not a web application firewall and HQL injections can be used to perform SQL injections.
This presentation was prepared for a Webcast where John Yerhot, Engine Yard US Support Lead, and Chris Kelly, Technical Evangelist at New Relic discussed how you can scale and improve the performance of your Ruby web apps. They shared detailed guidance on issues like:
Caching strategies
Slow database queries
Background processing
Profiling Ruby applications
Picking the right Ruby web server
Sharding data
Attendees will learn how to:
Gain visibility on site performance
Improve scalability and uptime
Find and fix key bottlenecks
See the on-demand replay:
http://pages.engineyard.com/6TipsforImprovingRubyApplicationPerformance.html
MongoDB.local DC 2018: Tips and Tricks for Avoiding Common Query PitfallsMongoDB
Query performance can either be a constant headache or the unsung hero of an application. MongoDB provides extremely powerful querying capabilities when used properly. As a member of the solutions architecture team, I will share common mistakes observed as well as tips and tricks to avoiding them.
This document discusses Elasticsearch and provides examples of its real-world uses and basic functionality. It contains:
1) An overview of Elasticsearch and how it can be used for full-text search, analytics, and structured querying of large datasets. Dell and The Guardian are discussed as real-world use cases.
2) Explanations of basic Elasticsearch concepts like indexes, types, mappings, and inverted indexes. Examples of indexing, updating, and deleting documents.
3) Details on searching and filtering documents through queries, filters, aggregations, and aliases. Query DSL and examples of common queries like term, match, range are provided.
4) A discussion of potential data modeling designs for indexing user
This document discusses using JSP and SQL to build a web application. It covers using servlets and JavaBeans to handle requests and responses. It also discusses using DAO objects to access a database, and using SQL commands like INSERT to add records to tables. Specific steps shown include creating a database table in Navicat, building JavaBeans with getters and setters, creating a DAO class to insert data, and using servlets to pass objects between the JSP page and DAO class.
This document describes KAAccessControl, a framework for managing user access control and permissions. It provides concise summaries in 3 sentences or less that provide the high level and essential information from the document.
The framework allows defining roles, profiles, lists and managing user permissions through annotations and configuration files. It handles authentication but does not provide the authentication mechanism. The framework manages the current user's profile and permissions and allows impersonating other users through its user service class. Components check permissions by annotating allowed roles and querying the framework's access control services.
The document outlines the content of a Java threading module which includes processes, threads, creating threads using the Thread class and Runnable interface, thread priority, and network server thread programming. It provides code examples of defining and starting threads using both Thread and Runnable, setting thread priority, and creating a multi-threaded network server using threads to handle client connections and requests.
Hibernate provides object relational mapping and allows working with data at the object level rather than directly with SQL. It abstracts the underlying database, handles change detection and caching. The session factory handles connection pooling and caching of mappings. The session represents a unit of work and tracks changes to objects, flushing updates to the database at the end of the session. The first level cache tracks changes to objects within a session. Query caching caches query results to improve performance. The second level cache caches objects beyond a single session.
New methods for exploiting ORM injections in Java applicationsMikhail Egorov
This document summarizes new methods for exploiting ORM injections in Java applications. It begins with introductions to ORM, JPA, and common ORM libraries. It then outlines several exploitation techniques, including using special functions in EclipseLink and TopLink to call database functions, abusing string handling and quote processing in OpenJPA, and leveraging features in Hibernate and specific databases like string escaping, quoted strings, magic functions, and Unicode delimiters. Code examples and demonstrations are provided for most of the techniques.
This document discusses using JavaServer Pages (JSP) and Structured Query Language (SQL) to build a web application that interacts with a database. It describes using JSP to generate HTML and JavaBeans to hold data, DAO objects to access the database, and SQL commands like INSERT to add records to database tables. It provides steps for creating a database table using Navicat and generating JavaBeans and DAO classes to insert member data into the database table from a JSP servlet.
The document discusses using Hibernate, an object-relational mapping framework, to provide object persistence and retrieval by mapping Java objects to database tables. It explains what Hibernate does, its features like object-relational mapping and transaction management, and provides examples of persisting and retrieving objects using Hibernate's API. The document also shows how to configure a Hibernate project and map classes and associations between objects and database tables.
The document discusses basic JDBC programming concepts including connecting to a database, executing SQL statements using Statement, PreparedStatement, and ResultSet objects, and mapping between Java and SQL data types. Key methods for connecting to a database, executing queries and updates, retrieving results, and setting parameters in PreparedStatements are described.
The document discusses reactive application patterns and principles. It describes how Akka actors can be used to build message-driven, resilient, elastic, and responsive applications. It provides an example of using Play, Akka Cluster Sharding to build a reactive user management system that is horizontally scalable and always available.
JDBC is an API that allows Java programs to connect to databases. It provides methods for establishing a connection, executing SQL statements, and retrieving results. The basic steps are to load a database driver, connect to the database, create statements to send queries and updates, get result sets, and close connections. JDBC supports accessing many types of data sources and provides metadata about the database schema.
The document provides information about JavaScript and the Document Object Model (DOM). It discusses how JavaScript can dynamically access and update HTML elements using the DOM. It explains that all HTML elements are defined as objects in the DOM that can be accessed and manipulated using JavaScript properties and methods. The document provides examples of how to select elements, modify attributes and styles, add and remove elements, and handle events. It also covers common JavaScript objects like Date, Math, and built-in constructors.
This document provides an overview of JSON (JavaScript Object Notation) including its syntax, values, objects, arrays, and uses for exchanging and storing data. JSON is a lightweight data format that is easy for humans to read and write and easy for machines to parse and generate. The document also discusses using JSON with XMLHttpRequest to make HTTP requests to a web server and retrieve JSON data to display on a web page without reloading.
The document contains details of 9 practical assignments for an Advance Java course. Each practical assignment involves developing a Java program or application to demonstrate a concept. For example, Practical 01 involves creating a program to select stationary products and display prices; Practical 02 creates an editable employee table; Practical 03 uses a split pane to display planet images; and so on. The final practical involves developing a room reservation system using Enterprise Java Beans.
Hibernate, created by Gavin King, known as the best and dominated object/relational persistence (ORM) tool for Java developers (Now is support .NET). It provides many elegant and innovative ways to simplifies the relational database handling task in Java.
Hibernate is great at a lot of things, but its something that needs to be used appropriately. In this tutorials, it providing many step by step examples and explanations on using Hibernate3
- Hibernate is an ORM tool that uses POJO objects and allows working with objects instead of directly with the database.
- It uses a SessionFactory to provide Sessions which represent a single unit of work and handles dirty checking. Mapping is defined in XML files.
- Hibernate supports complex queries using the Criteria interface to create restrictions and conditions equivalent to SQL queries.
As your data grows, the need to establish proper indexes becomes critical to performance. MongoDB supports a wide range of indexing options to enable fast querying of your data, but what are the right strategies for your application?
In this talk we’ll cover how indexing works, the various indexing options, and use cases where each can be useful. We'll dive into common pitfalls using real-world examples to ensure that you're ready for scale.
Introduction to Active Record - Silicon Valley Ruby Conference 2007Rabble .
Active Record is an object-relational mapping (ORM) pattern that allows developers to interact with a database using objects rather than SQL queries. It establishes a direct association between classes and database tables, and between class objects and table rows. The key characteristics of Active Record include directly mapping classes to tables, objects to rows, and using finders and setters to encapsulate data access. The Ruby on Rails framework includes an implementation of Active Record to provide data modeling and database access functions.
ORM2Pwn: Exploiting injections in Hibernate ORMMikhail Egorov
Mikhail Egorov and Sergey Soldatov presented their research on exploiting injections in Hibernate ORM. They demonstrated that while Hibernate Query Language (HQL) is more limited than SQL, it is possible to exploit HQL injections to conduct SQL injections on popular databases like MySQL, PostgreSQL, Oracle, and Microsoft SQL Server. They did this by leveraging features of Hibernate and the databases like how Hibernate handles string escaping and allows unicode characters in identifiers. Their talk provided examples of exploiting each database and a takeaway that Hibernate is not a web application firewall and HQL injections can be used to perform SQL injections.
This presentation was prepared for a Webcast where John Yerhot, Engine Yard US Support Lead, and Chris Kelly, Technical Evangelist at New Relic discussed how you can scale and improve the performance of your Ruby web apps. They shared detailed guidance on issues like:
Caching strategies
Slow database queries
Background processing
Profiling Ruby applications
Picking the right Ruby web server
Sharding data
Attendees will learn how to:
Gain visibility on site performance
Improve scalability and uptime
Find and fix key bottlenecks
See the on-demand replay:
http://pages.engineyard.com/6TipsforImprovingRubyApplicationPerformance.html
MongoDB.local DC 2018: Tips and Tricks for Avoiding Common Query PitfallsMongoDB
Query performance can either be a constant headache or the unsung hero of an application. MongoDB provides extremely powerful querying capabilities when used properly. As a member of the solutions architecture team, I will share common mistakes observed as well as tips and tricks to avoiding them.
This document discusses Elasticsearch and provides examples of its real-world uses and basic functionality. It contains:
1) An overview of Elasticsearch and how it can be used for full-text search, analytics, and structured querying of large datasets. Dell and The Guardian are discussed as real-world use cases.
2) Explanations of basic Elasticsearch concepts like indexes, types, mappings, and inverted indexes. Examples of indexing, updating, and deleting documents.
3) Details on searching and filtering documents through queries, filters, aggregations, and aliases. Query DSL and examples of common queries like term, match, range are provided.
4) A discussion of potential data modeling designs for indexing user
Performance Test Driven Development with Oracle Coherencearagozin
This presentation discusses test driven development with Oracle Coherence. It outlines the philosophy of PTDD and challenges of testing Coherence, including the need for a cluster and sensitivity to network issues. It discusses automating tests using tools like NanoCloud for managing nodes and executing tests remotely. Different types of tests are described like microbenchmarks, performance regression tests, and bottleneck analysis. Common pitfalls of performance testing like fixed users vs fixed request rates are also covered.
Hibernate Performance Tuning, presented on JEEConf 2012, Kiev, Ukraine.
Also see: http://branchandbound.net/blog/conferences/2012/05/jeeconf-tripreport/
Adaptation of presentation at http://www.slideshare.net/SanderMak/hibernate-performance-tuning
This document provides information about an upcoming backend development bootcamp organized by Google Developer Student Clubs (GDSC). It outlines the topics that will be covered, including JavaScript, Node.js, Express, MongoDB, and building a hands-on idea box project. It also shares details about past GDSC events like Android Study Jams where students submitted apps and winners were selected. Presenters are introduced who will teach various sessions over the course of the bootcamp, providing overviews of the topics they will cover like intro to JavaScript, servers, REST APIs, and using databases.
This is a presentation that was presented at Tech Next meetup group (http://www.meetup.com/TechNext/events/168164922/), to introduce the audience to AngularJs (http://angularjs.org/).
It covers major ideas that AngularJS thrives on - data-binding, directives, services, dependency-injections, form validations, overall application architecture, Angular's view of MVC etc.
The content was prepared with the recent experience I gained which working for a short stint on a project earlier and is as per best of my knowledge.
The presentation describes what is Apache Solr, how it could be used. There is apache solr overview, performance tuning tips and advanced features description
This document provides an overview of Module 5: Optimize query performance in Azure SQL. The module contains 3 lessons that cover analyzing query plans, evaluating potential improvements, and reviewing table and index design. Lesson 1 explores generating and comparing execution plans, understanding how plans are generated, and the benefits of the Query Store. Lesson 2 examines database normalization, data types, index types, and denormalization. Lesson 3 describes wait statistics, tuning indexes, and using query hints. The lessons aim to help administrators optimize query performance in Azure SQL.
[2015/2016] Local data storage for web-based mobile appsIvano Malavolta
This presentation has been developed in the context of the Mobile Applications Development course, DISIM, University of L'Aquila (Italy), Spring 2016.
http://www.ivanomalavolta.com
This document provides an overview of advanced Apex features for querying and manipulating data in Salesforce including: aggregate SOQL functions like COUNT and SUM; SOQL joins, semi-joins, and anti-joins; SOSL for text searching; transaction processing with savepoints and record locking; and database DML methods for partial success of batch updates. It includes examples of using these features in Apex code to retrieve and update Salesforce data.
Mondrian MDX requests can be slow in production environments for several reasons: large schemas with many dimensions and measures can cause performance issues; querying large datasets from the database can also impact performance. To address these issues, the document discusses profiling Mondrian requests, optimizing the JVM and database, using caching, and tuning the Mondrian schema. A Mondrian schema pool is also described that reuses schema objects and periodically flushes unused schemas to free memory.
Data access patterns and technologies are discussed. The Data Access Object (DAO) pattern separates data access from business logic. Spring JDBC and myBatis provide APIs for SQL queries and object mapping. Object-relational mapping (ORM) tools like Hibernate reduce code by mapping objects to relational databases but can reduce performance. JDBC template provides basic data access while frameworks offer additional features.
This document discusses SQL skills and how queries can negatively impact server performance if not written efficiently. It covers topics like query plans, execution contexts, using parameters, indexing, handling large datasets, and external influences on SQL performance. Specific "bad" SQL examples are also provided and explained. The presenter's goal is to help developers optimize their SQL and prevent poorly written queries from bringing servers to their knees.
This document discusses SQL skills and how queries can negatively impact server performance if not written efficiently. It covers topics like query plans, execution contexts, using parameters, indexing, handling large datasets, and external influences on SQL performance. Specific "bad" SQL examples are also provided and analyzed. The presenter aims to help developers optimize their SQL and prevent poorly written queries from bringing servers to their knees.
Mastering Test Automation: How To Use Selenium SuccessfullySpringPeople
In this slide, identify what to test and choose the best language for automation. Learn to write maintainable and reusable Selenium tests and add UI layout test as part of automation using Galen framework. This slide will also guide you in reporting structure by using external plugin's, an illustration covering cross browser testing (Running selenium grid with Docker) and explain Code repository (Git) and Jenkins CI tool.
1. The document provides an introduction to the Node.js course, covering topics like JavaScript basics, Node.js fundamentals, Express.js, debugging, and more.
2. Key concepts discussed include how the Node.js runtime works, using core modules, asynchronous programming with callbacks and promises, and the module system.
3. Express.js is introduced as a popular web framework that handles requests and responses, routing, and other complex server tasks so developers can focus on business logic. Debugging tools are also covered.
Similar to OQL querying and indexes with Apache Geode (incubating) (20)
Using Query Store in Azure PostgreSQL to Understand Query PerformanceGrant Fritchey
Microsoft has added an excellent new extension in PostgreSQL on their Azure Platform. This session, presented at Posette 2024, covers what Query Store is and the types of information you can get out of it.
What to do when you have a perfect model for your software but you are constrained by an imperfect business model?
This talk explores the challenges of bringing modelling rigour to the business and strategy levels, and talking to your non-technical counterparts in the process.
WWDC 2024 Keynote Review: For CocoaCoders AustinPatrick Weigel
Overview of WWDC 2024 Keynote Address.
Covers: Apple Intelligence, iOS18, macOS Sequoia, iPadOS, watchOS, visionOS, and Apple TV+.
Understandable dialogue on Apple TV+
On-device app controlling AI.
Access to ChatGPT with a guest appearance by Chief Data Thief Sam Altman!
App Locking! iPhone Mirroring! And a Calculator!!
Consistent toolbox talks are critical for maintaining workplace safety, as they provide regular opportunities to address specific hazards and reinforce safe practices.
These brief, focused sessions ensure that safety is a continual conversation rather than a one-time event, which helps keep safety protocols fresh in employees' minds. Studies have shown that shorter, more frequent training sessions are more effective for retention and behavior change compared to longer, infrequent sessions.
Engaging workers regularly, toolbox talks promote a culture of safety, empower employees to voice concerns, and ultimately reduce the likelihood of accidents and injuries on site.
The traditional method of conducting safety talks with paper documents and lengthy meetings is not only time-consuming but also less effective. Manual tracking of attendance and compliance is prone to errors and inconsistencies, leading to gaps in safety communication and potential non-compliance with OSHA regulations. Switching to a digital solution like Safelyio offers significant advantages.
Safelyio automates the delivery and documentation of safety talks, ensuring consistency and accessibility. The microlearning approach breaks down complex safety protocols into manageable, bite-sized pieces, making it easier for employees to absorb and retain information.
This method minimizes disruptions to work schedules, eliminates the hassle of paperwork, and ensures that all safety communications are tracked and recorded accurately. Ultimately, using a digital platform like Safelyio enhances engagement, compliance, and overall safety performance on site. https://safelyio.com/
Orca: Nocode Graphical Editor for Container OrchestrationPedro J. Molina
Tool demo on CEDI/SISTEDES/JISBD2024 at A Coruña, Spain. 2024.06.18
"Orca: Nocode Graphical Editor for Container Orchestration"
by Pedro J. Molina PhD. from Metadev
DevOps Consulting Company | Hire DevOps Servicesseospiralmantra
Spiral Mantra excels in providing comprehensive DevOps services, including Azure and AWS DevOps solutions. As a top DevOps consulting company, we offer controlled services, cloud DevOps, and expert consulting nationwide, including Houston and New York. Our skilled DevOps engineers ensure seamless integration and optimized operations for your business. Choose Spiral Mantra for superior DevOps services.
https://www.spiralmantra.com/devops/
Liberarsi dai framework con i Web Component.pptxMassimo Artizzu
In Italian
Presentazione sulle feature e l'utilizzo dei Web Component nell sviluppo di pagine e applicazioni web. Racconto delle ragioni storiche dell'avvento dei Web Component. Evidenziazione dei vantaggi e delle sfide poste, indicazione delle best practices, con particolare accento sulla possibilità di usare web component per facilitare la migrazione delle proprie applicazioni verso nuovi stack tecnologici.
The Rising Future of CPaaS in the Middle East 2024Yara Milbes
Explore "The Rising Future of CPaaS in the Middle East in 2024" with this comprehensive PPT presentation. Discover how Communication Platforms as a Service (CPaaS) is transforming communication across various sectors in the Middle East.
🏎️Tech Transformation: DevOps Insights from the Experts 👩💻campbellclarkson
Connect with fellow Trailblazers, learn from industry experts Glenda Thomson (Salesforce, Principal Technical Architect) and Will Dinn (Judo Bank, Salesforce Development Lead), and discover how to harness DevOps tools with Salesforce.
Baha Majid WCA4Z IBM Z Customer Council Boston June 2024.pdfBaha Majid
IBM watsonx Code Assistant for Z, our latest Generative AI-assisted mainframe application modernization solution. Mainframe (IBM Z) application modernization is a topic that every mainframe client is addressing to various degrees today, driven largely from digital transformation. With generative AI comes the opportunity to reimagine the mainframe application modernization experience. Infusing generative AI will enable speed and trust, help de-risk, and lower total costs associated with heavy-lifting application modernization initiatives. This document provides an overview of the IBM watsonx Code Assistant for Z which uses the power of generative AI to make it easier for developers to selectively modernize COBOL business services while maintaining mainframe qualities of service.
Everything You Need to Know About X-Sign: The eSign Functionality of XfilesPr...XfilesPro
Wondering how X-Sign gained popularity in a quick time span? This eSign functionality of XfilesPro DocuPrime has many advancements to offer for Salesforce users. Explore them now!
8 Best Automated Android App Testing Tool and Framework in 2024.pdfkalichargn70th171
Regarding mobile operating systems, two major players dominate our thoughts: Android and iPhone. With Android leading the market, software development companies are focused on delivering apps compatible with this OS. Ensuring an app's functionality across various Android devices, OS versions, and hardware specifications is critical, making Android app testing essential.
Superpower Your Apache Kafka Applications Development with Complementary Open...Paul Brebner
Kafka Summit talk (Bangalore, India, May 2, 2024, https://events.bizzabo.com/573863/agenda/session/1300469 )
Many Apache Kafka use cases take advantage of Kafka’s ability to integrate multiple heterogeneous systems for stream processing and real-time machine learning scenarios. But Kafka also exists in a rich ecosystem of related but complementary stream processing technologies and tools, particularly from the open-source community. In this talk, we’ll take you on a tour of a selection of complementary tools that can make Kafka even more powerful. We’ll focus on tools for stream processing and querying, streaming machine learning, stream visibility and observation, stream meta-data, stream visualisation, stream development including testing and the use of Generative AI and LLMs, and stream performance and scalability. By the end you will have a good idea of the types of Kafka “superhero” tools that exist, which are my favourites (and what superpowers they have), and how they combine to save your Kafka applications development universe from swamploads of data stagnation monsters!
2. OQL
It is a SQL-like language with extended functionality for querying complex objects, object attributes and methods.
Only a subset of the OQL features are supported.
Advantages of OQL:
● You can query on any arbitrary object
● You can navigate object collections
● You can invoke methods and access the behavior of objects
● You are not required to declare types. Since you do not need type definitions, you can work across multiple
languages
● You are not constrained by a schema
3. Commonly used Keywords
SELECT * or field projection
FROM “select * from /users”
WHERE “select * from /users where id = 0”
AND “select * from /users where id > 0 and age > 21”
OR “select * from /users where id != 0 or age < 21”
AS “select * from /users as u where u.id <> 0” , “select * from /users u where u.id > 0”
COUNT “select count(*) from /users”
DISTINCT “select distinct(*) from /users”, “select distinct(name) from /users
IN “select * from /users u where u.id in set (0, 1, 2)”,
“select * from /users u where u.id in (select id from /employees e)”
LIMIT “select * from /users u limit 5”
LIKE “select * from /users u where u.name like ‘%a%’”
NOT “select * from /users u where u.name NOT (id = 2)”
ORDER BY “select * from /users u where u.name = ‘Joe’ order by u.id”
TO_DATE (parsed using SimpleDateFormat) to_date('05/09/10', 'yy/dd/yy') to_date('050910', 'yyddMM')
That’s not all! More keywords and information can be found in the Geode Documentation
4. Geode Specific Keywords
IS_DEFINED
● Query function. Returns TRUE if the expression does not evaluate to UNDEFINED.
IS_UNDEFINED
● Query function. Returns TRUE if the expression evaluates to UNDEFINED. In most queries, undefined values are
not included in the query results. The IS_UNDEFINED function allows undefined values to be included, so you can
identify element with undefined values.
5. Geode Specific Keywords Continued
<trace> “<trace> select * from /users u where u.id = 0”
Example log output:
No Indexes used:
● [info 2015/05/26 10:25:35.102 PDT Server <main> tid=0x1] Query Executed in 9.619656 ms; rowCount =
99; indexesUsed(0) "select * from /users u where id > 0 and status='active'"
One index used:
● [info 2015/05/26 10:25:35.317 PDT Server <main> tid=0x1] Query Executed in 1.5342 ms; rowCount =
199; indexesUsed(1):sampleIndex-1(Results: 199) "select count * from /users u where u.id > 0"
When more than one index is used:
● [info 2015/05/26 10:25:35.673 PDT Serve <main> tid=0x1] Query Executed in 2.43847 ms; rowCount =
199; indexesUsed(2):sampleIndex-2(Results: 100),sampleIndex-1(Results: 199) "select * from /users u
where u.id > 0 OR u.status='active'"
System.setProperty("gemfire.Query.VERBOSE","true");
<hint ‘indexName’> or <hint ‘indexName1’, ‘indexName2’>
Example:“<hint ‘nameIndex’>select * from /users u where u.name = ‘Joe’ and u.age > 10”
6. Query Bind Parameters
What
Similar to a SQL prepared statement
Parameters start with a ‘$’ and a number starting from 1
Examples:
String queryString = “SELECT DISTINCT * FROM /exampleRegion p WHERE p.status = $1 and p.symbol = $2”;
...
Object[] params = {“sold”, “abc”}
SelectResults results = (SelectResults)query.execute(params);
Possible Exceptions
QueryParameterCountInvalidException
TypeMismatchException
Bind region as a parameter
● Binding region parameter requires actual region object and not the string name
“SELECT DISTINCT * FROM $1 p WHERE p.status = $2”
7. Field visibility and Method Invocation
The query engine tries to evaluate the value using the public field value, if public field is not found makes a get call
using field name (having its first character uppercase).
Examples:
SELECT DISTINCT * FROM /users u where u.firstName = 'Joe'
SELECT DISTINCT * FROM /users u where u.getFirstName() = 'Joe'
SELECT DISTINCT * FROM /users u where u.combineFullName() = ‘Joe’s Full Name’
8. Type conversions
The Geode query engine will implicitly do the following conversions
Binary Numeric Promotion
The query processor performs binary numeric promotion on the operands of the following operators:
● Operators <, <=, >, and >=, = and <>
1. If either operand is of type double, the other is converted to double
2. If either operand is of type float, the other is converted to float
3. If either operand is of type long, the other is converted to long
4. Both operands are converted to type int char
Temporal Type Conversion
java.util.Date , java.sql.Date , java.sql.Time , and java.sql.Timestamp are treated as nanosecond comparisons
Enum Conversion are not done implicitly, a toString() call is needed
Query Evaluation of Float.NaN and Double.NaN
Float.NaN and Double.NaN are not evaluated as primitives; instead, they are compared in the same manner used as
the JDK methods Float.compareTo and Double.compareTo
9. Query a Partitioned Region
Operations summary:
1.) “Coordinating” node calculates where all data resides
2.) Creates and executes tasks to query data on remote nodes
a.) Each node will execute the query, using any indexes the node currently has
3.) Executes query on local node
4.) On failure, will recalculate where failed data now resides
5.) Executes tasks to query data on remote nodes that failed/where data now resides
6.) Combines data and returns
10. Query Monitor
Query Timeout -
Set the system property - gemfire.Cache.MAX_QUERY_EXECUTION_TIME (default is disabled and set to -1)
ResourceManager - Monitoring Queries for Low Memory
Helps prevent out of memory exceptions when querying or creating indexes.
This feature is automatically enabled when you set a critical-heap-percentage attribute for the resource-manager
element in cache.xml or by using cache.getResourceManager().setCriticalHeapPercentage(float heapPercentage) API.
If set, timeout is now set to 5 hours if one has not been set.
Queries will be cancelled with QueryExecutionLowMemoryExcepton and InvalidIndexException
Set the system property - gemfire.cache.DISABLE_QUERY_MONITOR_FOR_LOW_MEMORY to true to disable.
Partitioned Region Queries and Low Memory
Partitioned region queries are likely causes for out-of-memory exceptions. If query monitoring is enabled, partitioned
region queries drop or ignore results that are being gathered by other servers if the executing server is low in
memory.
11. Indexing
Why use an index?
● Significantly improve querying speeds.
● No longer iterate through the entire region when a matching index can be used
Additional Info:
● Indexed fields must implement Comparable
● Provide simple way to index on fields, nested object fields, nested collection of objects/fields and nested maps
Types:
● Functional Index
● Functional (Compact) Index
● Map index
● Hash Index
● Primary Key Index
12. Functional Index
A sorted index, internally represented as a tuple and copy of the value
How to create
qs.createIndex(“indexName”, “d.name”, “/users u, u.dependents d”); //(List or Set)
qs.createIndex(“indexName”, “d.name”, “/users u, u.dependents.values d”); //(Map)
Representation
Key Values
Sonny | Collection: [(User:Joe, Sonny)]
Cheryl | Collection: [(User:Joe, Cheryl), (User:John, Cheryl)]
Example query
“select * from /users u, u.dependents d where d.name = ‘Sonny’”
Restrictions:
Cannot be created on overflow regions
13. Functional Index (Compact)
Memory savings over the non compact index at the expense of doing extra work during index maintenance.
How to create
qs.createIndex(“user names”, “u.name”, “/users u”);
qs.createIndex(“user names”, “u.nestedObject.fieldName”, “/users u”);
Representation
Key Values
Joe | Region Entry
John | [Region Entry, Region Entry]
Jerry | Collection(Region Entry, Region Entry)
Restrictions:
Index maintenance is synchronous
Only when there is one iterator in the from clause (example: /users u)
Additional Info:
What about updates in progress?
What about “in place modification”
14. Key Index
Creating a key index makes the query service aware of the relationship between the values in the region and the keys
in the region.
This allows the query service to translate a query using a key into a get.
How to create:
qs.createKeyIndex(“indexName”, “u.id”, “/users u”);
Example Query:
“select * from /users u where u.id = 1”
Restrictions:
Equality comparisons only
15. Hash Index
The good
Saves on memory due to not storing index key values
Hash values are computed from index key
The bad
Slower maintenance and query times
Only a slight savings in memory
Name is a bit misleading
Representation
Array: [ RE, RE, null, RE, REMOVED, null, RE, ...]
How to create
qs.createHashIndex(“indexName”, “u.name”, “/users u”);
Restrictions:
Only equality based queries
Single iterator
16. Map Index
Allows indexing a map field of an object
How to create:
qs.createIndex("indexName", "u.name[*]", "/users u");
qs.createIndex("indexName", "u.name['first', 'middle']", "/users u");
In Gfsh:
gfsh>create index --name="IndexName" --expression="u.name[‘first’, 'middle']" --region="/users u"
Example of query:
“SELECT * FROM /users u WHERE u.name['first'] = 'John' OR u.name['last'] = 'Smith'”
Gotcha:
Using u.name.get(‘first’) will not create or query the map index.
17. Map Index...
‘first’
‘middle’
‘last’
Keys
Range Index
Key Value
Joe Collection: [(User: Joe Bob, Joe)]
John Collection:[(User:John Jacob Schmidt, John)]
Jerry Collection:[(User:Jerry Schmidt, Jerry)]
Range Index
Key Value
Jacob Collection:[User: John Jacob Schmidt, Jacob)]
Range Index
Key Value
Bob Collection: [(User: Joe Bob, Bob)]
Schmidt Collection:[(User:John Jacob Schmidt, Schmidt),
(User:Jerry Schmidt, Schmidt)]]
Values
18. Multiple Index Creation
Creating an multiple indexes on a populated region requires iterating that region for each index
This has significant impact when we have overflow regions
Same mechanism used when cache is brought up internally
Example of multiple index creation:
Cache cache = new CacheFactory().create();
QueryService queryService = cache.getQueryService();
queryService.defineIndex("name1", "indexExpr1", "regionPath1");
queryService.defineIndex("name2", "indexExpr2", "regionPath2");
queryService.defineHashIndex("name3", "indexExpr3", "regionPath2");
queryService.defineKeyIndex("name4", "indexExpr4", "regionPath2");
List<Index> indexes = queryService.createDefinedIndexes();
To clear any defined indexes that have not been created yet
queryService.clearDefinedIndexes();
19. Querying with Functions
Benefits:
● Allows targeting specific nodes by filtering by partitioning key
● Closer to data
● Logic and computation on results from node, possibly less to send back
Drawbacks:
● More work for users (writing the function)
● More work for users (registering the function)
20. Equijoin Queries
Restrictions:
● Must be colocated
Problems:
● Slow due to cartesian
● Memory usage due to temporary joined result sets
Some improvements are coming:
● Significantly reduce join time for single iterator filters where indexes can be used:
“select * from /users u, /employees e where u.name = ‘John’ and u.id = e.id”
“select * from /users u, /employees e where u.name = ‘John’ and u.age > 21 and u.id = e.id”
“select * from /users u, /employees e, /office o where u.name = ‘John’” and u.id = e.id and e.location = o.location”
21. General Tips/Tricks
● From clause of the query and index expression should match
● For AND operators, put the more selective filter first in the query
● Whenever possible, provide a hint to allow the query engine to prefer a specific index