Introduction to .net and SQL Server Programming Courses | Simpliv

Introduction to .net and SQL Server Programming Courses | Simpliv

Learn the elements of data and time in .net and SQL server at this course. Practical and detailed to the point, Elias will show you how to get these aspects right without ranting or wasting your time. Earn a certificate upon completion. Install on android or iOS. The price of this learning: just 9!

Description
Teaching Approach

No fluff, no ranting, no beating the air. I esteem your time. The course material is succinct, yet comprehensive. All the important concepts are covered. Particularly important topics are covered in-depth. For absolute beginners, I offer my help on Skype absolutely free, if requested.

Take this course, and you will be satisfied.

Build a solid foundation of working with Date and Time with this course

Almost all the software works with date and time in one form or another. Some programs, of course, need to work with date and time more than other. However, date and time hide many pitfalls even in very simple scenarios. We all know that security and logging are regular aspects of almost any program. There is a wise phrase that sounds like: “Developers recall about security when it is too late.” The same can be said about date and time. Most developers don’t even imagine how many bugs are hiding behind the simple face of date and time. Those bugs are sitting in programs and waiting for their moment to blow up your production code causing very unfortunate repercussions. That’s why working with date and time is the full-fledged and very important aspect of software development.

Have you watched magnificent enlightening TV Shows by BBC? This course in some parts is like those BBC shows, because you’ll learn many interesting surprising facts. Besides, being familiar with peculiarities of working with date and time, you can write much more reliable and maintainable applications.

Content and Overview

This course is aimed at all kind of developers. It provides solid theoretical base reinforced by practical material.

We start with basics of date and time. I’ll show you some real cases when bugs related to date and time caused unpleasant consequences, event deaths of people. You’ll learn why the hell Gregorian calendar was introduced, why the 5th of October 1582 doesn’t exist at all. And did you know that actually a minute can last more than 60 seconds? Yes, you heard that, a minute can last more than 60 seconds. You’ll learn what is UTC, GMT, what is the difference between them and how time gets synchronized between computers all over the world. And by the way, what is time at all, how humanity measures it? After that, you’ll be introduced to the concept of time zones, you’ll learn about different standards that regulate date and time formatting. You’ll learn what is Epoch Time and Unix Time. Finally, you’ll understand the difference between different date-time scopes and perspectives.

The next section is dedicated to Time Zones where you’ll learn about daylight saving time and different very odd case with time transitions back and forth. I’ll give you a full definition of a time zone. You’ll learn more about providers of time zone information: IANA and Microsoft. You’ll learn many interesting facts and what fallacies exist about time zones.

The third section is all about date and time related types from BCL in .NET. You’ll learn about DateTime, DateTimeOffset, TimeZoneInfo, TimeSpan, Calendars and Stopwatch. I’ll show you that DateTime hides many pitfalls. You’ll learn that actual precision of BCL types is not equal to 100 nanoseconds as declared in the documentation. You’ll see how many calendars exist and what we can do with them. The third section reveals all the problems with the types built-in to BCL, so in the next section, you’ll learn about a third-party library called “Noda Time”.

Yes, a whole section is dedicated to the Noda Time library. You’ll learn about features provided by this library. You’ll get an overview of all the core types such as: LocalTime, LocalDate, LocalDateTime, Instant, Interval, Duration, ZonedDateTime and others. You’ll also learn how to write unit tests on code which uses date and time values with the help of Noda Time.

The whole section is dedicated to best practices of working with date and time. You’ll see some astonishing things like arithmetic on dates and problems of birthday calculation. You’ll learn the problems related to parsing and how to overcome them. I’ll show you the problems of events schedulingand what to do to avoid common mistakes. You’ll learn about date and time ranges, “intervals” is a separate peculiar topic. I’ll also show some additional best practices.

In other words, an exciting journey is waiting for you, just take it, relax and enjoy.

So, in short, the course covers the following topics:

Date and Time Fundamentals: Gregorian calendar, UTC, GMT, Atomic Time, How Computers Store Time, NTP, Date and Time Formats based on Standards and Specifications, Epoch Time and Unit Time, Date and Time Scope and Perspective
Time Zones: Definition (complex one), Daylight-Saving Time (DST), Providers such as IANA or TZDB and Microsoft
Date and Time in .NET: DateTime, DateTimeOffset, TimeZoneInfo, TimeSpan, Calendars, Stopwatch and many intrinsic details
Noda Time: overview, core types, unit testing
A great number of best practices of working with Date and Time: arithmetic on dates, parsing, calculating of birthdays, scheduling events, date formats, ranges and other.
In the end, we will recap what you have learned.

How long is this course: The course is around 3 hours. All are video lectures. You will be able to download all the slides and code samples used in the course.

Keywords.

C# datetime, C# datetime format, datetime parse, C# datetimeoffset, date and time fundamentals, datetime in .net, noda time, nodatime, C# datetime now, C# string to datetime, C# tostring format, utc now
noda time tutorial, C# datetime tutorial, datetime C# tutorial, datetime vs nodatime, datetime vs noda time, noda time C#, noda time vs datetimeoffset, noda time vs datetime
SQL date, SQL Server Date Functions, SQL Date Functions, DateTime SQL, SQL Server DateTime
Who is the target audience?

Anyone who is interested in working with date and time
C# developers who want to write reliable code that works with date and time
Basic knowledge
You should have some experience in C# (nothing more)
What will you learn
Use date & time related types from BCL properly
Use Noda Time for writing reliable code
Avoid common mistakes
Apply best practices of working with date and time values
To continue:

Sum Time columns in SQL

I'm writing a query to calculate when the students check-in and check-out and how much time they spend at the GYM. I have a Checking Field that contains the check-in time and a check-out field that contains the check-out, and a Duration.

I'm writing a query to calculate when the students check-in and check-out and how much time they spend at the GYM. I have a Checking Field that contains the check-in time and a check-out field that contains the check-out, and a Duration.

Check In        Check Out      Duration

12:30:00 1:30:00 1:00:00

How can I calculate check-in and check-out to obtain a duration like in the example?


Build a CRUD App with ASP.NET Core 2.2 and SQL Server

Build a CRUD App with ASP.NET Core 2.2 and SQL Server

​ I’ve always said that you can tell a lot about a person by the kind of music they listen to. Don’t tell me you haven’t had serious doubts about whether you can be friends with someone when you find out that they like a particular band or artist. In that spirit, I created *JudgeMyTaste*, an ASP.NET Core web application where people can enter their favorite band or artist so that people on the Internet can judge them openly. ​ The combination of ASP.NET and SQL Server is probably the most common pairing in the enterprises that use ASP.NET. With ASP.NET Core and SQL Server both being cross-platform, you don’t *have* to run this combination on Windows anymore! I’ll show you how to create a basic CRUD application using ASP.NET Core 2.2 and SQL Server 2017. I’ll be running on Linux, but with the free tools used here, it won’t matter what operating system you’re using! ​ The tools I’ll be using that are available for all platforms are: * SQL Server 2017 (I’ll be running on Ubuntu 18.04) * Visual Studio Code * Azure Data Studio * ASP.NET Core 2.2 ​ Once you’ve got all the tools installed for your platform, let’s rock and roll! ​ ​ ​ ## Scaffold Your ASP.NET Core 2.2 Application ​ No matter the platform you’re on, the ```dotnet``` CLI is available. The commands used here should be the same for everyone. To scaffold the ASP.NET Core 2.2 MVC application, create a new folder for it: I’ve always said that you can tell a lot about a person by the kind of music they listen to. Don’t tell me you haven’t had serious doubts about whether you can be friends with someone when you find out that they like a particular band or artist. In that spirit, I created JudgeMyTaste, an ASP.NET Core web application where people can enter their favorite band or artist so that people on the Internet can judge them openly.

I’ve always said that you can tell a lot about a person by the kind of music they listen to. Don’t tell me you haven’t had serious doubts about whether you can be friends with someone when you find out that they like a particular band or artist. In that spirit, I created JudgeMyTaste, an ASP.NET Core web application where people can enter their favorite band or artist so that people on the Internet can judge them openly.

The combination of ASP.NET and SQL Server is probably the most common pairing in the enterprises that use ASP.NET. With ASP.NET Core and SQL Server both being cross-platform, you don’t have to run this combination on Windows anymore! I’ll show you how to create a basic CRUD application using ASP.NET Core 2.2 and SQL Server 2017. I’ll be running on Linux, but with the free tools used here, it won’t matter what operating system you’re using!

The tools I’ll be using that are available for all platforms are:

  • SQL Server 2017 (I’ll be running on Ubuntu 18.04)
  • Visual Studio Code
  • Azure Data Studio
  • ASP.NET Core 2.2

Once you’ve got all the tools installed for your platform, let’s rock and roll!

Scaffold Your ASP.NET Core 2.2 Application

No matter the platform you’re on, the dotnet CLI is available. The commands used here should be the same for everyone. To scaffold the ASP.NET Core 2.2 MVC application, create a new folder for it:

mkdir JudgeMyTaste

Change into that new directory:

cd JudgeMyTaste

Then run the following command:

dotnet new mvc

Then open the new application in VS Code.

code .

When you open the new application in VS Code, you should get a warning in the bottom right corner asking to add some missing assets. Go ahead and add the missing assets. You’ll see the .vscode folder added with a launch.json and a tasks.json file.

These will allow you to run the application from VS Code. To verify that everything scaffolded properly, run the base application by typing F5. This will build the application, run it, and open it in a new browser window.

You may notice a strange error page come up, if you’ve never run an ASP.NET Core 2.x application before. By default ASP.NET Core wants to run on HTTPS. This is a recommended practice for web applications. You could avoid this message by removing the redirect to HTTPS in your Startup.cs or by generating a certificate for your local machine, but this error screen only comes up once in a great while, so I just side step it by clicking on Advanced and telling the browser that it’s okay to visit this site even though there is no certificate for it.

For your daily work, it will probably behoove you to create a local certificate for development so that you never have to see this message again.

Create Your SQL Server Database

Open Azure Data Studio and connect to your localhost server with the SA password you created when installing SQL Server on your machine. You’ll notice it is arranged very much like VS Code. In the Connections Explorer, you will see localhost as a connection. Right-click on the connection and choose New Query, which will open a new query window on the right side. Start typing the word CREATE and an intellisense drop down will open and one of the choices will be sqlCreateDatabase. Choose that option and a query will be scaffolded with the database name highlighted in the three places that it occurs in the query. You can just start typing the database name “JudgeMyTaste” and it will be replaced in all three places so that the final query looks like this.

-- Create a new database called 'JudgeMyTaste'
-- Connect to the 'master' database to run this snippet
USE master
GO
-- Create the new database if it does not exist already
IF NOT EXISTS (
  SELECT [name]
    FROM sys.databases
    WHERE [name] = N'JudgeMyTaste'
)
CREATE DATABASE JudgeMyTaste
GO

Now you can just click the green Run arrow at the top of the window to create the database. Simple, no?

Now when you expand the Databases folder in the Connection Explorer, you will see the JudgeMyTaste database in the list. Right-click on the new database and choose New Query again. Start typing CREATE again and this time choose sqlCreateTable from the options presented. Again, you can start typing the table name FavoriteBands and it will be filled in all the places it occurs in the query.

You’ll also need to add some other columns to the table. Add the columns for Id, Name, EnteredBy, and EnteredOn so that the query looks like this:

-- Create a new table called '[FavoriteBands]' in schema '[dbo]'
-- Drop the table if it already exists
IF OBJECT_ID('[dbo].[FavoriteBands]', 'U') IS NOT NULL
DROP TABLE [dbo].[FavoriteBands]
GO
-- Create the table in the specified schema
CREATE TABLE [dbo].[FavoriteBands](
  [Id] [int] IDENTITY(1,1) NOT NULL,
  [Name] [varchar](255) NULL,
  [EnteredBy] [varchar](255) NULL,
  [EnteredOn] [date] NULL
);
GO

Then run the query by clicking the green Run arrow as before.

It’s good practice to create a user specifically for your application to connect with the database. One that only has the permissions that it will need to interact with your database. Here’s a script to create a login and a user for the database and assign that user dbo permissions to the database.

USE master

GO

CREATE LOGIN webapp WITH PASSWORD=N'[email protected]!', DEFAULT_DATABASE=JudgeMyTaste

GO

ALTER LOGIN webapp ENABLE

GO

USE JudgeMyTaste

GO

CREATE USER webapp FOR LOGIN webapp
EXEC sp_addrolemember 'db_owner', 'webapp'

GO

It might seem like a lot going on here, but it simply creates a login for SQL Server, makes that login a user for the JudgeMyTaste database, and add it to the db_owner role for the database. This will allow that login to do all the CRUD operations that the application will need. Now your database is ready to be used by your application!

Connect SQL Server to Your ASP.NET Core 2.2 MVC Application

Before anything else, you’ll need the Entity Framework Core NuGet package. To install it, run the following command in the terminal.

dotnet add package Microsoft.EntityFrameworkCore.SqlServer --version 2.2.4

Start by adding the connection string to your appsettings.json file in the root of your MVC project, so that it looks like this:

{
  "Logging": {
    "LogLevel": {
      "Default": "Warning"
    }
  },
  "AllowedHosts": "*",
  "ConnectionStrings": {
    "JudgeMyTasteDatabase": "Server=.;Database=JudgeMyTaste;user id=webapp;[email protected]!"
  }
}

In the Models folder, create a class file called FavoriteBand.cs.

using System;
using System.ComponentModel.DataAnnotations;

namespace JudgeMyTaste.Models
{
  public class FavoriteBand
  {
    public int Id { get; set; }
    public string Name { get; set; }
    public string EnteredBy { get; set; }
    public DateTime EnteredOn { get; set; }
  }
}

This class will be used to work with the FavoriteBand entries.

In the root of the project, create a folder called Data to house the database context for the application. Create a C# file called JudgeMyTasteContext.cs with the following contents:

using JudgeMyTaste.Models;
using Microsoft.EntityFrameworkCore;

namespace JudgeMyTaste.Data
{
  public class JudgeMyTasteContext : DbContext
  {
    public JudgeMyTasteContext(DbContextOptions<JudgeMyTasteContext> options) : base(options)
    {
    }

    public DbSet<FavoriteBand> FavoriteBands { get; set; }
  }
}

In your Startup.cs file, in the ConfigureServices() method, right before the services.AddMvc()... line, add the newly created context with the connection string.

services.AddDbContext<JudgeMyTasteContext>(options => options.UseSqlServer(Configuration.GetConnectionString("JudgeMyTasteDatabase")));

Now your database is all hooked into your application. All you need to do is create some way for the user to enter their favorite bands. To get some more scaffolding goodness for the CLI, install the Code Generation tool.

dotnet add package Microsoft.VisualStudio.Web.CodeGeneration.Design

Now you can scaffold a controller to handle all the CRUD operations for the FavoriteBand class by running the following command from the terminal.

dotnet aspnet-codegenerator controller -name FavoriteBandsController -async -m JudgeMyTaste.Models.FavoriteBand -dc JudgeMyTaste.Data.JudgeMyTasteContext -namespace Controllers -outDir Controllers -udl

This is a long one but if you break it down into its component pieces, it’s easier to understand.

The first part just calls the dotnet CLI’s new aspnet-codegenerator command for a controller. You want the controller’s name to be “FavoriteBandsController” and for the controller actions to all be -async. The model being used to generate the controller is the JudgeMyTaste.Models.FavoriteBand class, and the database context will be the JudgeMyTaste.Data.JudgeMyTasteContext class you just created. The namespace and output directory for the controller will be Controllers and the -udl switch tells the generator to use the default layout for the views it will generate (yeah, it’s going to generate views for everything too!). Pretty cool, right?

Once you run the command, you should see the controller and all it’s views show up. The only thing left is to create a link so that users can get to the favorite bands section of the site easily.

In the Views/Shared folder open the Layout.cshtml file and add a link to the menu to get to the new section of the site.

<li class="nav-item">
  <a class="nav-link text-dark" asp-area="" asp-controller="FavoriteBands" asp-action="Index">Favorite Bands</a>
</li>

Now when you run the application, you can click on the Favorite Bands menu item and see a list of all the favorite bands that have been entered. Of course there aren’t any right now, so add one using the Create New link at the top of the page and see it show up in the listing.

Now it’s a little cumbersome to add the EnteredOn value manually, and the code generator you used can’t know that you can just add that field to the entry as it’s being saved, so change the Create() method of the FavoriteBandController to add it automatically.

// POST: FavoriteBands/Create
// To protect from overposting attacks, please enable the specific properties you want to bind to, for
// more details see http://go.microsoft.com/fwlink/?LinkId=317598.
[HttpPost]
[ValidateAntiForgeryToken]
public async Task<IActionResult> Create([Bind("Id,Name,EnteredBy")] FavoriteBand favoriteBand)
{
  if (ModelState.IsValid)
  {
    favoriteBand.EnteredOn = DateTime.Now;
    _context.Add(favoriteBand);
    await _context.SaveChangesAsync();
    return RedirectToAction(nameof(Index));
  }
  return View(favoriteBand);
}

The only things that have changed is that I removed the EnteredOn field from the Bind statement in the method signature, and I added the value DateTime.Now as the value right before saving it to the database.

Add Authentication to Your ASP.NET Core 2.2 MVC + SQL Server Application

What you have now is okay, but there’s currently no way to keep users from editing other user’s entries. We want to make sure to judge people for their favorite band that they actually entered, right?

No reason to write this yourself. You can easily integrate Okta to handle the authentication for you and easily:

Sign up for a forever-free developer account (or log in if you already have one).

Once you have signed up and logged in, you’ll be taken to your dashboard. Make note of your Org URL in the top right corner.

Click on the Applications menu item at the top, click Add Application, and from the first page of the wizard choose Web and click Next.

On the next screen, change the application name to “Judge My Taste App” and update the Base URIs value and the Login Redirect URIs to reflect to the correct port and the fact that you’re running on the HTTPS scheme.

Then click Done and you’re taken to the application page. On the General Settings tab click Edit and add a URL to the Logout Redirect URIs with a value of <a href="https://localhost:5001/signout/callback" target="_blank">https://localhost:5001/signout/callback</a>. This is where Okta will redirect back to after the logout call. This is handled by the ASP.NET OIDC Middleware.

Configure Your ASP.NET Core 2.2 MVC Application for Authentication

Now you need to tell your application how to use Okta for authentication. The easiest way is to use the ASP.NET SDK from Okta. You can install it from NuGet using the following command:

dotnet add package Okta.AspNetCore --version 1.1.5

Add some configuration values to your appsettings.json file to that the final file looks like this:

{
  "Logging": {
    "LogLevel": {
      "Default": "Warning"
    }
  },
  "AllowedHosts": "*",
  "ConnectionStrings": {
    "JudgeMyTasteDatabase": "Server=.;Database=JudgeMyTaste;user id=webapp;[email protected]!"
  },
  "Okta": {
    "ClientId": "{yourClientId}",
    "ClientSecret": "{yourClientSecret}",
    "OktaDomain": "https://{yourOktaDomain}",
    "PostLogoutRedirectUri": "https://localhost:5001/"
  }
}

This PostLogoutRedirectUri is the URL that the middleware will redirect to once Okta has redirected back to the signout/callback URL. You can use any valid URL in the MVC application. Here, I am just redirecting to the root of the application.

Back in the Startup.cs file, add the following using statements:

using Okta.AspNetCore;
using Microsoft.AspNetCore.Authentication.Cookies;

Then at the very beginning of the ConfigureServices() method add:

var oktaMvcOptions = new OktaMvcOptions();
Configuration.GetSection("Okta").Bind(oktaMvcOptions);
oktaMvcOptions.Scope = new List<string> { "openid", "profile", "email" };
oktaMvcOptions.GetClaimsFromUserInfoEndpoint = true;

services.AddAuthentication(options =>
{
  options.DefaultAuthenticateScheme = CookieAuthenticationDefaults.AuthenticationScheme;
  options.DefaultSignInScheme = CookieAuthenticationDefaults.AuthenticationScheme;
  options.DefaultChallengeScheme = OktaDefaults.MvcAuthenticationScheme;
})
.AddCookie()
.AddOktaMvc(oktaMvcOptions);

This is a pretty dense chunk of code, but most of it is boilerplate for the OIDC middleware that the Okta SDK is built on. The first part just binds all of those configuration values you just added in appsettings.json to the oktaMvcOptions. It also adds the scopes you want to receive (which are the OpenID information, the user’s profile, and the user’s email address). It also tells the middleware that it can get the claims from the user info endpoint, which all OIDC identity providers have.

When the code adds authentication, it tells the OIDC provider to use cookies for storing tokens and that you’ll be sending users to Okta from an MVC application.

To actually wire up authentication, you need to tell the Configure() method to use this service you just configured. Right before the app.UseMvc(...) line, add:

app.UseAuthentication();

Okta is now configured in your application! You still need to set up your application to challenge the user (send them to Okta to authenticate).

Create a new controller in the Controllers folder called AccountController with the following code:

using Microsoft.AspNetCore.Authentication.Cookies;
using Microsoft.AspNetCore.Mvc;
using Okta.AspNetCore;

namespace JudgeMyTaste.Controllers
{
  public class AccountController : Controller
  {
    public IActionResult Login()
    {
      if (!HttpContext.User.Identity.IsAuthenticated)
      {
        return Challenge(OktaDefaults.MvcAuthenticationScheme);
      }
      return RedirectToAction("Index", "Home");
    }

    public IActionResult Logout()
    {
      return new SignOutResult(new[]
      {
        OktaDefaults.MvcAuthenticationScheme,
        CookieAuthenticationDefaults.AuthenticationScheme
      });
    }
  }
}

This will give you a Login() and Logout() method to wire up some menu items. Speaking of which, add a new view in Views/Shared called _LoginPartial.cshtml. This will house all the code for the login menu items.

@if (User.Identity.IsAuthenticated)
{
  <ul class="navbar-nav ml-auto">
    <li>
      <span class="navbar-text">Hello, @User.Identity.Name</span> &nbsp;
      <a onclick="document.getElementById('logout_form').submit();" style="cursor: pointer;">Log out</a>
    </li>
  </ul>
  <form asp-controller="Account" asp-action="Logout" method="post" id="logout_form"></form>
}
else
{
  <ul class="navbar-nav">
    <li><a asp-controller="Account" asp-action="Login">Log in</a></li>
  </ul>
}

Change the main menu in Views/Shared/_Layout.cshtml to add this in and move the main menu to the left and have the login menu on the far right. The final div that houses the menu should look like this:

<div class="navbar-collapse collapse justify-content-between">
  <ul class="navbar-nav mr-auto">
    <li class="nav-item">
      <a class="nav-link text-dark" asp-area="" asp-controller="Home" asp-action="Index">Home</a>
    </li>
    <li class="nav-item">
      <a class="nav-link text-dark" asp-area="" asp-controller="Home" asp-action="Privacy">Privacy</a>
    </li>
    <li class="nav-item">
      <a class="nav-link text-dark" asp-area="" asp-controller="FavoriteBands" asp-action="Index">Favorite Bands</a>
    </li>
  </ul>
  <partial name="_LoginPartial" />
</div>

The class list for the navbar-collapse has changed to add the justify-content-between class that will keep the menus apart. The ul’s class also changed to mr-auto which will help keep it left. Lastly, the login partial is added at the end of the menu.

Don’t just sit there, fire this thing up and judge me for liking Nickleback!

Now you have a complete CRUD slice built in an ASP.NET Core 2.2 MVC application saving data to a SQL Server database! Now you can take the same path to add things like favorite movie, favorite food, and favorite beverage so that you can easily and completely judge people for their taste online!!!

SQL Fundamentals for Marketing, Digital and Web Analytics|Simpliv

SQL Fundamentals for Marketing, Digital and Web Analytics|Simpliv

Understanding the SQL concepts for Digital Marketing and Web Analytics, understanding the fundamentals of data and SQL, Knowing some common uses cases for Marketing, Web and Digital Analytics

Description
Data is a requirement these days to run effective marketing campaigns. Application of Big Data starts with understanding the fundamentals of data and SQL.

If you are already familiar with SQL then you can skip this course. This course teaches you all the SQL you need as a Digital Marketing Analyst or a Web Analyst. This course won't go into advanced level SQL concepts as that is not required to your job as as a Digital Marketing Analyst/Web Analyst. I strongly believe in short and simple courses that can get you ready in few hours as opposed to days.

However, if you ever get stuck or need something that I don't cover in this course then feel free to reach out to me.

Marketers and Marketing Analysts generally depend on the tools or IT department to help them pull the data for marketing purposes. IT leaves you hanging because they have other priorities as a results Marketing Analysts have to know how write SQL on their own so that they are not dependent on IT. This course is for those marketers who would like to know how to use SQL to conduct their marketing analysis.

If you are trying for a job as a Marketing Analysts then this course is a must for you. This will help your resume shine and put you ahead of other similar candidates. The more you can handle technology and data these days the better it differentiates you from the rest of the pack.

The course uses MYSQL to show how SQL works but all the leanings and syntax are applicable to other databases such Microsoft SQL Server and Oracle as well.

This course is a must have for Web Analytics, Digital Analytics and Marketing Analytics. This course will put you way ahead of other folks doing or seeking similar jobs. I have used the same course to train members of my team so you can be assured that this is tried and tested curriculum.

Why you should learn from me?

I have been in Digital Marketing and Analytics for over 15 years. I have trained people from diverse backgrounds and have converted them into high performing Digital Marketers and Analysts. I understand both the technology and marketing side of business. I have dealt with many analytics technologies way before Google Tag manager existed and know the inner working of Digital Analytics.

I have extensively worked with companies like Microsoft, Starbucks, Wall Street Journal, ESPN, T-Mobile to name few and helped them Data Driven Marketing Decisions.

In addition, I have developed various course and taught students from all over the world. I am online instructor for University of British Columbia (Canada), University of Washington (USA), Bellevue College (USA) and Digital Analytics Association.

I have an engineering degrees and an MBA.

Who this course is for:

Web Analysts
Digital Analyst
Marketers
Business Analyst
Basic knowledge
Basic computer skills
What will you learn
Write and Understand SQL to pull the data for marketing
Grasp Database fundamentals
Understanding of how data is structures and stored in databases
Master common SQL commands used by Marketing analysts
Import data into MySQL from CSV and Excel files
Export data from MySQL into Excel files
Connect MySQL with Tableau for data visualization
Use Databases and SQL with confidence
Learn some common uses cases for Marketing, Web and Digital Analytics
To continue: