我正在使用SQL Server,我很难想从我想要的SELECT查询中获取结果.我尝试加入不同的订单和使用子查询,但没有什么是我想要的方式.拿这个具有不同版本级别的软件应用程序的例子,可能安装在人民币计算机上.

我需要执行一个附加的地方,但由于某种原因,我无法得到我想要的结果.

也许我正在看我的数据错误,我不太确定为什么我不能让这个工作.

申请表

软件表(包含不同应用程序的版本信息)

软件计算机连接表

电脑桌

我想要一个查询,我可以运行我选择一个特定的计算机来显示什么软件版本和应用程序,但我也希望它显示什么应用程序它没有(版本将是一个空的,因为它没有那个软件就可以了)

我想要以下结果集

但我只是得到

我认为RIGHT JOIN将包括应用程序表中的所有结果,即使它们与计算机无关.我缺少/做错了什么？

使用LEFT JOIN或RIGHT JOIN时,无论您将滤镜放在“WHERE”还是“JOIN”中,都有所不同.

看到这个答案我刚才写的一个类似的问题：

简而言之：

>如果把它放入WHERE子句(就像你所做的那样),与该计算机无关的结果被完全过滤掉

>如果你把它放在JOIN中,那么与查询结果不相关的结果就出现在查询结果中,只有NULL值

>这是你想要的

http://stackoverflow.com/questions/8758223/sql-server-multiple-table-joins-with-a-where-clause

Kevin Feasel

2017-11-15

SQL Server Data Tools

Kevin Feasel

2017-04-26

Deployment , Powershell , Source Control , SQL Server Data Tools

版权声明：本文为Buddy Yuan原创文章，未经允许不得转载。原文地址： REDHAT7.4上安装SQL SERVER 2017

今天测试了一下在RedHat7.4上安装SQL Server 2017，整个安装过程并不复杂。以下是安装过程的详细步骤。

1.检查CPU和内存,CPU至少2个核心，内存2GB以上，磁盘空间大于6GB,如图所示：

2.下载Microsoft SQL Server 2017 Red Hat存储库配置文件：

3.运行yum安装sql server

4.运行SQL Server配置脚本（/opt/mssql/bin/mssql-conf)，这里选择安装的版本，因为我们是测试，就选择了Developer版。同时还需要设置SA的密码，密码规则是强密码，需要最少8个字符，包括大写和小写字母、数字和/或非字母数字符号。

5.查看mssql服务的状态，目前是running的。

6.默认SQL Server通过1433端口连接，此时要检查防火墙状态，如果是打开的，需要把1433端口在防火墙上做放开设置，允许连接。或者直接关闭Linux防火墙。我在这里直接关闭了防火墙。

7.接下来需要安装sqlcmd和bcp等客户端工具。和安装服务器一样，首先也要下载配置文件。

接下来如果有旧版的mssql工具，需要删除。

删除完成之后安装新的工具,在安装过程中出现下列的问题：

下列问题主要是因为软件的yum仓库不可用， 百度了办法 修改成了163的centos的yum仓库就可以了。

8.接下来做一些测试连接，先查看用的是否是1434端口

这里没配置好环境变量。先设置一下。

再一次连接，如果成功，就会显示sqlcmd命令提示符：1>

至此整个安装过程结束，参考微软官方文档: https://docs.microsoft.com/zh-cn/sql/linux/quickstart-install-connect-red-hat?view=sql-server-2017

How can I query Active Directory from SQL Server 2005?Pretty general question but here are some pointers. You need a linked server creating on the SQL Server that points to ADSI (Active Directory Service Interface) something like this will do it. EXE

My php/MS Sql Server 2005/win 2003 Application occasionally becomes very unresponsive, the memory/cpu usage does not spike. If i try to open any new connection from sql management studio, then the it just hangs at the open connection dialog box. how

I am looking for viewing the text of the system views and procedures in SQL Server 2005 using the object explorer or using sp_helptext. actually i am coming from the SQL Server 2000 background, where we have the feature of retreiving the code of the

Is there a dependable way to find dependencies among views and tables in SQL Server 2005? sys.sql_dependencies doesn't list all of my dependencies. (I thought I saw a similar thread here but can't find it now. Sorry if this is a dup).You can try thes

Backup SQL Server 2005: View or restore yourself without interfering with the existing database?

I have SQL Server 2005 set up and I backed up a database a year ago, and now need a few views from it. Backup is rather large, 6GB, and the database is up and running 24/7 and I cannot meddle with it, I just need these views. Creating a new database

Background I am working on a legacy small-business automation system (inventory, sales, procurement, etc.) that has a single database hosted by SQL Server 2005 and a bunch of client applications. The main client (used by all users) is an MS Access 20

Ex: for store procedure we use sp_helptext .is there any keyword for viewing jobs in text in sql server 2005 regards kumarFor stuff like this where I know how to do something in Management Studio but aren't sure of the way to do it by code I sometime

How can a Table's Last Modified date be returned in SQL Server 2005? I did see one on the Table Properties page. There is a Created Date but no Modified date. If it is not available, what would be some other ways to add this functionality? Here are a

Is there any option in sql server 2005 management studio to change columns in a table by hand and by the sql commands alter table or insert into. If yes, then could someone please show how or link to some instructions?Sure you can. If you want to ren

I need to keep track of the last login time for each user in our SQL Server 2005 database. I created a trigger like this: CREATE TRIGGER LogonTimeStamp ON ALL SERVER FOR LOGON AS BEGIN IF EXISTS (SELECT * FROM miscdb..user_last_login WHERE user_id =

We have an application built on top of SQL server 2005 that we have no control over. We've recently discovered that this application is sending some very inefficient SELECT queries to SQL that is causing serious capacity issues on the database. I kno

I'm very much new to SQL and struggling to learn, so I'll warn everyone up front my mistakes might very well be the obvious ones - don't assume I know what I'm doing! This is in SQL Server 2005. EDIT: The code below is accidentally misleading; my_tab

How can you do a full outer join in sqlserver 2005? Seems like there is full outer join in sqlserver 2008 but I need to do this in sqlserver 2005. In other words, I am merging two views based on the ACCTNUM col in both views (The views show aggregate

I have a scheduled job with a SP running on daily basis (SQL Server 2005). Recently I frequently encounter deadlock problem for this SP. Here is the error message: Message Executed as user: dbo. Transaction (Process ID 56) was deadlocked on thread |

SSIS has various data flow transformation components that make it easy to manipulate the source data before it can be sent to the destination for processing.

Below are some of the most frequently used one

Data Conversion

For changing the data type of the source column.

Simply select the input column and then specify the data type for it.

For e.g., if our source has one of the date columns as a string, we can apply Data Conversion transformation to convert its data type to Date.

Derived Column

Can be used if we want to apply the expression to the source column and create a new column or update the existing column.

For e.g. we are interested in the Year part of the Modified Date column. For this we can use the Year Date/Time function, get the year part and add it as a new column.

Percentage Sampling and Row Sampling

To reduce the number of rows in the pipeline.

Percentage Samplingallows us to define the percentage of rows for sampling. It generates two output, one output for the rows that are selected and the other for the unselected.

Similarly, Rows Sampling allows us to specify the number of rows directly instead of a percentage. It also gives the option to select the columns.

Multicast

Multicast can be used to pass the same data to multiple destination as shown below.

Lookup Transformation.

Conditional Split Transformation

Sort and Aggregate Transformation

Sort transformation can be used to specify sorting for the data. In the case of SQL, we can specify sort in the query itself however in case of working with flat files, this function can be handy.

To perform aggregation on the source data we can use Aggregation transformation.

Union All

Union All allows us to combine data from multiple sources. Here the column structure should be identical of the sources. The data from the first source is passed to the destination, followed by the data from the second.

We’d covered some of the common transformation components in this post, in the next post we’d try to cover the remaining frequently used transformation.

Hope it helps..

In today’s blog posting I want to talk about Query Memory in SQL Server, and want to show you how fast it can degrade the performance of your queries. Before we dive into the details about how SQL Server is managing Query Memory, I want to talk briefly about what Query Memory actually is.

SQL Server has to allocate Query Memory for various Execution Plans based on their used operators. The following Execution Plan operators need Query Memory:

How much Query Memory is allocated to these operators depends on various factors, like the Estimated Number of Rows, and the Row Size itself. In the worst case, one of the above mentioned operators can spill over to TempDb , and your query performance degrades because of the additional introduced physical TempDb overhead.

The Query Memory that is requested by an Execution Plan (the so-called Query Memory Grant) is taken from Buffer Pool Memory (with a maximum of 75%), and the used Resource Governor Workload Group defines the maximum per each query (up to 25% by default).

The Query Memory itself is a limited resource in SQL Server, and is therefore protected by a so-called Resource Semaphore . A semaphore itself is nothing more like a synchronization object that is used to control the access to a shared resource in our case to the Query Memory. The nice thing about a semaphore is that it can allow the access to the shared resource to multiple threads in parallel. It’s not like a Spinlock that is a simple Mutex: you hold the Spinlock, or not!

In the context of SQL Server multiple queries can request Query Memory through the Resource Semaphores. But when the Query Memory is exhausted (everything is currently in use), queries have to wait until other queries are releasing Query Memory back to SQL Server. Then they can get their Query Memory.

Let’s have now a more detailed look on these Resource Semaphores that SQL Server is using here. In my case I have configured SQL Server with a Maximum Server Memory setting of only 500 MB to make it easy to reproduce some performance problems. Therefore the whole available Query Memory is about 375 MB large 75% of the Buffer Pool Memory. For each Resource Governor Resource Pool you get 2 Resource Semaphores:

You can see and monitor these Resource Semaphores in the DMV sys.dm_exec_query_resource_semaphores . As you can see from the following picture, my SQL Server instance has 4 Resource Semaphores: 2 Resource Semaphores for the default Resource Pool, and 2 Resource Semaphores for the internal Resource Pool.

This DMV exposes you the following important columns for performance troubleshooting:

To make now things a little bit more complicated, each Resource Semaphore also has multiple queues available. And a submitted query which needs some Query Memory has to use the corresponding queue based on the query plan cost factor:

Which Resource Semaphore Queue a query is currently using can be seen through the DMV sys.dm_exec_query_memory_grants . This DMV can also tell you if a query has already successfully allocated Query Memory, or if the query is still waiting on the Query Memory Grant. Let’s have a more detailed look on this DMV. The following picture shows the output from this DMV while I was running a query that has requested some Query Memory.

This DMV exposes you the following important columns for troubleshooting:

The most important column for me here is the column grant_time . If you see here a NULL value for a given query, it means that the query is waiting for Query Memory. In that case the query reports you a wait type RESOURCE_SEMAPHORE , which is more or less very terrible. Because a query can only start when the requested Query Memory was granted to the query! Therefore a wait type RESOURCE_SEMAPHORE means that the query is also not yet started! Just think about that…

With the column queue_id you can also see in which Resource Semaphore Queue the query was put by SQL Server. As I have described above, the query gets put into a queue based on the cost factor of the query plan. A cheap query from an OLTP workload uses a different queue than a very expensive query from a reporting or DWH workload.

And now we are coming to the most important point of this blog posting:

A query which is waiting in a queue can be only executed when ALL lower-cost queues do not contain *any* other waiting queries!!!

And this can lead to serious performance problems. Imagine you have your large DWH query, which is currently waiting in queue_id 9. And in addition you have some recurring small queries from an OLTP workload that are always put into queue_id 5. Your DWH query will wait a very long time until it can be finally executed. I have tried to illustrate that behaviour with the following picture.

Let’s work now with a few different queries to demonstrate this problem. In the first step I have created a simple Stored Procedure in the ContosoRetailDW database that generates a query plan with a cost factor of 295.

Afterwards I have executed this stored procecure with 10 parallel users through the Stress Testing Tool ostress.exe that is part of the RML Utilities . As mentioned before my Maximum Server Memory setting is configured with only 500 MB.

When you run that Stored Procedure with 10 parallel users, you can already see in sys.dm_exec_query_memory_grants that a lot of queries are waiting on outstanding Query Memory Grants: for almost all queries the column grant_time is NULL, and only one query got a Query Memory Grant.

When you concurrently look into sys.dm_exec_requests , you can see that these waiting queries are reporting a wait type RESOURCE_SEMAPHORE back to SQL Server:

As you can see from the output of sys.dm_exec_query_memory_grants the query with a cost factor of around 295 was put into the Resource Semaphore Queue 7. Let’s try to run now concurrently some other queries which are dependent on Query Memory. The following listing shows 2 queries: one query with a cost factor of 2.97, and another one with a cost factor of 3064.

The query with the cost factor of 2.97 is put into the Resource Semaphore Queue 5, and is executed almost immediately. But the query with the cost factor of 3064 is put into the queue 8, and must wait until all lower queues don’t contain any queries anymore. So it must wait a much longer time and reports a longer time the wait type RESOURCE_SEMAPHORE .

How long a query waits for Query Memory depends on its cost factor. By default it waits (in seconds) 25 times of the cost factor with a maximum of 86400 seconds (24 hours). And after that wait time the query is finally executed by SQL Server.

You can override that default query wait behaviour with the instance setting query_wait (s) . The following listing shows how you can change that setting to 20 seconds.

When you have done the required RECONFIGURE , queries are only waiting 20 seconds for a Query Memory Grant. And afterwards SQL Server schedules them for execution, but with a much smaller Query Memory Grant. Therefore the query will spill over to TempDb . And this of course also introduces some physical I/O overhead which leads to a longer query execution time.

Besides the instance setting query_wait (s) , you can also configure the query wait time on the Resource Governor Workload Group through the option request_memory_grant_timeout_sec . The following listing shows how you can accomplish the same thing by changing the Memory Grant Timeout on default Workload Group to 20 seconds.

The outcome is the same: the query waits for a maximum of 20 seconds, and is executed afterwards with a smaller Query Memory Grant…

As you have seem from this blog posting, Query Memory Grants and Resource Semaphores can be really dangerous in SQL Server. It can get really problematic when you have a mixed workload (OLTP and DWH) on the same SQL Server instance. Because then your large DHW queries can be slowed down by your small OLTP queries, when they are dependent on Query Memory Grants.

Therefore I always suggest to make your OLTP queries as simple as possible, and you should make sure that these query plans don’t use operators which are dependent on Query Memory Grants. And this can be accomplished by working on your Indexing Strategy. If you have a good Indexing Strategy in place, there is no need for Sort/Hash operations, and for no parallel Execution Plans. Please keep that in mind.

Thanks for your time,

-Klaus

Last week I invited you to share a story of a project gone mad a death march project that you participated in or were impacted by.

If you haven’t already read the invitation please read it first: T-SQL Tuesday #107 Invitation: Death March

Now let’s see a summary of this month’s submissions!

This month we had 15 post submissions about this daunting topic. Two of the posts were from people who had never posted before. To them I say welcome and I hope you enjoyed the experience.

I think, in general, you were all brave to write about this sensitive topic. I know a lot of you are consultants (which is a great way to expose yourself to a death march project) and must be careful about telling stories that could be misconstrued by clients. Nonetheless, with enough obfuscation and redaction you have brought forth some truly horrifying posts! I am going to group the submissions by the most terrible themes that many posts shared.

Planning a migration is like organizing a hug masquerade ball. Hidden surprises lurk in the chamber rooms of the castle. Read them before the clock strikes midnight when darkness, decay, and the red death hold illimitable dominion over all!

Kevin Chant( blog / post ) joined us in the fray this month for the first time. He tells us about a hardware upgrade / migration project that went south. It was lies and insidious omissions that led them down a dark path. He was told the software was fine…but it was not. They assumed it had been tested…clearly it had not. Slips and oversights like this can add exponentially more time to an already long project. Tread carefully in the Western Woods where brave souls fear to venture.

Eugene Meidinger( blog / post ) reminds us that big projects can sometimes result in big failures. What could be more catastrophic than migrating to a new ERP system ? The software was created by an outside company who specialty included heaping piles of poisonous code! Our main character, Eugene, is thrown head first into the fire. As the flames licked his body he pondered weak and weary about the assumptions they had made. He concludes his tale: “Even to this day, I’ve got a certain amount of skittishness around the idea of large projects.”…be warned!

Ron Wheeler( blog / post ) is another brave first time participant who gathers us around the campfire. You see out there in those woods there lurk SQL Server upgrade and migration projects. When the wind blows they call us saying “your project is doooooomed!”. If you haven’t ever purchased server grade equipment you don’t know the long waits times for hardware. You will be in for a shocking surprise. This one involves obstacles and devious plots like funding surprises, team switch-a-roo by a VP, and other hazards. It does not bode well when the PM refuses to use MS Project and instead uses MS Excel.

Craig Porteous( blog / post ) spins a tale from long ago when he was a neophyte wizard with SQL Server. A deadly concoction is made of one-part MS Access, using Excel as the hammer to all nails, sprinkle in some unexpected downtime, and let’s start this at 5pm on a Friday. Once imbibed this potion will drain your life force. His team thought they would summon the migration within a few hours but miscast and realized it would run until Tuesday…and there was supposed to be no downtime ! Craig worked restlessly late in the evening, fingers stained by the whiteboard marker, and gained maniacal pleasure when they finally vanquished the evil.

Innocent souls have been victim of scope creep and its impending doom. The Grim Reaper waits for no man and time is of the essence.

Bert Wagner( blog / post ) take us on a stroll through the graveyard of projects damned by scope creep! The road to hell is paved with good intentions. First you take your eyes off the focus then you write features nobody asked for or needs. The madness ultimately manifests as many blog entries dying as drafts never seeing the light of publication. Watch his video and be still when the lights go out…

Andy Levy( blog / post ) worked in the tower monolith making sacrifices to the mainframe. His attempts to modernize a workflow were met rigor mortis refusals. He knew there were more features that had to be implemented than other stakeholders thought and that they would not be pleased. His team then summoned advanced wizards from the

big consulting company. Proposal after design proposal was rejected and cast out of the realm. The consultants could not counter this hex. His key colleague wizard had been shunned from the monolith tower leaving Andy all alone. Delays and slippage happened. Then happened again. In a final valiant effort Andy managed to save the princess and attend his wedding day. However, as a final hex, the system spent more time under development than it ever did in use.

Kenneth Fisher( blog / post ) writes about the business bullying you. It all started on a Friday at 4:30pm with a dark request to submit a big change into an ELT system without testing it. The developers protested this was wrong. Management gave the resounding chorus “but it has to be done now”. As is tradition, the DBA was brought in late in the game to help. It is wise to look before you leap lest you fall into a pit for which there is no escape.

Politics they are everywhere and seem to bring out the worst in people! They turn regular folks into monsters. Putrid politics have petrified many innocent projects…

Allen White( blog / post ) delves into the occult and spins a tale from the crypt about a telemetry data project taken down by the slings and arrows of politics. It is not for the faint of heart deep inside there lies such horrors as…dare I speak it?…a CUBE in a GROUP BY clause! The horror! The house of assumptions had to be burned down to the ground and rebuilt with dark sorcery.

Bob Pusateri( blog / post ) stirs the witches kettle and broods about a project that wasn’t totally through out. Business and management can run anything into the

. Bob tried to cast a spell on management that would counter their evil intent: “Google has scale requirements beyond our imagination, and has hundreds of employees with Ph.D.’s in computer science and related fields who can address these problems. We don’t!”. Years later word around the campfire was nobody from the company had ever heard of a custom Linux filesystem being used there…

Andy Leonard( blog / post ) looks into the crystal ball and cast tarot cards to inform us that 85% of all BI projects fail. This dystopian future is now! There is an ancient ritual known simply as “deltas”. These changes require self-awareness and meta thinking as Andy describes. Be carefully not to spiral down the hole of circular logic because if you do nobody will be able to save you. Add in a pinch of toad foot and bureaucracy and you conjure up TPS reports, too many meetings, and miscommunications.

What happens when stakeholders remain silent about project requirements? How about internal sabotage? Carry on weary traveler and know these stories.

Rob Farley( blog / post ) is a frequent writer for T-SQL Tuesday and joined us again to extend the streak. Rob warns us of the danger and pitfalls of misaligned expectations and feedback loops. The story weaves an interesting post about demos to the idea of an iceberg. “Don’t make the demo look too done” because clients will judge the progression of the project by how polished the demo appears. This is the iceberg analogy they only see the tip and do not see the huge mass supporting it. Customers often won’t ask questions until they see what it looks like. Once you see how understanding expectations and requirements can cloud your eyes you will know the ancient and eclectic dark art of software estimations! Captains beware not to steer your vessel into the great ice glacier!

Steve Jones( blog / post ) hangs on to the scaffolding on the dark tower during an OOP project. A

consultant was brought in to help. Little did Steve know that he was casting his backups to a local workstation and not the network file share. His company would not entertain a VCS for code. He clashed with the consultant over the progress of the work. They were ready to implement their efforts but first needed an artifact to harness the power. They bought a server with 2GB of memory and with much trepidation loaded the software onto the server. During user acceptance testing stakeholders were horrified that the performance was actually worse than before the project. At that time the SQL Server optimizer wasn’t as powerful as today. The time estimated as double the expected amount. Luckily no heads rolled but the possibility remained…

This article on the SQL Insert statement, is part of a series on string manipulation functions, operators and techniques. The previous articles are focused on SQL query techniques, all centered around the task of data preparation and data transformation.

So far we’ve been focused on select statementto read information out of a table.But that begs the question; how did the data get there in the first place? In this article, we’ll focus on the DML statement, the SQL insert statement. If we want to create a data, we’re going to use the SQL keyword, “Insert”.

The general format is the INSERT INTO SQL statement followed by a table name, then the list of columns, and then the values that youwant to use the SQL insert statement to add data into those columns. Inserting is usually a straightforward task. It begins with the simple statement of inserting a single row. Many times, however, it is more efficient to use a set-based approach to create new rows. In the latter part of the article, let’s discuss various techniques for inserting many rows at a time.

The assumption is that you’ve the following the permission to perform the insert operation on a table

Let’s start inserting the data into thissimple department table. First, use the name of the table and then inside parenthesis, the name of the columnsand then type in the values. So, name the columns that we are going to type in the values.

The following SQL Insert into statement inserts a row into the department. The columns dno, dname, and loc are listed and values for those columns are supplied. The order is also maintained in the same way as the columns in the table

Inserting data into a table can be accomplishedeither using SQL Server Management Studio (SSMS), a GUI, or through Data ManipulationLanguage in the SQL Editor.Using GUI in SSMSis a quick and easy way to enter records directly to the table.

Let’s go ahead and browse department table and right-click and go to edit top 200 rows.

This will bring up an editor windowwhere we can interact directly with the data. To type in the new values, come down to the bottom and start typing the values.

It is very useful in some case to familiarize yourself with what data that you’re about to enter into the table.

In the following SQL insert into statement, three rows got inserted into the department. The values for all columns are supplied and are listed in the same order as the columns in the table. Also, multiple values are listed and separated by comma delimiter.

Let us create a simple table for the demonstration. A table is created with integer column defined with default value 0 and another DateTime column defined with the default date timestamp value.

Now, let us insert default value into the table Demo using a SQL insert into statement

Note: If all the columns of the table defined with default values then specify the DEFAULT VALUES clause to create a new row with all default values

Next, override the default values of the table with a SQL Insert into statement.

Let us consider another example where the table is a combination of both default and non-default columns.

In order to insert default values to the columns, you just need exclude the default columns from the insert list with a SQL insert into statement.

The following example you can see that the keyword DEFAULT is used to feed a value to the table in the values clause with a SQL Insert into statement

The following example shows how to insert data to an identity column. In the sample, we are overriding the default behavior (IDENTITY property of the column) of the INSERT with the SET IDENTITY_INSERT statement and insert an explicit value into the identity column. In this case, three rows are inserted with the values 100, 101 and 102

In this section, we’ll see how to capture the results of a query (simple select or multi table complex select) into another table.

Obviously, in the real life, we do not work with vanilla SQL Server installation. We need to customize it by changing SQL Server settings and logins, creating and/or restoring the databases and do other actions. There are a couple of ways how you can do that.

The first approach is customizing existing container manually and creating the image from it using docker container commit command . After that, you can start the new containers from created image the same way as we already discussed. We will cover a couple ways to move data to and from containers later.

There is the better way, however. You can automate this process by utilizing docker build command . The process is very simple. You just need to define DockerFile, which contains the reference to the main image and specifies the build actions. You can copy scripts and database backups into the image, run SQLCMD, BCP and PowerShell scripts there you, pretty much, have the full control. Internally, Docker runs every command inside deployment containers (creating and destroying them during the process) saving the final one as the target image.

By: Esat Erkec || Related Tips: > Reporting Services Report Builder

Power BI offers a data entry option which allows users to enter data directly and this data can then be used on reports and visuals. How can we create and use this type of data in SQL Server Reporting Services?

As you may know, Power BI and SQL Server Reporting Service (SSRS) are different platforms and offer different types of solutions to developers and end users. If you ask “which one should we use, the answer is often “it depends on your requirements”. Also, some Power BI or SSRS features are very useful and you may be wondering when this feature will be added to the other report development tool.

In this tip, we will cover the Enter Data feature in Power BI and also show how you can now do this in SQL Server Reporting Services.

LaunchPower BI and click the Enter Data option in the Home tab as shown below.

A create table pop-up screen will appear. In this screen we can enter the rows and can add new columns.

If we double click the Column header we can change the column name. When we click the Load button, Power BI automatically creates a table for us.

This table can now be used in your reports just like any other table.

Now we will look at how we can do something like this in SSRS.

The SQL Server Reporting Service Team Blog made a new announcement which is the Enter Data feature is now available in SQL Server 2016 Report Builder. This feature allows us to enter data directly to Reporting Services. This feature is very similar to Power BI’s.

First we need to install the newer version of Report Builder and if you are using the previous version of Report Builder, you have to uninstall and install the new version. Now we will complete the steps for the SSRS enter data demonstration.

Launch Report Builder and click Blank Report.

Right click Data Sources in the Report Data menu and click Add Data Source.

Add a name to the data source.

Chose “Use a connection embedded in my report” and select ENTER DATA. Then click the OK button.

Right click Datasets which is in the Report Menu and click Add Dataset.

Add a name to the dataset.

Chose "Use a dataset embedded in my report" and select the Data source created in the previous step.

Click Query Designer and a pop-up screen appears which allows us to enter data manually. This screen is very similar to the Power BI screen. In this screen we will enter some constant data. We can change the column caption by double clicking the column header or when we right click in the columns, we can change the column caption and data type.

By default, all columns are created using the string data type. We can easily change the data type in the context menu.

At this point, I want to add a note about data type conversion. If you make an incorrect data conversion, you will see the below error in the Query Designer screen.

When we save the report in Report Builder, it creates a report file which has a file extension of RDL. In addition, Report Builder creates an XML type data source and adds this XML data source to the RDL (Report Definition Language) file. This XML data can be seen in the Dataset Properties below.

When we open the RDL file in Notepad, we can see the XML data source code.

If we want to edit data, we can click Query Designer and we can edit the data.

After all these steps, we will create a very basic report which will use this embedded data and then we will publish it to SQL Server Reporting Service.

Click Insert tab and select Insert Table in the design pane.

Drag and drop the data set columns to table and run the report.

After we have finished our report design, we have to edit our RsReportServer.config file because this new data extension is not enabled in our current SSRS installation. You can find this file in these paths.

Native Installation of SSRS:

This configuration file includes SSRS parameters and settings. For this reason, before we edit this file we should make a copy of this file.

Open theRsReportServer.config file with Notepad and then add the below extension settings to the configuration file.

The configuration file looks like the below image.

Save the RsReportServer.config file. After all these steps are finished, we will deploy the report to SSRS.

Click the Home menu and select the Save As option.

We will select Recent Sites and Servers and set the report server web URL in the Name field. Then click Save.

When we connect to the SSRS web URL we can find our report.

By: Ben Snaidero || Related Tips:More >Import and Export

As SQL Server database professionals we are always tasked with moving data around. One of the methods I use quite often when copying data between instances (especially when it is just a one-off table copy between test environments) is to setup a linked server between the instances and copy the data using a single INSERT/SELECT command. A question that arises with this method is which is faster, to push (INSERT INTO remotetable SELECT FROM localtable) or pull (INSERT INTO localtable SELECT FROM remotetable) the data. This tip will try to answer that question.

To test the performance difference between push and pull we will also look at 3 different methods for creating the connection between the servers so we can see if the difference is also in any way based on the type of connection used.

The 3 different methods we will used are:

One thing to note for this test is that to rule out any network anomalies I setup two SQL Server instances on the same server so that the data does not have to go over a network when it is copied. Also, in order for OPENROWSET to work properly the 'Ad Hoc Distributed Queries' option must be enabled on each SQL Server instance. This can be done by running the following T-SQL commands.

In order to run this test, we will first need to create a linked server. I won't go details on how to do this in this tip since it's pretty straight forward and depends on your environment, but if you need to you can read more on linked servershere.

For the actual data move we will simulate moving data from an online system to an archive table on another server. For my test case I used a source table that was loaded using a dump from aSQL Profiler trace that had approximately 28000 records in it. A similar table structure (minus the primary key) was created in the target instance as the archive table.

The T-SQL to create these tables is below.

The actual test script used to test moving the data is outlined below. It is divided into two sections. The first section is run from the source (online) SQL Server instance and pushes the data to the target (archive) SQL Server instance. The second section is run from the target (archive) SQL Server instance and pulls the data from the source (online) SQL Server instance. Since this is purely a performance test I turned on the timing statistics option in SSMS using "SET STATISTICS TIME ON" so that the duration of each statement was output after it completed.

Below is a table that summarizes the script results. It's quite obvious that the pull method performs much faster than the push method in all 3 cases but why is this the case. Let's take a look at aSQL Profiler trace to see if we can answer that question.

Let’s first take a look at theSQL Profiler trace from the PULL method. Checking first the trace from the source (online) server we see that it is performing a simple SELECT of all columns just as we would suspect.

On the target (archive) server the PULL method is also just doing a simple insert.

Now let’s take a look at the slower PUSH option and see if we can find where/why we are getting this extra execution time. First looking atSQL Profiler trace from the source (online) server we see a similar query to what we saw on the target (archive) with the PULL method with only difference being the longer duration and no write activity (this would now happen on the target (archive) server.

Looking at theSQL Profiler trace from the target (archive) server we can now see where all the extra execution time is coming from for the PUSH method. The linked server is implicitly opening a cursor and running a separate cursor call for each record inserted. Note: I’ve only included a subset of the sp_cursor calls in the interest of saving space.

Here is additional output from the trace.

Based on this simple test it’s pretty easy to see why using the PULL method is definitely the best option for performance. Even with this small dataset we saw some really large gains in performance by pulling data to our archive server rather than pushing it from the online server.

Last Update:

I am in the process of accessing a remote instance SQL server using VPN modems. The modems are in the same VPN network. I can ping each of the modems from the remote machines. I have already set the alias of the sql server instances to the ip address

Unable to connect to SQL Server via JDBC. No suitable drivers found for jdbc: sqlserver: //

I simply want to use SQL Server database in my HTTP Servlet program but my program can't seem to connect to the database. It gives me the following error: No suitable driver found for jdbc:sqlserver://localhost:1433;databaseName=Bookyard;integratedSe

When I want to connect to SQL Server 2008, I get this message: Cannot connect to server. Additional Information: Cannot open user default database. Login failed. Login fail for user 'sa'. (Microsoft SQL Server. Error:4064) How do I resolve this error

How to manage & ldquo; Unable to open a connection to SQL Server & rdquo; With a custom message in vb.net

Is there any way to provide your own message to the user in case SQL Server Database is offline or not accessible while loading a VB.NET form! and yeah I don't want to use Try/Catch because it will show all type of error that occurs for example: Try

ASP.NET MVC 4 website, SQL Server 2012. When I upload all files to windows Server 2008 R2, source, web config etc, the app works fine. When I use 'Web Deploy' - which only uploads 'required files', ie strips out source files, web.config etc - it come

I have a SQL Server instance installed on my VPS I've followed all the usual steps to connect remotely including: Allowing Remote Connections Enabling TCP/IP + adding port 1433 to the IPAll range Creating a Firewall rule to enable the connection Stil

How can I force my ASP.Net application to connect to a SQL Server using TCP/IP, not Named Pipes? I read somewhere putting "tcp:" in front of the server name in the connectionstring should do the trick, but it does not seem to change anything. Ed

Not sure what might have caused it, I ended task on some SQL processes in task manager then restarted the computer. Now I can no longer login to SQL Server 2008 R2. This is the error I get when attempting to login: ==================================

I am attempting to connect to SQL Server running on Windows XP system from a *nix system on a local server via pymssql. However, the connection fails as shown below db = pymssql.connect(host='192.168.1.102',user='www',password='test',database='TestDB

I tried to open a connection with SQL Server Express and assign a new record on a specific table in C#. This code is giving me this error ExecuteNonQuery requires an open and available Connection. The connection's current state is closed. And the fol

I have a problem connecting to SQL-server database through from my android project. I have added sqljdbc41.jar file to my /app/libs directory and I have added it to dependencies in my android studio project. I use following code: package com.konrad.r

I've set up ODBC connections to databases before, but I'm currently having problems and can't seem to figure out what I'm missing. This isn't my area of expertise, and the Microsoft help/documentation is less than 'user friendly'. Appreciate any poin

一台SQL Server 2008 R2版本（具体版本如下所示）的数据库，最近几天更新统计信息的作业出错，错误如下所示：

Microsoft SQL Server 2008 R2 (SP2) - 10.50.4000.0 (X64)

Jun 28 2012 08:36:30

Copyright (c) Microsoft Corporation

Standard Edition (64-bit) on windows NT 6.1 <X64> (Build 7601: Service Pack 1) (Hypervisor)

第一次碰到这么奇葩的问题。查看错误日志，就会发现更新统计信息时出现异常，生成了dump文件。

对表做DBCC CHECKTABLE发现正常，未有一致性错误。

DBCC CHECKTABLE ( 'TBusRetail' )

后面查了一下资料，在官方文档看到有个Bug会导致这个问题，官方文档为：FIX: An access violation may occur when you update the statistics of a table after you enable and then disable conflict detection on a table in in SQL Server 2008 or in SQL Server 2008 R2。刚好我们这个环境的版本也在其中。具体参考下面：

Cause

This issue occurs because the database engine is trying to load dangling statistics. When P2P conflict detection is enabled, an MDColumnIdP2pCdId system column is added to the base index rowset of the table. Replication-related queries may create statistics on the system column automatically. When P2P conflict detection is disabled, the system column is removed from the table. However, the corresponding statistics remain. Therefore, updating statistics causes the access violation exception to occur because the statistics cannot be added to the table.

SQL Server 2008 Service Pack 2

The fix for this issue was first released in Cumulative Update 3 for SQL Server 2008 Service Pack 2. For more information about this cumulative update package, click the following article number to view the article in the Microsoft Knowledge Base:

2498535 Cumulative update package 3 for SQL Server 2008 Service Pack 2

Note Because the builds are cumulative, each new fix release contains all the hotfixes and all the security fixes that were included with the previous SQL Server 2008 fix release. Microsoft recommends that you consider applying the most recent fix release that contains this hotfix. For more information, click the following article number to view the article in the Microsoft Knowledge Base:

2402659 The SQL Server 2008 builds that were released after SQL Server 2008 Service Pack 2 was released

Microsoft SQL Server 2008 hotfixes are created for specific SQL Server service packs. You must apply a SQL Server 2008 Service Pack 2 hotfix to an installation of SQL Server 2008 Service Pack 2. By default, any hotfix that is provided in a SQL Server service pack is included in the next SQL Server service pack.

The fix for this issue was first released in Cumulative Update package 6 for SQL Server 2008 R2. For more information about how to obtain this cumulative update package, click the following article number to view the article in the Microsoft Knowledge Base:

2489376 Cumulative Update package 6 for SQL Server 2008 R2

Note Because the builds are cumulative, each new fix release contains all the hotfixes and all the security fixes that were included with the previous SQL Server 2008 R2 fix release. We recommend that you consider applying the most recent fix release that contains this hotfix. For more information, click the following article number to view the article in the Microsoft Knowledge Base:

981356 The SQL Server 2008 R2 builds that were released after SQL Server 2008 R2 was released

但是等我打上补丁后，测试发现问题依然存在，也只有这个表存在这个问题。后面仔细检查，发现这个表有不少计算列（ Computed Column ），刚好以前也遇到过由于计算列导致统计信息更新出现错误的情况，一检查，发现这表有大量的统计信息，遂生成删除统计信息的脚本后执行删除（排除了相关索引的统计信息）。然后再更新统计信息，OK，问题解决了。看来又是神奇计算列导致的统计信息更新异常！

SELECT 'DROP STATISTICS dbo.TBusRetail.' + QUOTENAME ( name ) + ';'

FROM sys . stats

WHERE object_id = OBJECT_ID ( 'dbo.TBusRetail' )

Azure SQL Database is introducing two new features to cost-effectively migrate workloads to the cloud.SQL Database Hyperscale for single databases, available in preview, is a highly scalable service tier that adapts on demand to workload needs. It auto-scales up to 100 TB per database to significantly expand potential for app growth.

What does this mean? It’s one of the most fundamental changes to SQL Server storage since 7pm. So this is big: big news, and very big data stores. I am very lucky because I got to interviewe Kevin Farlee of the SQL Server team about the latest news, and you can find the video below.

I am sorry about the sound quality and I have blogged so that the message is clear. When I find the Ignite sessions published, I will add in a link as well.

What problem are the SQL Server team solving, with Hyperscale?The fundamental problem is how do you deal with very large databases in the cloud. VLDBs is the problems that people want to do with normal operations. All the problems with VLDBs occur due to the sheer size of data, such as backups, restores, maintenance operations, scaling. Sometimes these can take days to conduct these activities, and the business will not wait for these downtimes. If you are talking tens of terabytes, that takes day and ultimately Microsoft needed a new way to protect data and VLDBs. The SQL Team did something really smart and rethought very creatively on how they do storage, in order to take care of the issues with VLDBs in the cloud.

So, the Azure SQL Server team did something that is completely in line with one of the main benefits and key features of cloud architecture: they split out the storage engine from the relational engine. Storage implementation was completely rethought and remastered from the ground up. They took the viewpoint over how you would go about architecting, designing and building for these solutions in the cloud, if you were to start from scratch?

The Azure SQL Server database team did a smart thing: Azure SQL Server is using microservices to handle VLDBs.

The compute engine is one microservice which is taking care of it’s role, and then another microservice that is taking care of the logging, and then a series of microservices that handle data. These are called page servers, and they interface at the page level. The page servers host and maintain the data files. Each page server handles about a terabyte of data pages. You can add on as many as you need.

Ultimately, compute and storage are decoupled so you can scale compute without moving the data. This means it’s possible to keep adding more and more data, and it also means that you don’t have to deal with the movement of data. Moving data around when there are terabytes and terabytes of data isn’t a trivial task.The page servers have about a terabyte of data each, and the page servers have about a terabyte’s worth of SSD cache.

The ultimate storage is Azure Blob Storage, because blob storage is multiply redundant and it has features like snapshots, so this means that they can do simultaneous backups by just doing a snapshot across all of the blobs. This has no impact on workload.

Restores

Restores are just instantiating a new set of writeable disks from a set of snapshots, and works with the the page servers and the compute engine to take care of it, working in symphony. Since you’re not moving the data, it is faster.

I’m personally very impressed with the work that the team they’ve done, and I’d like to thank Kevin Farlee for his time. Kevin explains things exceptionally well.

It’s worth watching the video to understand it. As well as the video here, Kevin goes into detail in his Microsoft Ignite sessions, and I will publish more links when I have them.

Community

One advantage in doing the MIcrosoft Community Reporter role is that I get to learn from the experts, and I enjoyed learning from Kevin throughout the video.

It seems to me that the Azure SQL database team have really heard the voice of their technical audience and they’ve worked passionately and hard to tackle these real life issues. I don’t know if it is always very clear that Microsoft is listening but I wanted to blog about it, since I can see how much the teams take on board the technical ‘voice’ from the people who care about their solutions, and who care enough to share their opinions and thoughts so that Microsoft can improve their solutions.

From the Azure architecture perspective, it works perfectly with the cloud computing concept of decoupling the compute and the storage. I love watching the data story unfold for Azure and I’m excited by this news.

I have a very special relationship with MDS (Master Data Services), and even though for some reason I have never blogged about it, I feel like SQL Server 2019 is bringing a good reason to blog about.

To define my kind of relationship with the MDS, let’s put it to the perspective, that for a couple of months in 2017 I was spending with it many more months that I would spend with Columnstore Indexes. :) And let’s add to that, that I have had to learn the internals of the functioning of MDS way to much that I have wished to. :)

Before we continue, let me ask you one question, have you heard about Silverlight ?

Or in other words, and with a kind of evil voice “DID YOU EVER INSTALLED SILVERLIGHT ON A PRODUCTION SERVER”?.

If you have worked with MDS oh yes, you did! At least in order to check if everything is configured/upgraded correctly and nothing is broke, I will do a wild guess and claim that you did! So am I … :s

No more Silverlight Yahoo!

The lack of the horizontal scrollbars for the Master Data Management is still as irritating as it was many years ago.

In the basic tests of the Integration Management I was happy with what I saw, especially given that this is a pretty early release.

The version management bugs (lock a version and try to copy it) are still here the screen changes its design completely …

Do not take this feedback as a negative one, I am critical because I really would love this product to grow and to succeed, because right now anyone who is truly serious about Master Data Management is looking towards other vendors, such as Profisee .

Is this a promise of a brighter future for the Business Intelligence people working with Data on the Enterprise?

I do not think so, but I think it is a very first step on ensuring that not everything is lost.

I wish this would mean that MDS is not really dead. (and not like in maintenance mode, cleaning up the bugs from 2008)

I wish that there would be someone in the leadership position Microsoft who love Business Intelligence and more specifically Data Quality. (Those people would have to be from the leadership, cause I know enough great specialists who truly care, but they are not given decision rights, hopefully just yet)

I wish that the elimination of the Silverlight is not some kind of windows Server requirement and that we soon can see a presence of the Linux version of the MDs (on the Apache, for example) and eventually (or even before) a PaaS (Platform As A Service).

I will be looking and testing the new MDS, with no public blog posts anticipated but I will be closely watching where the MDS team will be taking the product forward.

The post Fix SQL Server with one click appeared first on Born SQL .

Randolph West solves technology problems with a focus on SQL Server and C#. He is a Microsoft Data Platform MVP who has worked with SQL Server since the late 1990s. When not consulting, he can be seen acting on the stage and screen or doing voices for independent video games.

微软System Center四大核心套件，SCCM、SCVMM、SCOM、SCDPM，接下来我们部署最后一个重要的套件SCCM，SCCM具有资产管理，终端管理，补丁、软件、操作系统分发，等诸多功能，从2012其，其还集成了SCEP（System Center Endpoint Protection）安全套件，可以用于终端安全检测、杀毒等。

常规套路，在安装SCCM 2016之前，我们先来看看SCCM的前提条件，并部署SCCM所需的数据库。

SCVMM的前置条件需求如下：

计算机加入域

安装账户、服务账户具有本地管理员权限

SQL Server 20108 R2 SP3、2012 SP3、2014 SP1、SP2、2016、2016 SP1(本次部署采用2016)

排序规则要求SQL_Latin1_General_CP1_CI_AS

SQL Server要求的功能为： 数据库引擎服务功能为必须

windows身份验证需要

每个SCCM站点需要专用的SQL Server实例

SQL Server内存要求最少设置8GB

必须启用SQL嵌套触发器

要求启用SQL Server公共语言运行时（安装SCCM时会自动启用）

SQL Reporting报表服务（如需生成报表）

BITS服务

.Net 3.5、4.0或4.5或更新 (Windows Server 2016已内置4.6与3.5)

Windows Installer 4.5（或更高版本）（Windows Server 2016系统已内置）

Microsoft XML Core Services 6.0 (MSXML60)

IIS服务角色

WSUS服务

Windows ADK (Windows 部署工具组件)

部署工具

Windows 预安装环境（Windows PE）

图像处理和配置设计器（ICD）

用户状态迁移工具（USMT）

Windows Perforamance Tookit

Windows Assesment Service

进行正式安装之前，需进行如下步骤：

安装好操作系统

设置IP地址与计算机名（本POC测试中，IP地址为172.16.11.15、计算机名为SCDPM）

计算机加入域

将DPMadmin管理员用户、sqlservice服务启动账户加入到本地管理员组

安装好.Net 3.5 与 .Net 4.6

2. SQL Server与前置条件安装

1） 使用CMadmin登录到SCDPM服务器，并插入SQL Server 2014 安装光盘

2） 双击打开SQL安装程序

3） 在SQL Server安装界面，点击左侧的安装，然后点击右侧的“全新SQL Server独立安装或向现有安装添加功能”

4） 在产品密钥页面，镜像已经预输入了密钥，直接点击“下一步”

5） 在许可条款页面，勾选 “我接受许可条款”，然后点击“下一步”

6） 在Microsoft更新页，直接点击“下一步”

7） 在产品更新页，直接点击“下一步”

8） 在安装规则页，所有规则检查通过后，点击“下一步”

9） 在功能选择页面，勾选数据库引擎服务、全文语义提取搜索、Reporting Service-本机，然后点击“下一步”

10） 在实例配置页面，选择默认实例，然后点击“下一步”

11） 在服务器配置页面，将 SQL Serrver代理 、 SQL Server数据库引擎、SQL Server Reporting Service的服务启动账户更改为mscloud\sqlservice，并输入密码，勾选“授予SQL Server数据库引擎服务执行卷维护任务特权”，然后点击上方的排序规则选项卡

12） 将数据库引擎规则改为SQL_Latin1_General_CP1_CI_AS,然后点击“下一步”

13） 在服务器引擎配置页，身份验证模式选择混合模式，然后将cmadmin、sqlservice、administrator等域用户添加为SQL Server管理员，然后点击上方的数据目录选项卡

14） 在数据目录选项卡，数据根目录选择D:\SQLDB，然后点击“下一步”

15） 在Reporting Service页面，选择安装和配置，然后点击下一步

16） 在准备安装页面，检查SQL 安装设置是否有误，确认无误后，点击“安装”

17） SQL Server安装完成，点击“关闭”

18） 在SQL Server 2016安装包中，不再提供管理工具，需要单独下载SQL Server管理工具，下载地址 https://go.microsoft.com/fwlink/?LinkId=531355

19） 双击打开下载好的SSMS管理工具，在初始页面，点击“安装”

20） 安装成功，点击重新启动，重启服务器

21） 重启完成后开始安装先决条件

首先打开我们下载好的ADK 10程序adksetup.exe

22） 打开后选择安装路径，然后点击下一步

23） 在工具包隐私页，点击下一步

24） 在许可协议页，点击“是”

25） 按照下图所示勾选要添加的功能，然后点击安装

26） 安装完成点击关闭

27） 在AD中创建系统管理 容器

使用域管理员登录到任意一台域控制器，打开 控制面板 -> 管理工具-> ADSI编辑器

28） 右键点击连接到

29） 选择默认命名上下文，然后点击确定

30） 在域名上，右键点击新建->对象

31） 类选择Container，然后点击下一步

32） 值输入System Management，然后点击下一步

33） 点击“完成”

34） 右键点击新建的容器，然后点击 属性

35） 点击 安全 选项卡，然后点击 添加

36） 添加SCCM的主机名，并赋予 完全控制 权限，然后点击 高级

37） 选择该对象，点击 编辑

38） 将应用于设置为 这个对象及全部后代 ，然后点击 确定

在返回的界面一路点击确定

39） 按照上述步骤，添加mscloud\cmadmin账户权限

By: Daniel Farina || Related Tips:More >SQL Server on linux

In aprevious tip we looked at how to use Cron to schedule tasks for SQL Server on Linux . In this tip we take a deeper look to help answer these questions: Is there is any security configuration that I can use? Is there a way to view a log of cron work? How I can check if a job was successful or failed? In this tip I will answer those questions.

In myprevious tip in this series I introduced you to the cron daemon and its configuration file, crontab. I omitted many items in order to make the introduction simple. My intentions with that tip were mostly to introduce you to the format of crontab file. Now I will cover more advanced topics.

It is not enough to just know the crontab file format to use cron. Think about it. It is pointless to schedule a job if you wont be able to know whether it was successful or failed.

Here is a list of topics I will cover in this tip:

Let’s start.

You can define and use variables in a crontab file. There are predefined variables where the name has a specific use. Take a look at the next table. Some of those variables have a default value which can be overridden by redefining it. Also, you can assign an empty string if you want to blank out the contents of a variable (i.e. VARIABLE="").

Something important to note is that cron doesn’t perform variable substitution. In layman’s terms, you can’t assign a variable the sum or composition of other variables. Let’s consider the following example:

On the previous example the user who wrote the crontab lines wants the PATH variable to contain the directory specified in the HOME variable and additionally /bin and /usr/bin directories. But since there is no variable substitution in cron, the PATH will take "HOME:/bin/:/usr/bin" as a literal. The proper way to write the previous lines is as follows:

In the next image you will see a crontab file with SHELL and PATH variables declared.

The next code fragment shows how to use a variable in a job definition. It is declaring a variable SQLDATA with the path to SQL Server backups and each day at midnight moves the backup files to an external device.

Cron jobs are logged by default to the file /var/log/syslog, which is the file where all services log statuses and messages. There are different ways you can view its content.

The next script uses the grep command to search the pattern "cron" in the file /var/log/syslog (the -i is to make the search case insensitive).

Also, we can use a pipe to send the output to the tail command if we are interested only in the last 10 lines.

The systemctl command shows the status of cron service as well as its last entries in syslog.

Also, we can use journalctl (a command that queries the system journal) and pass the system unit cron as a parameter. It has the peculiarity that shows system reboots.

We can create a single file that holds the cron messages by editing the /etc/rsyslog.d/50-default.conf file and uncommenting the line that starts with #cron.*. On the next image you can see that line.

After you uncomment that line and save the changes you should run the following command to restart the rsyslog service.

Cron has two files, /etc/cron.allow and /etc/cron.deny that we can use to configure and manage the users allowed to have a personal crontab. The system-wide crontab will work regardless of the contents of those files. Those files have the same format which is one user per line. Here is how they work.

In order to protect the system-wide crontab you have to set the proper permissions to the /etc/crontab file. The following command will give read and write permissions only for the root user and no other user will be able to read the file.

Cron also has special folders that serve as shortcuts to schedule jobs at specific times. In the next table I enumerate those folders.

The system-wide crontab is what executes the content of each of those folders, so it may be useful to set those folders with root only permission to avoid the chance that a user puts malicious scripts in those folders.

By: Artemakis Artemiou || Related Tips:More > Application Development

SQL Server is one of the most powerful data platforms in the world and the .NET Framework is one of the most popular software frameworks for developing software that runs primarily on Microsoft windows. Imagine what you can do if you combine these two technologies. The possibilities are endless.

This tip helps you get started with SQL Server and .NET (C#). You will learn how you can connect from a C# application to SQL Server and how you can retrieve the version of the SQL Server instance, thus running a simple query.

In order to demonstrate a connection to SQL Server via a .NET application, in this case a C# application, we need to start a new project in Visual Studio. For this demo, I’m using Visual Studio 2017 .

So, in Visual Studio, I’m starting a new project and select Visual C# - Console App (.NET Framework) and calling it TestApp1.

And this is the development environment I get, in order to work on my project:

The purpose is to try to connect to a named SQL Server instance " SQL2K17 " on the local machine and retrieve the SQL Server version information.

Here’s a screenshot of the SQL Server instance, as it can be seen in SQL Server Management Studio (SSMS):

In order to connect to a database from a client (i.e. in this case, our C# application), we need to make use of a Data Provider . For example, there are ODBC drivers/providers, OLE DB providers, specific .NET Framework Data Providers, etc. Without the use of a Data Provider, you cannot connect to the database. Data Providers act like intermediaries between the database server and the application/client.

In this demo, we are going to use the " .NET Framework Data Provider for SQL Server ". We make use of this data provider by including in our project, the System.Data.SqlClient namespace with the below line of code at the top of our code class:

Then we need to write the proper C# code that tries to establish a connection to the SQL Server instance, using the above data provider, along with executing the query that returns the SQL Server version.

At this point it must be mentioned that when writing data access code, you always need to include exception handling code/logic, in order to handle any issues that may have to do with the communication between the client (i.e. your C# application) and the database server.

In order to connect to SQL Server using the .NET Framework Data Provider for SQL Server and retrieve information, you will need to create the below objects:

Also, in order to establish the connection to SQL Server, you will need to specify the connection string , in the format expected by the data provider you are using.

In the connection string, you can specify that you want to have either a trusted connection to SQL Server, that is using Windows Authentication, or a SQL authentication-based connection, by using a username/password.

Below, you can find examples of connection strings. The first one, uses a trusted connection, and the second one uses an SQL connection.

In this demo, we are going to use a Trusted connection.

The below code block, shows how you can set the connection string in the SqlConnection object, along with applying exception handling logic while trying to connect to the SQL Server instance:

The below code block, shows how you can make use of the SqlCommand object:

Last, the below code block shows how you can make use of the SqlDataReader object for the purposes of this demo:

OK, now we can put everything together and write the proper C# code to access the named SQL Server instance ".\SQL2K17", retrieve version information, and display it on the screen via the command line.

Here’s the full code for the Program.cs class:

One thing I have noticed in various places is that people still tend to use the traditional clustered and non clustered indexes. Yet I rarely see the filtered indexes being used even though they have been available since SQL Server 2008. Here’s the results of a quick poll I done this week about index preferences:

#sqlserver question of the day. Do you have a preference of which index type to use first to fix performance issues, if so what? #sqlpass #sqlfamily

As shown rowstore non-clustered filtered index was the least popular choice. One of the votes you see might have been a sympathy vote.

So to help spread the love for them and newer index types I have decided to do a unique review of current SQL Server index types.

But before I do I want to briefly discuss heaps.

Heaps means that the data for a table does not have any form of clustered index. Traditionally they are know to have issues performance wise. Especially if a large amount of deletes and updates take place inside them.

See for yourself by downloading Brent Ozars First Responder toolkit here and run sp_blitzindex against a database that has heaps. Of course heaps have their uses. They work well with large imports if configured correctly.

Now the heaps are clarified we can go to the index types.

You might be wondering what I mean by rowstore. It’s a term somebody came up with to describe the traditional index structure that most people who work with SQL Server know.

It is based on a balanced tree index design. If you look on SQL Server Books online you see the diagram of this index. You see it has a tree structure and looks like an organisation chart. Clustered indexes define how the data in a table is ordered by stating what columns the index is ordered by when created. Index keys are another name for the columns used to order an index.

Traditionally these are created to convert the data inside heaps into a structured index. Because they contain the data itself only one can be created per table.

These indexes are what some people also call covering indexes. These are indexes that tend to include a subset of the columns in your table to speed up the performance of queries. To reduce the size of these indexes and improve the performance even more you can add columns as “included” columns.

Those columns end up in the leaf level of the index only. It optimises the index in question and avoids SQL Server having to look at another index for that table. You should add columns which are only in the “Select” part of a SQL query as an “included” columns.

You can have a number of these indexes per table depending on which version of SQL you are using.

Some people will point out this is a type of non-clustered index. And they are completely right. I’m giving this type it’s own section to spread the love for it a bit. It’s being available since SQL Server 2008. I think it should be more popular because it can dramatically improve query performance.

It’s where you create a non-clustered index with a “Where” clause at the end after stating all the columns. Exactly like you do at the end of a normal query. Doing this makes the index a lot smaller and optimal. If you have a certain query causing you pain it can make it go a lot faster. I’ve seen filtered indexes change queries from taking minutes to seconds.

Way back in SQL Server 2005 the decision was made to introduce XML to SQL Server. Back then it was a big deal. I’ll be honest here I’ve not used them since Microsoft reduced their importance in the SQL exams.

Still I did say I’d cover them. You can have a Primary and an additional Secondary XML index. To create a Secondary XML index you must first create a Primary. Either can be used in different ways to access XML data from SQL faster. If you feel sorry for people who support this maybe spare a though for those who support XML in varchar(max) columns as well.

Columnstore indexes were introduced in SQL Server 2012 and are highly compressed non-clustered indexes. Based on a compression engine used in Excel these are ideal for reading large database tables that contains millions of rows.

I have to add that only certain data types are supported though and the larger varchar data types are not.

Because of their popularity they have improved with newer versions of SQL Server. Plus filtered columnstore indexes were introduced with SQL Server 2016. Another advantage of using these indexes are that they perform well with memory optimized tables.

First introduced in SQL Server 2014 a table with compatible data types can have a clustered columnstore index.

Be aware that when clustered columnstore index is created it does not reorder the data in a specified order. Therefore it is considered good practice to create a clustered index on a large table first. After that convert it to columnstore.

Like their rowstore counterparts you can only have one of these per table.

These index types were introduced to handle the data structure used by in-memory OLTP (aka Hekaton). Which first introduced with SQL Server 2014.

These are used by memory optimized tables. Designed to reduce contention during a large amount of transactions.I highly recommend you do your homework before using this. For more information about this I recommend downloading Kalen Delaneys Second Edition about In-Memory OLTP from here .

What a mouthful this index name is! This index type is a version of a non-clustered index for Memory-Optimized tables. It’s based on the traditional B-Tree, or Balanced Tree, index design. It also uses the same top-down design that rowstore indexes have. Due it being optimized for In-Memory OLTP it’s known as a Bw-tree structure.

Well there’s my quick overview of current index types in SQL Server. A bit longer than expected but worth it. Look in SQL Server books online for more detailed explanations about all of them.

If you have questions or anything to add feel free to comment on this post.

Kevin Chant