break out base class construction

tweak clearer code

remove all remnants of DQ::Constants

Pass subtype to Literal() helper directly

Update DQ Converter to use new DQ::ExprHelpers

Instead of creating DQ structs directly, use the ExprHelpers to handle generation.

Fix eq_bind checker

We have to Deepcopy because otherwise we get $VAR->... incorrect failures

fix arrayref tables to use correct join generation style

document order by madness

simple literals get detected and turned into nodes

ASC purge: t/06order_by.t

less generous literal parsing

parse simple order literals

abstract order specification

make renderer and converter classes more pluggable

handle ->_where_to_dq($plain_sql_string)

more tweaks

refactor a bit more, honour literals in converter

factor out Converter

simplify and generalize table literal handling

factor out select logic a bit more

pass unknown @_ downwards for subclassers

order inside select node

factor some stuff out and enable writeable quoting attributes

throw toys out the pram and convert to Moo

clean up always_quote usage, factor out _render_sqla

port -ident and -value

fix handling for nested function calls - see giant comment for compat hate.

handle scalarref in arrayref of table names

delete vestigial _join_sql_clauses method

annihilate refkind stupidity

gut values using _mutation_rhs_to_dq code

de-REFKIND-rubbish-ify from handling

port INSERT, factor out mutation op RHS code

convert update, refactor some stuff

factor out from+where handling and port DELETE

separate out _where_to_dq from _expr_to_dq and rewrite select to use DQ

fix expression generation for UPDATE

first cut at convert and case options

implement $self->{logic} and kill numbered modifiers

Convert deprec. test to expectation of fatal error

improve and/or handling

remove builtin special ops; handled elsewhere

special ops handling

allow \n in op names - not sure why this ever worked, but the scope guard test uses it and I don't see an immediate reason to disallow it

refactor operator construction and add injection guard support back

switch { foo => \'= bar' } to using multipart literal support

clean up IN/BETWEEN handling

sort hash keys when found as RHS in a hashpair

handle empty where clauses, fix a quoting bug in literals, re-add support for custom default comparison op

handle crack fueled inner function thing

rewrite _where_to_dq to get rid of refkind switch

handle more IN/BETWEEN odd cases, fix value_meta handling

first chunk of WHERE clause conversion

refactor somewhat and convert order_by

factor _table_dq out and use in SELECT

pass SELECT's FROM+etc. through DQ

generate SELECT list using DQ

move _render_dq call for _table to top level of method

handle \@from via DQ

switch literal FROM clause generation

create Data::Query::Renderer::SQL::Naive object and use it for single-table FROM clause generation

Pull in some dependency bugfixes

Upgrade M::I

Migrate -ident and -value from dbic, reorganize docs

Document with the right name

Cleaning up docs as ribasushi suggested. Made it clear that literal sql
should be used as a last resort.  Provided an example for testing IS NOT NULL.

Cleanup parser a bit more, anchor everything correctly, etc

Add test for SQL statement that used to fail before the refactor

Massively refactor arbitrary sql parser code

Now it deals much better with malformedness, does not recurse to insanely
deep evels, and reports much much better errors on test mismatches

Fix over-eager parenthesis unrolling (only legal in AND/OR)

Promote AS to a binop of sorts

Do not import Carp functions into the namespace

_debug not debug, RT#67179

fix some pod per RT65556

fix git url, RT67137

take out useless _table option

Add some crazy malformed SQL to make sure things do not throw

It looks like the empty-not-undef fix in 7cc47319 also fixes the general
issue of throwing on unknown operators (e.g. reverting af75bd59 would
still yield passing code, though the AST will still be incorrect).

Add a currently passing test as a reminder of what stuff to look for

Fix incorrect comparison of malformed lists

AND OR and , must have both a lhs and a rhs, if neither is
present add a [], which will properly trip the comparison
later on.

Fix recursion warnings while parsing extremely long lists

Fix stupid not exists omission

Release 1.72

Consolidate the injection_guard checks, fix bobby's name

injection_guard implementation

Require bugfixed CAG

Undocument -nest with extreme prejudice

-nest is a wart that never served any reasonable purpose. While
DBIC is outright deprecating it, SQLA is simply undocumenting it,
committing to keep all tests intact (but not committing to
reimplement -nest in the Data::Query adapter).

Removed excess parentheses in generated SQL

Fix stupid assumption in parenthesis unroller

Pass options to _insert_returning and allow bind rvs

add handling for NULL when using -in

Better diagnostics (unparse the parent of the failed chunk)

Ask for a faster CAG, switch to MI::AI

Warnfree tests

Fix retardation in -between bind handling

migrate _parenthesis_unroll to SQL::Abstract::Tree

Fix parsing of foo.* in SQLA::Tree

Release 1.71

Disable dbic-tests when no dbic is present

Release 1.70

sort changes by importance

no raw ASCII