Showing posts with label Oracle. Show all posts
Showing posts with label Oracle. Show all posts

Friday, 24 August 2012

Emerging DB Technology – Columnar Database


Today’s Top Data-Management Challenge:

Businesses today are challenged by the ongoing explosion of data. Gartner is predicting data growth will exceed 650% over the next five years. Organizations capture, track, analyze and store everything from mass quantities of transactional, online and mobile data, to growing amounts of machine-generated data. In fact, machine-generated data, including sources ranging from web, telecom network and call-detail records, to data from online gaming, social networks, sensors, computer logs, satellites, financial transaction feeds and more, represents the fastest-growing category of Big Data. High volume web sites can generate billions of data entries every month.

As volumes expand into the tens of terabytes and even the petabyte range, IT departments are being pushed by end users to provide enhanced analytics and reporting against these ever increasing volumes of data. Managers need to be able to quickly understand this information, but, all too often, extracting useful intelligence can be like finding the proverbial ‘needle in the haystack.

How do columnar databases work?

The defining concept of a column-store is that the values of a table are stored contiguously by column. Thus the classic supplier table from supplier and parts database would be stored on disk or in memory something like:  S1S2S3S4S52010302030LondonParis Paris LondonAthensSmithJonesBlakeClarkAdams



This is in contrast to a traditional row-store which would store the data more like this:
S120LondonSmithS210Paris JonesS330Paris BlakeS420LondonClarkS530AthensAdams
From this simple concept flows all of the fundamental differences in performance, for better or worse, between a column-store and a row-store. For example, a column-store will excel at doing aggregations like totals and averages, but inserting a single row can be expensive, while the inverse holds true for row-stores. This should be apparent from the above diagram.

The Ubiquity of Thinking in Rows:

Organizing data in rows has been the standard approach for so long that it can seem like the only way to do it. An address list, a customer roster, and inventory information—you can just envision the neat row of fields and data going from left to right on your screen.

Databases such as Oracle, MS SQL Server, DB2 and MySQL are the best known row-based databases.
Row-based databases are ubiquitous because so many of our most important business systems are transactional.
Data Set Ex:  See the below data set contents of 20 columns X 50 Millions of Rows.


Example Data Set
Row-oriented databases are well suited for transactional environments, such as a call center where a customer’s entire record is required when their profile is retrieved and/or when fields are frequently updated.

Other examples include:
• Mail merging and customized emails
• Inventory transactions
• Billing and invoicing

Where row-based databases run into trouble is when they are used to handle analytic loads against large volumes of data, especially when user queries are dynamic and ad hoc.

To see why, let’s look at a database of sales transactions with 50-days of data and 1 million rows per day. Each row has 30 columns of data. So, this database has 30 columns and 50 million rows. Say you want to see how many toasters were sold for the third week of this period. A row-based database would return 7-million rows (1 million for each day of the third week) with 30 columns for each row—or 210-million data elements. That’s a lot of data elements to crunch to find out how many toasters were sold that week. As the data set increases in size, disk I/O becomes a substantial limiting factor since a row-oriented design forces the database to retrieve all column data for any query.

As we mentioned above, many companies try to solve this I/O problem by creating indices to optimize queries. This may work for routine reports (i.e. you always want to know how many toasters you sold for the third week of a reporting period) but there is a point of diminishing returns as load speed degrades since indices need to be recreated as data is added. In addition, users are severely limited in their ability to quickly do ad-hoc queries (i.e. how many toasters did we sell through our first Groupon offer? Should we do it again?) that can’t depend on indices to optimize results.


Pivoting Your Perspective: Columnar Technology

Column-oriented databases allow data to be stored column-by-column rather than row-by-row. This simple pivot in perspective—looking down rather than looking across—has profound implications for analytic speed. Column-oriented databases are better suited for analytics where, unlike transactions, only portions of each record are required. By grouping the data together this way, the database only needs to retrieve columns that are relevant to the query, greatly reducing the overall I/O.

Returning to the example in the section above, we see that a columnar database would not only eliminate
43 days of data, it would also eliminate 28 columns of data. Returning only the columns for toasters and units sold, the columnar database would return only 14 million data elements or 93% less data. By returning so much less data, columnar databases are much faster than row-based databases when analyzing large data sets. In addition, some columnar databases (such as Infobright®) compress data at high rates because each column stores a single data type (as opposed to rows that typically contain several data types), and allow compression to be optimized for each particular data type. Row-based databases have multiple data types and limitless range of values, thus making compression less efficient overall.

Thanks For Reading This Blog. View More:: BI Analytics

Performance Center Best Practices


For Performance Testing we have started using HP Performance Center due to many advantages it provides to the testing team. We have listed out some of the best practices which can be followed when using Performance Center.

Architecture – Best Practices

  • Hardware Considerations
    • CPU, Memory, Disk sized to match the role and usage levels
    • Redundancy added for growth accommodation and fault-tolerance
    • Never install multiple critical components on the same hardware
  • Network Considerations
    • Localization of all PC server traffic - Web to Database, Web to File Server, Web to Utility Server, Web to Controllers, Controller to Database, Controller to File Server, Controller to Utility Server.
    • Separation of operational and virtual user traffic – PC operational traffic should not share same network resources as virtual user traffic – for optimal network performance.
  • Backup and Recovery Considerations
    • Take periodic backup Oracle Database and File System (\\<fileserver>\LRFS)
  • Backups of PC servers and hosts are optional.
  • Monitoring Considerations
    • Monitor services (eg. SiteScope) should be employed to manage availability and responsiveness of each PC component

Configuration – Best Practice

  • Set ASP upload buffer to the maximum size of a file that you will permit to be uploaded to the server.
    • Registry: HKLM\SYSTEM\CurrentControlSet\Services\w3svc\Parameters
  • Modify MaxClientRequestBuffer
    • create as a DWORD if it does not exist)
    • Ex. 2097152 is 2 Mb
  • Limit access to the PC File System (LRFS) for security
    • Performance Center User (IUSR_METRO) needs “Full Control”
  • We recommend 2 LoadTest Web Servers when
    • Running 3 or more concurrent runs
    • Having 10 plus users viewing tests
  • The load balancing needs an external, web session based, load balancer
  • In Internet Explorer, set “Check for newer versions of stored pages” to “Every visit to the page”
    • NOTE: This should be done on the client machines that are accessing the Performance Center web sites

Script Repository – Best Practice

  • Use VuGen integration for direct script upload
  • Ensure dependent files are within zip file
  • Re-configure script with optimal RTS
  • Validate script execution on PC load generators
  • Establish meaningful script naming convention
  • Clean-up script repository regularly

Monitor Profile – Best Practice

  • Avoid information overload
    • Min-Max principle – Minimum metrics for maximum detection
  • Consult performance experts and developers for relevant metrics
    • Standard Process Metrics (CPU, Available Memory, Disk Read/Write Bytes, Network Bandwidth Utilization)
    • Response Times / Durations (Avg. Execution Time)
    • Rates and Frequencies (Gets/sec, Hard Parses/sec)
    • Queue Lengths (Requests Pending)
    • Finite Resource Consumption (JVM Available Heap Size, JDBC Pool’s Active Connections)
    • Error Frequency (Errors During Script Runtime, Errors/sec)

Load Test – Best Practice

  • General
  • Create new load test for any major change in scheduling logic or script types
  • Use versioning (by naming convention) to track changes
  • Scripts
  • When scripts are updated with new run-logic settings, remove and reinsert updated script in load test
  • Scheduling
  • Each ramp-up makes queries to Licensing (Utility) Server, and LRFS file system.  Do not ramp at intervals less than 5 seconds.
  • Configure ramp-up quantity per interval to match available load generators
  • Do not run (many/any) users on Controller

Timeslots – Best Practice

  • Scheduling
    • Always schedule time slots in advance of load test
    • Always schedule extra time (10-30 minutes) for large or critical load tests
    • Allow for gaps between scheduled test runs (in case of emergencies)
  • Host Selection
    • Use automatic host selection whenever possible
    • Reserve manual hosts only when specific hosts are needed (because of runtime configuration requirements)
The above mentioned solutions will help you to make use of Performance Center without any issues and will also save you a lot of time by avoiding some issues which might arise because of not doing some of the above mentioned practices.

Thanks For Reading This Block. Want To Know More Visit At: Performance Center Best Practices

Thursday, 27 May 2010

Some myths and challenges faced by BPT Methodology

Is designing test for an entire business scenario a time-consuming process?
Business Process (BP) – a BP should be well-documented written at a level that can be script. The BP should be understandable by people not familiar with business. It should be sufficiently detailed. If possible we can have Mercury Screen Recordings (MSR), Navigational flow etc.

Data – The input data required for executing the BP should be reusable. If it is not reusable, sufficient set of data should provided for automating the BP. For most of the finance modules data are not reusable.

Business Process should be complete, correct and accurate. Verifying BP completeness and correctness takes a lot of time, better to start off with these steps in mind as verification time should be used to ensure the quality of the scripts instead of verifying the quality of the BP. Don’t assume anything, design the test cases so that any person can run it or execute it. Design the test cases so that any person can understand what steps are to be validated.

Generally speaking, the more user involvement a BP requires the less desirable it becomes for automation. Though scripts build during development process are executed successfully, they are liable to fail during regression execution. The common errors and solutions can be summarized as:

Wrong Data is being used: Most of the time the script fails due to a mismatch between the data displayed in application and the data stored in Data Table. The solution for this is to change the incorrect value in the Data Table.

Script Flow has changed due to a new build or a new data: if this is the case we need to modify the existing script to add/remove the necessary steps. This is not acceptable because we are automating scripts with the same process. This may represent delays in our delivery date.

The script is running with a different user: The solution is to use the same user that we were using during the development phase or give the new user the same privileges that the user utilized during development had.

Data is burned: If this is the case we need to get or create new data in order to execute the script.

Are your scripts backward compatible i.e., can they run in lower versions?
Scripts execution in lower version of QTP: The other major problem faced in scripts are not backward compatable.ie.., scripts build in upgraded version of quick test professional like 9.2,cannot be executed in 9.0 or lower versions. This problem can be overcome by using BCIE (Bushiness component Import and Export) tool. Using this tool we can import the reusable component from higher version of QC and export it to lower version of QC. Scripts are then compatible with lower versions.

Does Subject Matter Experts require technical knowledge?
Even though creating Business Processes Test Script using accelerators might seem like a simple task, there are multiple factors and caveats that need to be taken into account.
1.The initial Components base might prove complete for some BP’s, but there will surely be a need to create new components in order to complete all the scripts.
2.Though the UI Scanner automatically generates the required components, it might be required to manually modify the QTP code, or even to manually create a whole component.
3.VB Script knowledge is welcomed, since sometimes, there might even be the need to create new functions in the libraries, or modify the existing ones. It is always better to have a technical architect in a project dedicated to handle Libraries, tool installation, debug and trouble shooting. A technical architect should have considerable knowledge of library architecture and descriptive programming understanding, should understand relationship between Accelerators libraries and Business Process Testing. The responsibilities of the technical architect would be to provide the team with wrappers and

Are accelerators only for ERP applications?
Accelerator projects are not restricted to only ERP applications like SAP, PeopleSoft,Seibel and Oracle. It can be customized for application like Metavance, web based application like SAP web portal by our technically expertise development team.