• The impala server consist of distributed and massively parallel processing info engine.
• It run on particular hosts among your CDH cluster with a various daemon processes.

• The core impala element may be a daemon method that runs on every node of the cluster, and its physically described by the impalad method.
• Then read and write a informative files; which accepts questions transmitted from the impala-shell command, Hue, JDBC, or ODBC; parallelizes the questions can seperate work to alternative nodes within the impala cluster; and transmits intermediate question results back to the central organizer node.
• The impala daemon running on any node, and that node is the organizer node for that question when You can submit a question.
• The other nodes transmit partial results back to the organizer, that constructs the ultimate result set for a question.
• You may continuously connect with a similar impala daemon for convenience.When running experiments with possibility through the impala-shell command.
• For clusters running production workloads, you would possibly load-balance between the nodes by submitting every question to a distinct impala daemon in round-robin vogue, exploitation the JDBC or ODBC interfaces.
• Its verify that nodes and may settle for new work. Through the impala daemons are in constant communication with the statestore.

• The impala element called the statestore checks on the health of impala daemons on all the nodes during a cluster, and unendingly relays its findings to every of these daemons.
• It is physically described by a daemon method named statestored; you simply would like such a method on one node within the cluster.
• If an impala node goes offline because of hardware failure, network error, software package issue, or alternative reason, the statestore informs all the opposite nodes so future queries will avoid creating requests to the unreached node.

• Performance and quantifiability enhancements.
• Integration with Apache koodoo.
• Security.
• The REFRESH statement currently updates data regarding HDFS block locations.
• [IMPALA-1654] many varieties of DDL operations will currently work on a spread of partitions.

• Impala can query many file format such as Parquet, Avro, Text, RCFile, SequenceFile
• Impala supports data stored in HDFS, Apache HBase and Amazon S3
• Impala supports multiple compression codecs:
  • Snappy (Recommended for its effective balance between compression ratio and decompression speed),
  • Gzip (Recommended when achieving the highest level of compression),
  • Deflate (not supported for text files), Bzip2, LZO (for text files only);
• Impala provides security through authorization based on Sentry (OS user ID)
  • Defining which users are allowed to access which resources,
  • What operations are they allowed to perform authentication based on Kerberos + ability to specify Active Directory username/password,
  • How does Impala verify the identity of the users to confirm that they are allowed exercise their privileges assigned to that user auditing,
  • What operations were attempted,
  • Did they succeed or not, allowing to track down suspicious activity; audit data are collected by Cloudera Manager;
• Impala supports SSL network encryption between Impala and client programs, and between the Impala-related daemons running on different nodes in the cluster;
• Impala allows to use UDFs and UDAFs;
• Impala orders the joins automatically to be the most efficient;
• Impala allows admission control – prioritization and queueing of queries within impala;
• Impala allows multi-user concurrent queries;
• Impala caches frequently accessed data in memory;
• Impala computes statistics (with COMPUTE STATS);
• Impala provides window functions (aggregation OVER PARTITION, RANK, LEAD, LAG, NTILE, and so on) – to provide more advanced SQL analytic capabilities (since version 2.0);
• Impala allows external joins and aggregation using disk (since version 2.0) – enables operations to spill to disk if their internal state exceeds the aggregate memory size;
• Impala allows subqueries inside WHERE clauses;
• Impala allows incremental statistics – only run statistics on the new or changed data for even faster statistics computations;
• Impala enables queries on complex nested structures including maps, structs and arrays;
• Impala enables merging (MERGE) in updates into existing tables;
• Impala enables some OLAP functions (ROLLUP, CUBE, GROUPING SET);
• Impala allows use of impala for inserts and updates into HBase.

• MVP is a design pattern for developers to write their code in a more readable, maintainable, and scalable manner.
• In MVP, our code is divided into three parts named Model, View, and Presenter rather than placing the whole code in one activity.
  • Model – The model handles the data part of our application.
  • Presenter – It acts as a bridge that connects a Model and a View.
  • View – This is responsible for laying out views with the relevant data as instructed by the Presenter.

• Everything which is related with data is a part of the Model. The Model contains a data provider and the code which fetches and updates the data.
• This part of MVP updates the database or communicates with a web server.

• The Presenter contains the application’s business logic and when an operation is performed or data is changed then it will notify the View that it needs to update.

• The View part of MVP contains the visual parts of our application, like showing messages, and also handles visibility.
• View contains only that part of the code which is related to UI and it does not contain any logic related to the displayed data. The View is controlled by the Presenter.

• The diagram below depicts a basic MVP structure.

• Activity, Fragment and a CustomView act as the View part of the application.
• The Presenter is responsible for listening to user interactions (on the View) and model updates (database, APIs) as well as updating the Model and the View.
• Generally, a View and Presenter are in a one to one relationship. One Presenter class manages one View at a time.
• Interfaces need to be defined and implemented to communicate between View-Presenter and Presenter-Model.
• The Presenter is responsible for handling all the background tasks. Android SDK classes must be avoided in the presenter classes.
• The View and Model classes can’t have a reference of one another.

• A Fragment is a piece of an activity which enable more modular activity design. It will not be wrong if we say, a fragment is a kind of sub-activity. A fragment has its own layout and its own behavior with its own life cycle callbacks.

• You can add or remove fragments in an activity while the activity is running.
• You can combine multiple fragments in a single activity to build a multi-plane UI.
• Android Fragment is the part of activity, it is also known as sub-activity. There can be more than one fragment in an activity. Fragments represent multiple screen inside one activity.
• Android fragment lifecycle is affected by activity lifecycle because fragments are included in activity.
• Each fragment has its own life cycle methods that is affected by activity life cycle because fragments are embedded in activity.
• The Fragment Manager class is responsible to make interaction between fragment objects.

• The lifecycle of android fragment is like the activity lifecycle. There are 12 lifecycle methods for fragment.

• The general steps to use a Fragment:

• • Create a subclass of Fragment.
  • Create a layout for the Fragment.
  • Add the Fragment to a host Activity, either statically or dynamically.

• To create a Fragment in an app, extend the Fragment class, then override key lifecycle methods to insert your app logic, similar to the way of Activity class.
• Instead of extending the base Fragment class, you can extend one of these other, more specific Fragment subclasses:
  • DialogFragment : Displays a floating dialog, such as a date picker or time picker.
  • ListFragment : Displays a list of items that are managed by an adapter (such as a SimpleCursorAdapter).
  • PreferenceFragment : Displays a hierarchy of Preference objects as a list, similar to PreferenceActivity. This is useful when creating a “settings” Activity for your app.

How to create a Fragment in Android Studio

• In Project: Android view, expand app > java and select the folder containing the Java code for your app.
• Choose File > New > Fragment > Fragment (Blank).
• Name the Fragment something like SimpleFragment, or use the supplied name (BlankFragment).
• If your Fragment has a UI, check the Create layout XML option if it is not already checked. Other options include:

• • Include fragment factory methods : Include sample factory method code to initialize the Fragment arguments in a way that encapsulates and abstracts them. Select this option if the number of arguments would make a constructor too complex.
  • Include interface callbacks : Select this option if you want to include sample code that defines an interface in the Fragment with callback methods that enable the Fragment to communicate with its host Activity.

• Click Finish to create a Fragment.

• Fragments were added to the Android API in Honeycomb(API 11).
  • android.app.Fragment : The base class for all fragment definitions
  • android.app.FragmentManager : The class for interacting with fragment objects inside an activity
  • android.app.FragmentTransaction : The class for performing an atomic set of fragment operations

• When using a compatibility package library provided by Google, the following classes are used for implementation.
  • android.support.v4.app.FragmentActivity : The base class for all activities using compatibility-based fragment (and loader) features
  • android.support.v4.app.Fragment
  • android.support.v4.app.FragmentManager
  • android.support.v4.app.FragmentTransaction

• Let’s have a look at the simple example of android fragment.

• • An activity represents a single screen with a user interface just like window or frame of Java .Android activity is the subclass of Context Theme Wrapper class.
    • Activities are a fundamental building block of Android applications and they can exist in a number of different states.

• • The activity lifecycle begins with instantiation and ends with destruction, and includes many states in between.
  • When an activity changes state, the appropriate lifecycle event method is called, notifying the activity of the impending state change and allowing it to execute code in order to adapt to that change.
  • Android Activity Lifecycle is controlled by 7 methods of android.app.Activity class.
  • An activity is the single screen in android. It is like window or frame of Java.
  • By the help of activity, you can place all your UI components or widgets in a single screen.
  • The 7 lifecycle method of Activity describes how activity will behave at different states.

• Let’s see the 7 lifecycle methods of android activity.

• It provides the details about the invocation of life cycle methods of activity. In this example, we are displaying the content on the logcat.
  • File: MainActivity.java

• You will not see any output on the emulator or device. You need to open logcat.

• Now see on the logcat: on Create, on Start and on Resume methods are invoked.

• Now click on the HOME Button. You will see on Pause method is invoked.

• After a while, you will see on Stop method is invoked.

• Now see on the emulator. It is on the home. Now click on the center button to launch the app again.

• Now click on the lifecycle activity icon.

• Now see on the logcat: on Restart, on Start and on Resume methods are invoked.

• If you see the emulator, application is started again.

• Now click on the back button. Now you will see onPause methods is invoked.

• After a while, you will see onStop and onDestroy methods are invoked.