1. The packages are treated as part of a project and they are linked to the project and properties.
2. This mode needs a special database SSISDB, to be used for deployment and execution. We cannot deploy packages as part of file system.
3. The packages are deployed as a project instead of individual packages. All or none package deployment happen in this option. We cannot deploy selective packages (in SSIS 2016, even projects can deploy individual packages i.e. added feature of selectivity).
4. The packages can share project properties, parameters, connections etc.

1. Even packages are part of a project they are maintained individually.
2. The packages can be deployed either in database (msdb) or file system.
3. The advantage of file system deployment is, we can have separate maintenance strategy of packages than database.

1. We should use proper version of BI editor which matches with our target version, otherwise, we will face run time issues while deploying the code.
2. Since we are using the TFS with VS 2015, the team used VS 2015 to open the SSIS and SSRS packages to add them in TFS. When we open packages and reports in VS 2015 (it will prompt for auto-upgrade to new version), they by default refer the latest version of SQL 2016. But our target is 2014. This creates a problem when we run the SSIS packages or SSRS reports.
3. We should create a new project in VS 2015 and change the project target version property to use proper version i.e. in our case SQL 2014 for SSIS packages.
4. 
5. Now we need to add the required SSIS packages which need to be up-graded to the new project. If we have many packages, it will be difficult to add them one by one. We can edit the project file and add the package name. We can use command prompt to get the package names and then use MS Excel to add the required other values needed to complete the project file with all the package names.
6. Now we need to open the packages and check for any error.
7. If the target version is SQL 2016, the VSTA version would be 14. But in our case the target is SQL 2014, so we need to downgrade the target to SQL 2014 and it has VSTA version 3.
8. We may not be in risk if the package does not have any script task or script component.
9. We can open the package file in notepad and search for tag VSTA and verify the version.
10. 
11. When we change the target version from 2016 to 2014, we get error for script task and script component.
12. When we open the script task , we observe the readonly and readwrite variables are blank. The script component, is not editable. So need to rewrite them, by taking the code from original file.
13. For SSRS reports, we need to create a new project and change the target to appropriate version.
14. 
15. Now we can add the data source (rds) and report (rdl) files.
16. Verify the reports.
17. If we open the reports in VS 2015, we can find a tag in the report with 2016 version. xmlns="https://schemas.microsoft.com/sqlserver/reporting/2016/01/
18. We need to build the project and go to the bin folder and get the rds and rdl files which would be referring to 2010.
19. These are the ones (rds and rdl files) to be deployed in the target system.

1. Creating Parent Child relationship
   1. We can create a parent package and call other package as child (by referring execute package task in control file).
   2. But in this way we cannot use the child’s own external configuration (xml) file. We need to add all the child’s configured values to the parent’s and from child package, we need to use parent package variable configuration option.
   3. This way we are tightly coupling the packages and the child cannot run independently.
2. Dynamically loading the package and its config file.
   1. We can have a script task and pass the package name and config names as variables.
   2. In this way, we can write code for loading package with configuration file. Refer the links for details. Link1, Link2, Link3.
   3. We could not get the proper log for the child package.
3. Using a batch file
   1. Batch file inside parent package.
      1. We need to use execute process instead of execute package.
      2. The batch file will have the package name and the config file.
   2. Batch file as a wrapper (powershell script can be used for better handling).
      1. We need to create a single batch file which calls the packages in order.
      2. In this way there is no relationship maintained.
      3. We can use if else condition to make sure one package need to be run only when the other succeeds.

1. We need to convert the file to binary stream and either store in database table or pass as an object by the service bus to the local service.
2. We need various properties like name of the file, type of file, destination location (optional) and the binary of the file.
3. The local service will create the file at remote server with the properties.
4. We can do further processing once it is available at local service.

I used the fiddler tool to analyze the internal of request, but strange the code started working. I was happy. I stopped the Fiddler tool and went to the code and re-executed. It stopped working and gave me same error. Was there something magic done by Fiddler tool?

I was using a web application and by clicking of a button the file had to be posted. Then I found something interesting that the Fiddler tool was using a proxy. But I could not find the proxy details from the internet explorer -> tool -> settings-> Connection -> LAN Settings. But I could see option for "Use automatic configuration script" and a link https://pac.xxxxxx.net/.

The PAC (Proxy Auto Config) file defines the way bowsers use the proxy. I just clicked the link and it prompts to save the file. I saved it and opened with notepad and hurrey got the proxy details with port number. Below is the complete code to be used in the Button Click event. Once clicked, the xml file will be posted and the response (xml in my case) would be shown in a text box.

string username = "username";
string password = "Password";

HttpWebRequest req = null;
HttpWebResponse res = null;

const string url = "https://myTestLink";
req = (HttpWebRequest)WebRequest.Create(url);
String encoded = System.Convert.ToBase64String(Encoding.Default.GetBytes(username + ":" + password));
req.Headers.Add("Authorization", "Basic " + encoded);
req.Method = "POST";
req.ContentType = "application/xml; charset=utf-8";
req.Timeout = 30000;

req.Headers.Add("SOAPAction", url);

// proxy details
req.Proxy = new WebProxy("proxy.xxx.com", 8080);
req.KeepAlive = true;

var xmlDoc = new XmlDocument { XmlResolver = null };
xmlDoc.Load(@"C:\Users\test\Desktop\myTest.xml");
string sXml = xmlDoc.InnerXml;

req.ContentLength = sXml.Length;

var sw = new StreamWriter(req.GetRequestStream());
sw.Write(sXml);
sw.Close();

res = (HttpWebResponse)req.GetResponse();
Stream responseStream = res.GetResponseStream();
var streamReader = new StreamReader(responseStream);

//Read the response into an xml document
var soapResonseXmlDocument = new XmlDocument();
soapResonseXmlDocument.LoadXml(streamReader.ReadToEnd());

TextBox1.Text = soapResonseXmlDocument.InnerXml;

Below are the steps to do for securing the connection string.

1. Create a reusable library (.dll). In this way the library file can be used with other SSIS package or .net code.

2. Register it.

3. Refer in SSIS package.

Create a reusable library

 Open a .net class library type project.
 Create a class

  public class EncryptDecrypt
  {
        public string StringToEncrypt { get; set; }
        public string SecretKey { get; set; }
        public string StringToDecrypt { get; set; }
 
        public string GetEncryptedString()
        {
            try
            {

                string strEncryptedString;

                byte[] clearBytes = System.Text.Encoding.Unicode.GetBytes(StringToEncrypt);
                PasswordDeriveBytes pdb = new PasswordDeriveBytes(SecretKey, new byte[] { 0x49, 0x76, 0x61, 0x6e, 0x20, 0x4d, 0x65, 0x64, 0x76, 0x65, 0x64, 0x65, 0x76 });
                byte[] encryptedData = Encrypt(clearBytes, pdb.GetBytes(32), pdb.GetBytes(16));
                strEncryptedString = Convert.ToBase64String(encryptedData);

                return strEncryptedString;

            }
            catch
            {
                throw;
            }
        }

         public string GetDecryptedString()
        {
            try
            {
                string strDecryptedString;

                byte[] cipherBytes = Convert.FromBase64String(StringToDecrypt);
                PasswordDeriveBytes pdb = new PasswordDeriveBytes(SecretKey, new byte[] { 0x49, 0x76, 0x61, 0x6e, 0x20, 0x4d, 0x65, 0x64, 0x76, 0x65, 0x64, 0x65, 0x76 });
                byte[] decryptedData = Decrypt(cipherBytes, pdb.GetBytes(32), pdb.GetBytes(16));
                strDecryptedString = System.Text.Encoding.Unicode.GetString(decryptedData);

                return strDecryptedString;
            }
            catch
            {
                throw;
            }
        }
       private static byte[] Encrypt(byte[] clearText, byte[] Key, byte[] IV)
       {
            MemoryStream ms = new MemoryStream();
            Rijndael alg = Rijndael.Create();
            alg.Key = Key;
            alg.IV = IV;
            CryptoStream cs = new CryptoStream(ms, alg.CreateEncryptor(), CryptoStreamMode.Write);
            cs.Write(clearText, 0, clearText.Length);
            cs.Close();
            byte[] encryptedData = ms.ToArray();
            return encryptedData;
        }

        private static byte[] Decrypt(byte[] cipherData, byte[] Key, byte[] IV)
        {
            MemoryStream ms = new MemoryStream();
            Rijndael alg = Rijndael.Create();
            alg.Key = Key;
            alg.IV = IV;
            CryptoStream cs = new CryptoStream(ms, alg.CreateDecryptor(), CryptoStreamMode.Write);
            cs.Write(cipherData, 0, cipherData.Length);
            cs.Close();
            byte[] decryptedData = ms.ToArray();
            return decryptedData;
        }
 }

Register the .dll file

Please follow the steps mentioned (https://microsoft-ssis.blogspot.com/2011/05/referencing-custom-assembly-inside.html) to sign the dll with strong name key.

Refer in SSIS package

1. Create a variable in SSIS package. This variable should be configured to get data from sql config table at runtime.
2. Don’t config (through properties -> expression) the connection manager to refer this variable for connection string. If we config this way, the connection manager will throw error at runtime as it will get the encrypted string.
3. Place a script task at the beginning of the Control Flow.
4. Once the dll is registered, we can refer that in the script task.
5. Before the main process start, add a script task and refer the .dll file.
6. Create an object of the class and assign the properties with appropriate values.
7. Below is the code to assign the decrypted value to the connection manager.

public void Main()
{
    // TODO: Add your code here

ConnectionManager oCon;
    string strEncryptedConnStr;
    string strDecryptedConnStr;

    EncryptDecrypt ed = new EncryptDecrypt();

    ed.SecretKey = "MySecretkey";

    strEncryptedConnStr = Dts.Variables["User::varTeradataConnStr_str"].Value.ToString();
    ed.StringToDecrypt = strEncryptedConnStr;
    strDecryptedConnStr = ed.GetDecryptedString();

    oCon = Dts.Connections["ADONET_CONN-Teradata"];
    oCon.ConnectionString = strDecryptedConnStr;

    Dts.TaskResult = (int)ScriptResults.Success;
}

In this way (one of the ways which I tried) the connection string can be secured and decrypted at the time of running the SSIS package.

1. By scheduler available in Azure mobile service.

We can execute sql procedures on Azure based on our need (schedule configuration).

1. Create a mobile service.
2. Create a scheduler. Mention the database to be used for this.
3. Configure the scheduler for the frequency.
4. Click on tab Script. The script can be written in java script or .net. The script should have the code to run a proc.

 I used below code to run dbo.ExecuteDataRequest procedure Azure database.

 function Execute_Process_Request() {
      console.log("Executing ExecuteDataRequest...");
      mssql.query('Exec dbo.ExecuteDataRequest',{
         success: function(results){
         console.log("Finished the Process Request job.");
         },
          error: function(err) {
            console.log("error is: " + err);
         }
     });
 }

Find the new user added which will run the scheduler (Under Login folder of Security of Azure db server). Need to grant execute permission to the new user on the database where we need to execute the job.

 Grant Execute to [new user available under security of the database]

If you want to give permission only to execute few objects, we can do so by specifying the objects like Grant Execute on [object name] To [new user] 

2. By creating an sql job on on-premise database server.

We can create a normal sql job on any database server which resides on on-premise. We can execute the procedure with the help of sqlcmd utility.

We can execute the job at remote database server with above sqlcmd utility. If we are using windows identity we can create credential and proxy to execute the job at remote server without providing the user credential in command.

1. The columns should not be NULL as the output is dependent on data. So the Null value should be handled with a default one.
2. Since the functions accepts 2 arguments, the second one we can add all the needed columns and convert the int, numeric / decimal values to char format.
3. We can use HASHBYTES(‘SHA1’,ISNULL(COL1,’NA’) +’|’+ CAST(ISNULL(COL2,0) AS VARCHAR(10))) to differentiate the output value of each row after adding all the columns. EX, R|Andy|Jo and Randy|J|O.
4. The output value depends on case sensitive of the data. Hash value for a is different from A.

1. This is a method of data comparison and we can create a computed column to store this varbinary data.
2. By creating an index on this column we can enhance the performance of data joining of tables with more column join. The data compare performance can be improved.
3. If there is any change to the data of any column the computed column also changes.
4. We can process only the delta data, which will help in performance of data processing.

               The new version of SQL server 2014 comes with various capabilities for OLTP and DW system along with enhancements previous version features.

Performance improvements

• New In-Memory (codenamed  as Hekaton) OLTP built in to core SQL Server database allows to improve performance of database applications.
• Enhanced In-Memory ColumnStore for Data Warehousing – now updatable with even faster query speeds and with greater data compression for more real-time analytics support.
• New buffer pool extension support to non-volatile memory such as solid state drives (SSDs) – Increase performance by extending SQL Server in-memory buffer pool to SSDs for faster paging.
• New Enhanced Query Processing – speeds all SQL Server queries regardless of workload.

Enhanced Availability, Security and Scalability

• Enhanced AlwaysOn – Built upon the significant capabilities introduced with SQL Server 2012, delivers mission critical availability with up to 8 readable secondaries and no downtime during online indexing operations.
• Online Indexing at partition level – this is a good thing as now index rebuilding can be done at a partition level.
• Statistics at the partition level – this will be a huge improvement in performance.

• Increased scale – Continue to benefit from scale for up to 640 logical processors and 4TB of memory in a physical environment and up to 64 virtual processors and 1TB of memory per VM.
• Network Virtualization – Abstracts networking layer so that it you can easily migrate SQL Server from one datacenter to another.
• Storage Virtualization with Storage Spaces – Create pools of storage and storage tiers allowing your hot data to access the premium storage and cold data to access standard storage improving resilience, performance and
  predictability.
• Enhanced Resource Governance – With Resource Governor, SQL Server today helps you with scalability and predictable performance, and in SQL Server 2014, new capabilities allow you to manage IO, in addition to compute and memory to
  provide more predictable performance.

• Enhanced Separation of Duties – Achieve greater compliance with new capabilities for creating role and sub-roles.  For example, a database administrator can now manage the data without seeing sensitive data or personally identifiable information.

Platform for Hybrid Cloud

         SQL Server 2014 creates a strong platform for hybrid cloud where cloud scale can be leveraged to extend the scalability and availability of on-premises database applications as well as reduce costs.

Simplified Cloud Backup and Disaster Recovery

• Backup to Azure Storage – reduce costs and achieve greater data protection by backing up your on-premises database to Azure Storage at an instance level. Optimize backup policy with intelligence built in to SQL Server that monitors and tracks backup usage patterns to provide optimal cloud backup. Backups can be automatic or manual, and in case of an on-premises failure, a backup can be restored to a Windows Azure Virtual Machine.

• Datafile on azure storage - Databases can be easily detached and migrated or moved to different virtual machines (that is, portability). Standby SQL Server virtual machines can be easily used for fast disaster recovery.

Tables

CREATE TABLE [dbo].[orders_mem](

    [O_OrderKey] [int] NOT NULL PRIMARY KEY NONCLUSTERED HASH WITH (BUCKET_COUNT=3000000),

    [O_CustKey] [int] NULL,

    [O_OrderStatus] [varchar](64) NULL,

    [O_TotalPrice] [decimal](13, 2) NULL,

    [O_OrderDate] [datetime] NOT NULL INDEX IX_OrderDate NONCLUSTERED,

    [O_OrderPriority] [varchar](15) NULL,

    [O_Clerk] [varchar](64) NULL,

    [O_ShipPriority] [int] NULL,

    [O_Comment] [varchar](80) NULL

) WITH (MEMORY_OPTIMIZED=ON, DURABILITY = SCHEMA_AND_DATA)

• There are two types of disabilities (SCHEMA_AND_DATA and SCHEMA_ONLY) supported in Heckaton. The first one keeps schema and data even the sql server restarts, where as in second case the schema only is retained when sql server restarts.
• The data are stored as file stream. The object can be found in file stream.
• Here primary key cannot be created on Clustered index as the data is residing in memory where data is stored in hash table with linked list connecting to rows.
• Every memory-optimized table must have at least one index, because it is the indexes that combine all the rows into a single table. We cannot create index which accepts NULL values.
• If we want to create index on varchar column in the table, the column should have windows collation of _BIN2 type (ex COLLATE Latin1_General_100_BIN2).
• Once the table is created in memory, we cannot alter it. We can drop and recreate with new structure.
• The hash indexes works better for equal search and range index works better for queries searched in range value.
• The indexes are not stored and they are recreated when the sql server starts. We cannot create column store index on Heckaton tables.
• The sys.tables need to be quried to find Heckaton objects by using option is_memory_optimized = 1
• These don’t support (n)varchar (max), userdefined datatypes etc.
• We cannot MERGE the target Heckaton tables. The Heckaton tables cannot be populated or joined with cross database tables. Below query will not work.

                                  INSERT INTO dbo.Table1

                                  SELECT * FROM
                                  DB2.dbo.Table2

                          We have to store the table to a temp table before loading to Heckaton table.

Stored Procedures

CREATE PROCEDURE <Proc name>

               <Param list>

With

               native_compilation

               ,schemabinding

               ,execute as owner

AS

BEGIN atomic with(transaction isolation level = snapshot, language = 'english')

               SELECT  <Col name>

               FROM  <table name >

               WHERE <Condition>

END

• The natively complied stored procedures. The stored procedure is compiled to machine code and stored as dll.
• The native compilation hints that it should be compiled to native code.
• Schema binding option restricts the drop of the Heckaton objects.
• Execute as owner to be mentioned as native compiled object cannot resolve the user and permissions.
• Language is provided to provide the format of the timestamp used internally to manage transaction.
• The objects must be two part name i.e. schema name and table name.
• The dmv dm_os_loaded_modules can be queried to find the memory optimized objects loaded. When the server restarts, while querying this dmv, we can get the list of tables but procedures will not be listed until they are recompiled (executed). This behavior is to speed up the database recovery.
• Below features are not supported as of now.
  • Distinct
  • SET option like NOCOUNT
  • Creation of temp table (# or table variables as they are stored in tempdb)
  • Common Table Expression
  • Ranking functions
  • Subqueries, Exists
  • Combining result sets by UNION (ALL)
  • The GROUP BY should have the aggregated function used as part of SELECT statement.

                                             SELECT name

                                             FROM dbo.Table1

                                             GROUP BY name

                                 The above will work but not inside the proc. We need to add aggregate function in SELECT statement in order to work inside the proc.

                                             SELECT name, COUNT(id)

                                             FROM dbo.Table1

                                             GROUP BY name

References

               https://msdn.microsoft.com/en-us/library/bb500435(v=sql.120).aspx

               https://msdn.microsoft.com/en-us/library/dn606154(v=sql.120).aspx

               https://blogs.technet.com/b/dataplatforminsider/archive/2014/03/18/sql-server-2014-releases-april-1.aspx

               https://www.brentozar.com/archive/2013/06/new-dmvs-in-sql-server-2014-ctp1/

               Before going for the deployment plan, we assume the database is created in SQL Azure database server.  In case of hybrid model where we have both on-premise and azure databases, we can create a data-sync agent and group to sync the databases. The syncAgent need to be created to define the on-premise database where as the sync group will define the Azure database details (the tables and columns to be synced, the frequency, whether source or target updates be considered as final etc).

A table must have clustered index to store data in Azure, but to sync data the table must have Primary key column defined. If a table is having a clustered index while creating and later Primary key is defined on same clustered key column, a unique, non clustered index will be created.

Please install the below executables for SQL Server 2012 in order to do setup for data-sync agent.

               SharedManagementObjects, SQLSysClrTypes - x86 and SQLDataSyncAgent-Preview-ENU.

     Data-Sync installation Links

           https://msdn.microsoft.com/en-us/library/jj823137.aspx

            https://msdn.microsoft.com/en-us/library/windowsazure/jj823138.aspx (Select Install Instruction collapsible button and choose X86 options for the miss)

     The sync agent can be scheduled to do updates based on desired interval.

We can run SSIS package in on-premise database server to do data sync with azure database. Based on the number and size of tables we can decide whether to go for data sync or run SSIS package (any other Azure supported ETL tool can also be considered). Since it depends on the data transfer over network (separate charge for data transfer on azure), we need to plan accordingly.

               When we need to delete the sync agent, it will not allow us to do that i.e. an exception will be raised as the agent is referenced with other object. In order to delete the agent, we need to stop the on-premise database service and unregister the key reference in data sync tool and delete the agent in Azure portal.

Database deployment

The scripts can be deployed to Azure by the help of data tier application file (.dacpac). There are various ways to create .dacpac files. Refer the link https://pietervanhove.azurewebsites.net/?p=1011 to create file.

Here we will discuss the deployment in two ways.

Through SSMS

               Open the SSMS and right click on the database which needs to be deployed to azure. Select appropriate menu options from tasks. The Export option will generate the schema along with data of the tables. The Extract option will generate the schema only. The Deploy option will do the deployment on Azure.

               Select appropriate files and do the deployment.

In Azure portal also we can generate the scripts for deployment. It will prompt for the location to save the dacpac file when user selects the Extract option. The user can slect the on-premise dacpac file to do deployment by selecting Deploy option.

By the command prompt window

               We can use the SQLPackage (https://msdn.microsoft.com/en-us/library/hh550080(v=vs.103).aspx) to do the deployment.

Export from the source database - bacpac file creation (to Export schema and data) - The operation will fail if any table exists without Clustered index.

C:\Program Files (x86)\Microsoft SQL Server\110\DAC\bin>SqlPackage.exe /a:Export /ssn:prasantnanda-2k  /sdn:MyTestDB /tf:c:/prasant/MyTestDBBP.bacpac

Import on target server (Azure)

C:\Program Files (x86)\Microsoft SQL Server\110\DAC\bin>SqlPackage.exe /a:Import /SourceFile:c:/prasant/MyTestDBBP.bacpac /tsn:ihq656uayo.database.windows.net,1433 

/tdn:SampleSchoo /tu:prasant.nanda /tp:msxxxxxx45

 In this way we can migrate a brand new database on Azure.

dacpac file creation (to Extract schema)

C:\Program Files (x86)\Microsoft SQL Server\110\DAC\bin>SqlPackage.exe /a:Extract /ssn:prasantnanda-2k  /sdn:MyTestDB /tf:c:/prasant/MyTestDBDP.dacpac

dacpac deployment (to Publish diff schema)

C:\Program Files (x86)\Microsoft SQL Server\110\DAC\bin>SqlPackage.exe /a:Publish /SourceFile:c:/prasant/MyTestDBBP.dacpac /tsn:ihq656uayo.database.windows.net,1433 

/tdn:SampleSchoo /tu:prasant.nanda /tp:msxxxxxx45 /p:AllowIncompatiblePlatform=TRUE

If we don't provide parameter /p:AllowIncompatiblePlatform=TRUE, it will throw error for platform incompatibility. The target platform as Azure can be provided while creating dacpac (option is available in SSDT i.e. project target platform).

We will be notified with errors while deploying a dacpac if there are any scripts available with SQL Azure unsupported features.

If there is a column dropped in the schema, while deploying it will throw error as it suspects some data loss.

In order to go ahead with column dropped as schema change we need to provide the parameter /p:BlockOnPossibleDataLoss=False

If there is an object got deleted from in the source database, the same will not be deleted even after deployment. If we need to delete that we have to use the parameter /p:DropObjectsNotInSource=True.

There are many parameters available in SQLPackage (https://msdn.microsoft.com/en-us/library/hh550080(v=vs.103).aspx )documentation. Please use appropriate parameters for the required action.

The advantage of using the command line way of deployment is, we can create a batch file (to extract and publish database changes) and schedule the batch file run for deployment.

Links for automated database deployment.

https://support.ready-roll.com/customer/portal/articles/759692-setting-up-automated-sql-server-database-deployment
https://www.anujchaudhary.com/2012/08/sqlpackageexe-automating-ssdt-deployment.html

 User Login creation – We have to generate scripts for the required logins from on-premise database server. Each login should be associated with a password as there is no windows login available.

 --===============================================

-- Create SQL Login template for SQLAzure Database

--===============================================

 CREATE LOGIN [myLogin]

       WITH PASSWORD = 'test001chk@sys_12345'

GO 

The password must be minimum 8 characters and should be complex i.e. mix of numeric, special character etc. Below is the script of login create generated in Azure

 USE [master]

GO

 /* For security reasons the login is created disabled and with a random password. */

/****** Object:  Login [myLogin]   Script Date: 13-12-2013 08:47:44 ******/

CREATE LOGIN [myLogin] WITH PASSWORD=N'à¶''°÷‹½Û¾ë•2§ŸÝe ²ëå''û}È枿‚LŽh`', DEFAULT_DATABASE=[master], DEFAULT_LANGUAGE=[us_english], CHECK_EXPIRATION=OFF, CHECK_POLICY=OFF

GO 

ALTER LOGIN [myLogin] DISABLE

GO

DB Object creation – We have to generate scripts in SSMS and that should be executed in Azure db.

Tables – we need to analyze the script as there some features not supported by Azure.

Data Compression is not allowed – If we have specified data compression, we have to remove option.

DATA_COMPRESSION = PAGE is not supported in current version of SQL Azure

Creating object on Filegroup option – We cannot create a table with index on a specified filegroup. We can specify filegroup for table, but not for index

SET ANSI_NULLS ON

GO

SET QUOTED_IDENTIFIER ON

GO

SET ANSI_PADDING ON

GO

CREATE TABLE [dbo].[Customers](

       [CustomerId] [int] IDENTITY(1,1) NOT NULL,

       [CustomerName] [varchar](100) NULL,

       [CustomerBusiness] [varchar](200) NULL,

       [CustomerMSToolsUsage] [varchar](300) NULL,

       [AdditionalInfo] [varchar](300) NULL,

 CONSTRAINT [PK_Customers] PRIMARY KEY CLUSTERED

(  [CustomerId] ASC )WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) -- ON [PRIMARY] is not allowed

) ON [PRIMARY]

GO

SET ANSI_PADDING OFF

GO

Filegroup reference and partitioning scheme  error occurs when we mention the filegroup for index.

Each table should have clustered index. If it is not available, we have to add it before inserting data into table.

StoredProcedure,function, views- The current version of Azure doesn’t support cross database reference.

1. If there is a table hint provided in the query the WITH keyword is mandatory.  Deprecated feature 'Table hint without WITH' is not supported in this version of SQL Server.
2. SYSTEM_USER, DBCC CHECKIDENT, SELECT INTO, SUSER_NAME, NEWSEQUENTIALID are not supported. We canot create object with these.

 In above mentioned approach, we have to analyze each script manually and modify wherever needed. There is another way of generating the script by using a migration tool wizard.

We can use AzureMigrationWizard (codeplex) to automatically generate the scripts automatically with the appropriate syntax for Azure.

 AzureMigrationWizard can be downloaded at https://sqlazuremw.codeplex.com/

Once downloaded the binaries, open the “Dependencies” config file of the tool. Please use the version 11 for sql server 2012.

  
<Dependency>  
<Assembly>Microsoft.SqlServer.Smo, Version=11.0.0.0,
Culture=neutral, PublicKeyToken=89845dcd8080cc91</Assembly>
<Type>Microsoft.SqlServer.Management.Smo.Server</Type>
</Dependency>

Double click on SQLAzureMW application file.  

Below are the changes done in the script by the tool.

DATA_COMPRESSION = PAGE is not supported in current version of SQL Azure

Deprecated feature 'Table hint without WITH'.  Automatically added WITH for you.

Adding clustered index ci_azure_fixup_dbo_Exxxxg on [dbo].[Exxxxg].  You may want to change this index. 

Save the script generated by the tool which can be referred later.

We can also use the Deploy database to Azure option in SSMS. Please refer https://blogs.msdn.com/b/brunoterkaly/archive/2013/09/26/migrating-an-on-premises-sql-server-2012-database-to-windows-azure-sql-database.aspx for details.

1. A cloud based SQL Server database on clustered servers.
2. Servers are load balanced, replicated databases and failure detection. Which provides high availability, scalability and reliability.
3. Each user database is having 3 replicated databases. Before a transaction gets committed, one primary and one secondary replicated database should also be updated.
4. It supports .net framework 3.5 onwards and OData (a WCF data service) interface to transfer data. OLEDB is not supported.
5. Storage account ConnectionStringBuilder for cloud configuration can be used to create a connection string.
6. Federations – It is the way to achieve high scalability and performance through horizontal partitioning (row split) of one or more tables data. It is a database object in database and there can be multiple federations in a database. Each federation has a single key for partitioning data. The database contains the federation database object is known as federation root. Applications connect to federation root.

 Set Up

1. Get a windows Azure subscription. Get the SQL Server service.
2. We can create database either accessing the Azure database server on SSMS or Azure service portal.
3. There are 2 version of sql azure subscriptions web and business editions. In web edition a user can create 1 master and 149 user databases.
4. Only SQL Server login is allowed. The ip address from which the database to be accessed should be configured in firewall. The user can configure the range of ip addresses. The connections are encrypted and
   managed by firewall rules.
5. REST based APIs are used to manage database. These include create, drop database servers and manage firewall rules.

  
  
   If user selects Custom Create option of database create, user has to provide an existing or new server name (user can select the preferred location of the server). 
  
  

Once server is created, we can configure the firewall setting for server access. The ip of the local system (info can be get from ipconfig) may be different from the global ip (https://www.whatismyip.com/).

Once setting are completed, user can access the database. The user has to append the server name while accessing the desired database.

The user can also login to the azure database from SSMS (SQL Server 2008 R2 onwards). While accessing from SSMS, the user needs to provide the SQL authentication and credential like above picture.

How SQL Azure is different from traditional SQL world?