Sunday, January 31, 2021

File systems versus database management systems (DBMS)

Every DBMS book and beginner course out there discusses this subject, but we still see a considerable number of visitors ending up on our site when searching for “difference between a flat file and a database”, “difference between an excel spreadsheet and a database” etc., so we decided to provide a brief explanation here.  

First of all it is very important to clearly distinguish between a database and a database management system as they are nowadays often used interchangeably (albeit inaccurately). A database in the general sense is any structured collection of data – you have a file where you keep business cards you have collected, that is a database of contacts; you have an excel sheet where you record your ebay sales, that is a database of sales; you have a text file where you have stored a list of prospects, that is database. In a more narrow sense that the term database has evolved into, it really means a structured collection of data that has been stored in a computer system in a particular format through one of the database management systems like Oracle, DB2, SQL Server, MySQL, Access etc. A database management system is a software application that facilitates the process of creating and managing electronic databases. So remember, SQL Server, SQL Azure, Oracle, DB2 etc. are not databases but rather database management systems (dbms)

So, what do we need a database management system for? Isn’t what the file system that the Operating System provides sufficient for our data storage and administration needs? Consider the following oversimplified requirements – your team has been tasked with building a computer system that will collect and administer data on the employees of the company, products and services the company sells, vendors that supply the company with products and services, customers, orders and so on. You quickly identify the following high level requirements:

  • the amount of the data that needs to be stored will reach in the hundreds of gigabytes;
  • thousands of employees will need to access the information concurrently;
  • the system must answer any queries submitted by the users quickly and accurately;
  • data changes made by different users must be applied consistently;
  • access to the data (ability to read, update or add) must be selective – certain users have certain rights on certain parts of the data. 

If as a programmer / software engineer all you have at your disposal is the operating system and a programming language you soon start to realize the immensity of the challenge you have in front of you:

  • with hundreds of gigabytes of data that will be stored on let’s say an array of hard drives you need to build a system that manages the transfer of data from those hard drives to main memory and vice versa as needed. You realize that how you organize the data into files is going to make or break the system. 
  • thousands of users sending thousands of queries to your system means you need to foresee as best as possible the types of queries the system will receive and write code that will handle each of those queries;
  • What if there is a crash in the middle of the day when hundreds of users were adding and updating data? What happens to your data? When a user enters a sales order for example your application stores the order information and amongst the other things sends an order to the shipping department and updates inventory levels but the system crashed and your code did not complete executing! The inventory numbers were not updated… Your system must be able to handle such situations and ensures that your data does not turn into “garbage” no matter what happens – easy to say but very hard to do.  
  • What happens if two or more users are trying to update the same data at the same time? Your application needs to handle this and other concurrency related issues and this on itself is no small task.
  • How about the selective access to the data? Simply not giving the user a way through the interface to access certain data does not provide sufficient security. Separating the data into files based on security needs and using the operating system security mechanisms sounds good but you will soon discover that such separation is not realistic as it would make every other task your system needs to handle much more difficult. 

Can your team handle all those challenges? Of course it can but at what cost? How long will it take your team to build a stable system that can handle those challenging requirements? 

That is where a database management system (DBMS) comes into play. Companies like Oracle, IBM, Microsoft and others have made billions upon billions of dollars selling their DBMS systems (respectively Oracle, DB2, SQL Server) that at the core are software applications designed to handle all those challenges mentioned above and a lot more.  

A DBMS provides an awesome abstraction layer that saves you a tremendous amount of trouble and effort.

Synchronize database schemas - SQL Compare SDK

Comparing and synchronizing the schemas of two SQL Server databases is very easy with xSQL Software's SQL Schema Compare SDK. As you can see in the code snippet in the image below, there are only 5 simple steps involved in making the schema of database A the same as the schema of database B: 

  1. Read the schemas of both databases
  2. Pair objects based on the object name
  3. Compare the paired objects to each other
  4. Generate the synchronization script
  5. Execute the script on the target
Of course, as we have mentioned in other articles, SQL Compare SDK gives you complete control over the database compare operation allowing you to:
  1. exclude or include certain types of objects - for example, if you do not want to compare database users you can do comparer.Options.CompareUsers = false
  2. create entity filters to exclude for example only stored procedures the name of which starts with sp_PS
  3. exclude / include specific objects, for example don't compare table "employees"
  4. set comparison options and scripting options based on your specific requirements 
  5. set execution options such as transaction size, whether to continue execution on error etc. 

Download the SQL Schema Compare SDK and check out the extensive documentation - you will be able to build your first database comparison and synchronization application in no time. 

Saturday, January 30, 2021

Database Documenter - what is it good for?

When they hear the words database documentation or Database Documenter many software developers and database administrators think "boring", "annoying", "useless", and "outdated before generated". 

What if you could get a tool that makes documenting the database and keeping the documentation up to date, quick and easy, allowing you to completely automate the process? What if the documentation that that tool generates is so useful that you would keep it pinned on your desktop and use it as a reference every time you need to do something with the database? 

Yes, xSQL Software's Database Documenter is exactly that tool which allows you to do all the above with ease, generating extremely useful HTML and/or CHM documentation that makes it very easy and convenient to understand the database structure, to see the object dependency graphs, to quickly find exactly what you may be looking for. Here's a screen shot showing the Employees table: 

Our Database Documenter supports SQL Server, SQL Azure, Oracle, DB2, MySQL, Sybase ASE, Informix IDS, SQLite, Teradata, VistaDB, ENEA Polyhedra, Raima RDM. Download and try the Documenter today. 

Friday, January 29, 2021

Software developers and SQL Schema Compare

Any software developer who has worked with SQL Server (or any database for that matter) has at some point had to deal with the challenge of propagating the database changes from the development database to the QA/staging database, to the production database. The process is always the same, you start your "application enhancement" project with a clear vision of the outcome, you potentially identify the database objects, tables, views, stored procedures, triggers, functions etc. that you may have to tweak, completely revamp, or write from scratch.

As you move along new changes and additions to the database structure (aka database schema) become necessary - you keep making those changes to the database and depending on your type (from highly organized to totally messy), experience (from decades of experience to a rookie programmer) etc. how you handle those changes may vary from the "meticulously document everything" approach to the "I will remember those changes I am making" approach. 

While the "document everything" approach is commendable it does unfortunately come with a hefty price tag - a lot of extra hours will be spent on that documentation and to make matters worse no intelligent programmer who gets the adrenaline rush from coming up with ingenious approaches to handling technical challenges enjoys dealing with documentation. 

On the other hand, the "I will remember" approach is not only non-commendable but, depending on the complexity and sensitivity of the project it may at times be disastrous - otherwise genius programmers pulling their hair trying to figure out why the application is working on their development environment but is going haywire on the production, operations people going nuts over the malfunctioning of the system, etc. 

So what is an intelligent software programmer to do? 

Fortunately, there is no need to choose between bad and worst, there is no need to spend all those hours documenting everything (don't take this wrong, any good programmer will always take the time to provide sufficient documentation to allow a comparably intelligent human to understand why something was done, who did it and when), nor is there a need to remember what changes you are making. xSQL Software's SQL Schema Compare, allows the user to compare two databases and clearly identify all the changes that have been made on the structure (aka schema) of one database versus the other. But wait, it goes way further than that - it allows the user to generate a safe change script that will apply (transfer) all those changes to the destination database in a single click.

Now that's efficiency, something that would otherwise take hours to do you can handle with SQL Schema Compare in minutes, and you can easily archive the detailed documentation of all the changes you made to the database. Not only is that commendable, but it feels great too, you are doing an outstanding job without having to waste a minute on it. 

Here is where things get even better SQL Schema Compare is completely free, no strings attached, for SQL Server Express edition (aka SQL Express). Download it now and try for yourself. 

Create database from schema snapshot - SQL Compare SDK

 As we explained in a previous post here, you can easily take schema snapshots using xSQL Software's SQL Compare SDK, and you can commit those schema snapshots into a source control repository to utilize for your database change control process, maintain an audit trail of database schema changes etc. In this post we will show how easy it is to create the database from a previously saved schema snapshot: 

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using xSQL.Schema.Core;
using xSQL.Schema.SqlServer;
using xSQL.SchemaCompare.SqlServer;

namespace xSQL.Sdk.SchemaCompare.Examples
    class DatabaseSnapshot
        /// <summary>
        /// Creates the AdventureWorks database from a snapshot file.
        /// </summary>
        public static void CreateDatabaseFromSnapshot()
            SqlDatabase database;
                //--create the database from the snapshot file

            catch (Exception ex)

Download SQL Compare SDK now and try for yourself. 

Thursday, January 28, 2021

SQL Compare bundle - one click comparison

Both of the SQL Compare bundle tools, Schema Compare and Data Compare provide a very simple and intuitive interface that allows you to reduce the operation of comparing the schemas of two databases or the data contained in them, into a single click

Obviously, the first time you compare two databases, depending on the scenario, you may need to go through a few steps to:

  • choose the object types you may wish to include or exclude from the comparison
  • select the comparison options if the default options do not satisfy the requirements of your use-case
  • select scripting options
  • maybe set some object filters in the case of Schema Compare
  • select comparison keys in the case of Data Compare when the tables you are comparing do not have a primary key defined or a unique index
  • maybe set row filters in the case of Data Compare. 
However, once you have customized your comparison to meet your specific requirements, every selection you have made is saved into a comparison session which you can then run with just one click. 

SQL Compare SDK - schema snapshots with 2 lines of code

Using xSQL Software's SQL Compare SDK you can take snapshots of your database schema with just 2 lines of code - well, as you will see below, technically, there are a few extra lines of code needed to set things up, but you are only calling 2 methods, ReadSchema() and SaveToSnapshot():

using xSQL.Schema.Core;
using xSQL.Schema.SqlServer;
using xSQL.SchemaCompare.SqlServer;

namespace xSQL.Sdk.SchemaCompare.Examples
    class DatabaseSnapshot
        /// <summary>
        /// Creates a snapshot for the AdventureWorks database
        /// </summary>
        public static void CreateSnapshot()
            SqlServer server;
            SqlDatabase database;
                //--create the SQL Server object, connect using Windows authentication
                server = new SqlServer(@"(local)");

                //--create the database object
                database = server.GetDatabase("AdventureWorks");

                //--attach an event handler to SchemaOperation event in order to get progress information during the schema read
                database.SchemaOperation += new EventHandler<SchemaOperationEventArgs>(database_SchemaOperation);

                //--attach an handler to SnapshotOperation event to get snapshot feedback
                database.SnapshotOperation += new EventHandler<SnapshotOperationEventArgs>(database_SnapshotOperation);

                //--read the database schema

                //--create the snapshot
                database.SaveToSnapshot(Path.Combine(@"C:\", database.GetDefaultSnapshotFilename()));
            catch (Exception ex)

        private static void database_SchemaOperation(object sender, SchemaOperationEventArgs e)
            //--exclude verbose messages
            if (e.Message.MessageType != OperationMessageTypeEnum.Verbose)

        private static void database_SnapshotOperation(object sender, SnapshotOperationEventArgs e)
            //--exclude verbose messages
            if (e.Message.MessageType != OperationMessageTypeEnum.Verbose)

Download the SQL Compare SDK now and try for yourself. 

Wednesday, January 27, 2021

Oracle Schema Compare - why are identical objects showing as different

When it comes to comparing two database objects the question whether the two objects are equal or not has a somewhat complicated answer, that is, it depends! The answer depends on what exactly are you comparing those objects on. For example, is "Equal" equal to "equal"? Well, that depends on whether the the character case is relevant to you in that use-case that prompted the comparison in the first place. 

xSQL Software's Oracle Schema Compare tool offers 31 standard comparison options like "ignore the name of the primary key", "ignore the name of the unique constraints", "ignore the name of the check constraints", "compare xml storage", "compare the schema of a synonym based object" etc., and 19 advanced comparison options like "compare the pct. free of a storage clause", "compare the return type of nested table", "compare the segment name of a LOB", etc. Screen shots below show part of those lists that affect the object is "equal or not" decision. Our developers have carefully considered the "default" settings with the aim of minimizing the need for the user to tinker with those options however, every case is different and our Oracle Schema Compare puts you in charge - you can tweak the behavior of the comparison engine as you see fit. 

So, when using Oracle Schema Compare you see that two object are found to be different by the comparison engine while you believe they should be equal, or they are found to be equal while you believe they should be different don't panic - investigate the differences and carefully review the comparison options - more likely than not one of those options holds the answer to your surprise.

Please note that some of the options listed on the advanced tab may be unknown to you depending on the level of familiarity with Oracle and it would have been helpful to provide a description for each. However, due to space and other restrictions, instead of us providing an incomplete and insufficient description that attempts to summarize information already available in the Oracle documentation we selected to omit those descriptions and let you consult the source directly when necessary.

Download Oracle Schema Compare now and see for yourself why it's hands down the best comparison tool our there. 

Tuesday, January 26, 2021

Oracle Schema Compare - Entity Filters

When comparing the schemas of two Oracle databases users of xSQL Software's Oracle Schema Compare tool, generally don't have to worry about any specific settings or options that the tool offers, they just add the databases to the workspace, compare them, generate synchronization script and execute the script on the target. However, in some case your schemas may be complex or very complex containing thousands of object like tables, views, functions, procedures etc. - in those cases, instead of a few seconds the comparison operation may take much longer. Furthermore, often you know that certain objects never change and do not need to be compared so excluding those from the comparison could be very helpful. That's where the entity filters come in. Entity filters allow you to exclude schema objects based on some predefined criteria. You could exclude, for example, tables whose name starts with TEST_, views ending with "_TEMP", procedures by name, function using regular expressions and more.

Oracle Schema Compare allows you to creates filters for specific object types, such as tables, views, procedures. A filter is a set of name-selecting criteria, combined with the OR/AND operator. If you wish to exclude, for example, all tables whose name starts with DEV_ or TEST_, you could create the following filter (notice the OR operator):

   Table filter: name starting with "DEV_" OR name starting with "TEST_"

If you wish to exclude all but two views, whose name are V_EMPLOYEES and V_JOBS, the filter would be as follows (notice the AND operator):

   View filter: name != "V_EMPLOYEES" AND name != V_JOBS

To create an entity filter:

  • Launch the Entity Filters from the Ribbon link, the Comparison Form context menu, or via the Entity Filters button in the schema selection form.
  • Select the object type, for which the filter is intended, such as Tables or Views.
  • Click on the "(new...)" link and create the filter criteria. Add as many criteria as you need
  • To change the criteria operator, from OR to AND or vice versa, simply click on one operator.
Download Oracle Schema Compare now - it comes with a 3 week fully functional trial. 

Oracle Schema Compare - supported objects

xSQL Software's Oracle Schema Compare tool supports the majority of the Oracle object types, such as: tables (relational tables, object tables and xml tables); views (standard views, object views and xml views); functions; procedures; packages; synonyms; sequences; object types; collection types; triggers on tables, views or schema; primary keys on tables or views; unique constraints on tables or views; check constraints; foreign keys on tables or views, indexes on tables or clusters; xml indexes; spatial indexes; domain indexes. 

By default, all object types are included in the comparison and synchronization process, but the user can choose to include or exclude certain object types depending on the use-case. However, the user should be aware that excluding objects of a given type may cause the synchronization script to fail due to missing dependencies. 

Download a free fully functional 3-week trial now and try for yourself. Oracle Schema Compare supports Oracle Schemas from 10g up to 19c. 

Questions, comments and suggestions on how to improve our Oracle Schema Compare are greatly appreciated. 

Monday, January 25, 2021

Database deployment made easy with xSQL Builder

If you are a software publisher and your software utilizes a SQL Server database on the back-end you have most likely faced the daunting task of pushing schema changes down to your customers. A lot of publishers will ship a "database upgrade" script as part of the software upgrade, but successfully executing that script on the target machine is very challenging for most customers. That is where our Builder for SQL Server comes in - it was designed exactly for that purpose. Here is how it works:

  • in a few easy steps you create an executable package that includes a schema snapshot of the "reference" version, that is the version you wish to push down to your customers
  • you may also include custom pre and post synchronization scripts for certain customers
  • you ship the self-contained executable to the customer
  • when the customer executes it all it needs to provide is the target database and the necessary credentials
  • the executable will compare the reference schema with the target, generate the sync script and execute the script on the target 
  • it will also send a notification back to you reporting whether the upgrade was successful or not and if not you will receive additional info on the cause of failure. 
Download now and see how easy it is. Let us know what you think - your feedback is what guides us as we work to make the products better for you. 

How to run a trace on SQL Server Express

Using xSQL Software's Profiler for SQL Server you can run traces on any SQL Server edition including MSDE and SQL Server Express starting from SQL Server 2000 and later. Here are some of the highlights:

  • No need to install any agents on the target machines
  • Trace multiple SQL Server instances at once
  • Collect all traces into one central repository
  • Advanced scheduling allows you to automate the process of collecting the critical data you need
  • Precise event filtering (from simple criteria, such as equal or like operators, to complex regular expressions) to minimize the burden on the participating SQL Servers. Just the data you want, no more, no less.
  • Built-in user defined events
The flexibility of the Profiler makes it an ideal tool for discovering SQL Server performance bottlenecks, conducting database auditing and compliance with regulations such as Sarbanes-Oxley, HIPAA, GLBA, etc. 

Download now and try for yourself. xSQL Profiler is free for 1 SQL Server Express instance. 

Saturday, January 23, 2021

SQL Compare SDK

 Our SQL Compare SDK allows any software developer to integrate SQL Server database schema comparison and synchronization functionality into any application with minimal effort. Here are some of the highlights:

  • Supports all SQL Server editions from SQL Server 2005 to SQL Server 2019
  • Supports latest version of SQL Azure
  • It's fast, responsive and has a very small footprint
  • In addition of comparing and synchronizing you can script any individual objects and take snapshots of the whole schema
  • Intuitive object model designed with the developers in mind
  • No external dependencies, very easy to deploy
So, what exactly can you use our SQL Compare SDK for? Two of the most common use cases:
  • Software developers/publishers who are periodically having to push database changes down to their customers.
  • Database administrators / software developers who are building a customized database version control system.
Check out the comprehensive online documentation and download the SQL Compare SDK today to get started. 

Friday, January 22, 2021

SQL Comparison Bundle review from 13 years ago

13 years ago, in 2007, when we were on version 2 of our SQL Comparison Bundle, the reviewer wrote: "It's frankly hard to write reviews that are for products that just flat out work right." - read the full review here: sswug-review.pdf ( 9 versions and 13 years later our SQL Schema Compare (previously known as xSQL Object) and our SQL Data Compare continue to work right and are loved by thousands of users on every corner of the globe. 

You can download the current version of our SQL Comparison Bundle here. We made it free for SQL Server Express in 2007 and we continue to distribute it for free now. 

SQL Comparison Bundle - simply the best comparison tools

SQL Comparison Bundle includes both the SQL Server Schema Compare tool and the SQL Server Data Compare tool that are two of the best SQL Compare tools you can find regardless of what criteria you may be using for evaluation. Here's what really matters and demonstrates the superiority of the SQL Comparison Bundle:
  • Performance: what we like to say is "dare to compare" - both tools included in the SQL Comparison Bundle, the Schema Compare and Data Compare have been crafted with extreme care to deliver the best possible performance in most scenarios. Resource consumption is carefully managed and every optimization opportunity is utilized. 
  • Reliability: the tools included in the SQL Comparison Bundle have been in production for over 15 years and thousands of users rely on them - they simply work. 
  • Interface: whether you are using the GUI or the included command line utilities the tools included in the SQL Comparison Bundle, in the words of our users, are simply a joy and deserve one of the biggest compliments a user can bestow on a software "user manuals are not needed". 
  • Cost: how does FREE sound? Both tools included in the SQL Comparison Bundle are completely free for SQL Server Express, no restrictions, no limitations, just our humble contribution to the SQL Server community. 

Thursday, January 21, 2021

SQL version control - schema snapshots

Database version control is one of the most critical tasks in ensuring the safety and reliability of the software development process and the operation of data-driven applications. Every code deployment coincides with a particular state of the database supporting it - the code and the database must be in sync. If you roll your application back to a point in time you may also have to roll back the database schema changes or your application may become unstable or non-functional. 

Many database administrators and developers commit the database change script or the whole database create script in the repository together with the application code, and that serves the purpose, but it's far from being efficient or convenient. Our SQL Schema Compare tool offers a better way, schema snapshots

A schema snapshot in this context is a small encrypted file that contains 100% of the database schema information in it. You can manually take schema snapshots of a given database any time you decide to through the SQL Schema Compare GUI or, you can use the included schema compare Command Line utility to automate the process and take snapshots on a schedule. Furthermore you can automate the decision on whether you need to store the snapshot in the repository or not by comparing the current snapshot with the previous one: if there are no changes you can discard the new snapshot otherwise you commit it to repository. 

Utilizing schema snapshots you can then do any of the following:

  • Create a copy of the database (schema only). To do that, you create a blank database, then compare the desired source snapshot with the blank database and generate the "sync" script which will make the blank database exactly the same as the database from which the snapshot was taken. 
  • Compare any two snapshots to each other to generate the changes that have occurred in the time period between the two snapshots. 
  • Compare a snapshot directly to a live database and generate synchronization script to revert the database back to the state it was when the snapshot was taken. 

Wednesday, January 20, 2021

Free SQL Server tools

Our product offering includes 6 awesome tools that are free, you don't have to pay a dime for:
  • SQL Schema Compare - allows you to compare and synchronize the schemas of any 2 SQL Server Express databases, no expiration, no limitation and no external dependencies other than .NET framework. Supports from SQL Server 2005 to SQL Server 2019. One of the best schema compare tools you will find in the market. Cost: FREE
  • SQL Data Compare - allows you to compare and synchronize the data between any 2 SQL Server Express databases, no expiration, no limitation and no external dependencies. Cost: FREE
  • Documenter - document any database for free. The only catch is that the documentation will include a "this is an unlicensed version" text throughout the documentation - a bit of inconvenience but does not limit the functionality.
  • Script Executor  - build script execution packages with constraints and conditional branching and run them interactively, via the command line, or deploy them as executable packages. FREE for personal use only. 
  • SQL Search - you can run it as a stand-alone application or you can add it as an add-in to SQL Server Management Studio. No restrictions, no expiration. Cost: FREE 
  • xSQL Profiler - Tracing, monitoring and event collection of multiple SQL Server instances from one location FREE for one SQL Server Express instance.

SQL Server versions

Here's the list of SQL Server versions from SQL Server 2000 to SQL Server 2019:
  • SQL Server 2019 -> v 15.0.x (October 2020 CU v 15.0.4073.23)
  • SQL Server 2017 -> v 14.0.x (September 2020 CU v 14.0.3356.20)
  • SQL Server 2016 -> v 13.0.x
  • SQL Server 2014 -> v 12.0.x
  • SQL Server 2012 -> v 11.0.x
  • SQL Server 2008 R2 -> v 10.50.x
  • SQL Server 2008 -> v 10.0.x
  • SQL Server 2005 -> v 9.0.x
  • SQL Server 2000 -> v 8.0.x
If you want to see what version you are using just run SELECT @@VERSION;

DATETIME vs DATETIME2 - 5 reasons why DATETIME2 is better

Recommendation first: if you are not sure whether to choose Datetime or Datetime2 the answer is choose Datetime2. Why?
  1. Higher precision – up to 7 fractional digits for datetime2 vs 3 for datetime 
  2. Higher level of accuracy – datetime rounds the last digit to an increment of .000, .003 or .007 whereas datetime2 supports accuracy of 100 nanoseconds 
  3. Wider range of values – datetime2 supports dated from 0001-01-01 00:00:00 to 9999-12-31 23:59:59.9999999 whereas datetime supports dates from 1753-01-01 00:00:00 to 9999-12-31 23:59:59.997 
  4. Space requirements – depending on the fractional precision you require datetime2 needs from 6 Bytes to 8 bytes of space whereas datetime requires 8 bytes 
  5. Compliance with standards: datetime2 is compliant with both ANSI and ISO 8601 whereas datetime is not.
For a more in depth review of those reasons you can check our other post here.

SQL Server Editions

SQL Server comes in a variety of editions each of which targets different audiences based on performance, runtime and price requirements. Here is a quick summary of the editions currently available for SQL Server 2019:

Express: SQL Server Express edition is free and it's one of the best choices for small software vendors, developers, and hobbyists learning and building data-driven client applications. There's also a lightweight version of Express called LocalDB which runs in user mode and is installed quickly without having to configure anything. SQL Server Express does have some limitations but it can be seamlessly upgraded (except for the money you need to pay) to higher end versions. Some of the limitations you should be aware of: 

  • max compute for a single instance is 1 socket or 4 cores
  • max memory buffer pool is 1,410 MB
  • max DB size is 10 GB
  • does not support most of the high availability features like log shipping, fast recovery etc.
  • only supports subscriber replication
  • SQL Profiler and SQL Server Agent are not available
Developer: SQL Server Developer edition is the best choice for hard-core developers as it includes all the functionality that the highest edition (Enterprise) includes so you can build and test any kind of application. However, this edition is restricted for development and testing only - it can not be used in production, therefore, as a developer you must consider the costs involved when deciding to utilize certain functionality that may only be available in the expensive Enterprise edition. 

Web: SQL Server Web edition targets Web hosts and Web VAPs aiming to lower the total cost of ownership. Limitations include:
  • max compute 4 sockets or 16 cores
  • max memory for buffer pool 64GB
  • missing some high availability features like backup compression, fast recovery etc.
  • missing some scalability features like resource governor, partitioned table parallelism etc.
  • No encryption for backups
  • Subscriber only merge replication
Standard: SQL Server Standard edition targets departments within large organizations and small organizations delivering basic data management and business intelligence.  Limitations include:

  • max compute 4 sockets or 24 cores
  • max memory for buffer pool 128 GB
  • missing some high availability features like mirrored backups, fast recovery etc.
  • missing some scalability features like resource governor, partitioned table parallelism etc.
Enterprise: SQL Server Enterprise edition is the ultimate edition that includes everything Microsoft has got to offer, it provides high availability, scalability, end-to-end business intelligence, fast performance, unlimited virtualization etc. The only limits on scalability are those dictated by the OS limits and the max relational database size being 524 PB

Tuesday, January 19, 2021

SQL Search tool for SQL Server is free for all

 Our SQL Search tool for SQL Server is free with no restrictions and:

  • you can run it as a stand-alone or as an add-in to SQL Server Management Studio;
  • it supports both SQL Server and SQL Azure;
  • it allows you to conduct a simple search using "like" or "exact" search criteria, an advanced search using SQL Server expressions, that combines multiple terms with the "and", "or" and other SQL operators, or a very complex search using regular expressions;
  • it allows you to search in multiple databases at once;
  • you can search not only the regular database objects but also SQL Server jobs including job steps and statements executed on each step.
Download now and check it out. Let us know how we can make it even better, we would greatly appreciate it. 

Oracle Data Compare v5 available

Our Oracle Data Compare tool is getting better with every new build we release. Version 5 now supports all Oracle versions from Oracle 9i  all the way up to Oracle 19c. Three week fully functional trial, custom mappings, custom comparison keys, command line utility for automating the data compare and synchronization process, one-click compare and a lot more. 

Download now and see what you have been missing. 

Monday, January 18, 2021

Oracle Schema Compare V5 now available

Version 5 of xSQL's Schema Compare tool for Oracle that provides for comparing and synchronizing objects in Oracle schemas is available for download from our website. The new version supports all Oracle versions, from Oracle 10g up to Oracle 19c and comes with a 3 week fully functional trial. 

Some of the new features include:

  • Exposes over 100 options for fine-tuning the comparison operations
  • A storage and management of the comparison sessions allows for fast, one-click compare
  • Schema filters can exclude Oracle objects based on complex rules
  • Proprietary snapshots, that store Oracle schemas in files, allows for schema archiving or offline comparison
  • Extensive logging provides operational, execution or error details when needed
  • A target-specific synchronization script, combined with a synchronization log, captures all schema changes quickly and accurately
  • A command line utility allows for unattended or scheduled comparisons
  • A step-by-step wizard simplifies the management of the command line config files
Schema Compare for Oracle runs on Windows operating systems, client and server, that have the .NET framework 4.6 or higher installed.