Is '*=' a valid operator for Access Queries - sql

Question

I have just started on a project that involves building a web application replacement for an old Access application that was already backed by an SQL database.
The issue i have hit is that the Access application has a bunch of queries within it that use '*=' as condition operators (ie "where field1 *= 'Something'") which when i run the application cause it to crash.
I have tried to verify if the operator is valid or if the original developers have handed over an intentionally broken version of the application.
Can any one provide verification that '*=' (ie asterix equals) is or is not a valid operator in an Access query?

Answer 1

Don't worry; your original developers are not trying to pass you intentionally broken code. It's just that the code is very old.
*= (and its counterpart =*) were a non-standard SQL operator supported originally by Sybase SQL and inherited by Microsoft SQL Server in the mid-90's. *= meant LEFT JOIN (and its counterpart =* meant RIGHT JOIN)1
(Microsoft SQL Server was originally a repackaged edition of Sybase SQL, licensed from Sybase, adapted and recompiled to run on Microsoft's brand-new Windows NT Operating System. The partnership was eventually discontinued and Microsoft rewrote the code from scratch without Sybase's involvement, and that's the product we still have today)
The operator *= was a way to express LEFT JOIN operations, before there was such a thing as a LEFT JOIN operator:
SELECT *
FROM a, b
WHERE a.id *= b.id
Is the same as:
SELECT *
FROM a
LEFT JOIN b
ON a.id = b.id
These operators have been deprecated for more than a decade and are no longer supported at all, ever since SQL Server 2012. Using them in earlier versions of SQL Server is possible but requires the whole database to have a legacy-mode setting called compatibility_level to be set to 80 ("SQL Server 2000 mode").
Access has never supported these operators.2
You need to locate the code doing these outer joins and replace them with suitable LEFT JOIN (or RIGHT JOIN for =*) operations.
Finally, you should be aware that *= is not an exact mirror of LEFT JOIN. I don't remember all the details, but it goes something like this: If there are only two tables involved, or if there is a central table and all the LEFT JOINs go from the central table to immediate leaf tables, you can replace *= with LEFT JOIN in a straightforward fashion. However, if the outer joins cross more than two tables out, then *= behaves different than the naive replacement and you need to research it more carefully. I might be wrong about the details. Be careful!
1Compare this weird syntax for LEFT JOIN with this variant of an INNER JOIN, which is still perfectly acceptable today:
SELECT *
FROM a, b
WHERE a.id = b.id
Is exactly the same as:
SELECT *
FROM a
INNER JOIN b
ON a.id = b.id
2UPDATE: Upon re-reading your question I realize you were talking about pass-through queries executed by SQL Server. Then your choices depend on what version of SQL server you are using.
If you are able to run the application against SQL server 2008 R2 or earlier, you can temporarily switch compatibility_level to 80 to give you time to fix your queries.
More likely than not, you are having this problem precisely because you are trying to move the database to a version of SQL Server newer than 2008 R2, which doesn't support compatibility_level 80. When you loaded the database on a version of SQL Server newer than 2008 R2, the setting was automatically increased to the lowest value supported by your version of SQL Server (but higher than 80, which would no longer be supported). Then your only reasonable choice is to stay on SQL server 2008 R2 for now (and switch the database back to compatibility_level 80 if necessary) while you work on fixing the application queries.