Differenze tra asqueel e GenroPy

In asqueel

Dichiarato (src/asqueel/elements.py:274); la scrittura della tabella è rifiutata se una colonna ha default (src/asqueel/model_source.py:251). Prova: insert solleva UnsupportedFeatureError 'write execution of c.default is not available in this release'

In asqueel

Ciascuno solleva UnsupportedFeatureError che nomina l'attributo, su tabella (variant, ext_<pkg>) e su colonna (localized, variant, ext_<pkg>): src/asqueel/builder.py:405-411. Prova: 'app.t.c: localized is not available in this release'

In asqueel scrivi

tbl = pkg.table('note', pkey='id')
tbl.options().sys_fields()

In asqueel ottieni

options().sys_fields(...) (src/asqueel/model_elements.py:90); espansione src/asqueel/model_expansion.py:125 (id, __ins_ts, __mod_ts, __del_ts, __ins_user, __mod_user, __is_draft, __syscode); scrittura eseguita (src/asqueel/model_source.py:237): trigger_setTSNow (src/asqueel/table_triggers.py:50), trigger_setCurrentUser (src/asqueel/table_triggers.py:57) da db.currentUser (src/asqueel/runtime.py:158). Prova: insert valorizza id di 22 caratteri, __ins_ts e __mod_ts

In asqueel scrivi

tbl.options().sys_fields()
tbl.options().hierarchical('code')

In asqueel ottieni

options().hierarchical (src/asqueel/option_elements.py:14); espansione src/asqueel/model_expansion.py:226, richiede pkey id di size 22 (:234), linked_to e depth sollevano UnsupportedFeatureError (:230); scrittura con HierarchicalHandler (src/asqueel/hierarchical.py:29) chiamato da trigger_hierarchical_before/after (src/asqueel/table_triggers.py:61); lettura di child_count, hlevel, root_id

In asqueel scrivi

tbl.options().auto_counter()

In asqueel ottieni

options().auto_counter (src/asqueel/option_elements.py:22); espansione src/asqueel/model_expansion.py:199-209 (colonna _row_count, order_by della tabella). La scrittura è rifiutata salvo su tabella gerarchica (src/asqueel/model_source.py:239-242). Prova: insert su tabella con auto_counter solleva 'write execution of option auto_counter is not available in this release'

In asqueel

db.tableMixin e db.packageMixin sollevano UnsupportedFeatureError (src/asqueel/runtime.py:53, :57); mixin= sulla tabella solleva (src/asqueel/builder.py:407); la classe Table di main.py solleva (src/asqueel/package_layout.py:55). Restano una sola classe per tabella: x_table_class (src/asqueel/object_tree.py:166; docs/guide/hooks.md:3) o la Table del layout unita a SqlTable (src/asqueel/package_layout.py:75)

In asqueel

Attributi di table() dichiarati (src/asqueel/elements.py:172-173); le proprietà sollevano UnsupportedFeatureError (src/asqueel/object_tree.py:334). Prova: 'app.t: rowcaption is not available in this release'

In asqueel

virtual_columns elenca solo le virtuali dichiarate (src/asqueel/object_tree.py:217); le colonne di formulaColumn_<x>() stanno in dynamic_columns (src/asqueel/object_tree.py:225) e column() le risolve; starColumns solleva UnsupportedFeatureError (src/asqueel/object_tree.py:334); l'espansione di '*' è interna al compilatore (src/asqueel/compiler.py:805)

In asqueel

Nessun elemento subtable: t.subtable(...) solleva AttributeError; default_subtable come attributo di tabella solleva ValueError (src/asqueel/builder.py:365); opzione di query subtable rifiutata (src/asqueel/application_table.py:45)

In asqueel

_override rifiutato dalla grammatica: «Element 'formulaColumn' does not accept '_override'» (prova); fisica contro virtuale dà 'conflicting element kinds' (src/asqueel/builder.py:194-197, tests/test_virtual_column_redefinition.py:93-106)

In asqueel

src/asqueel/elements.py:388 solo dichiarazione; selezionarla dà UnsupportedFeatureError 'pyColumn is not available in this release' (src/asqueel/compiler.py:214, tests/test_specific_errors.py:62, prova)

In asqueel

Assente dalla grammatica: chiamarla dà AttributeError «'SourceBagNode' object has no attribute 'toolColumn'» (prova); non compare fra i tag di src/asqueel/builder.py:66-70

In asqueel

variant= rifiutato su column (src/asqueel/builder.py:405-410) e dalla grammatica di formulaColumn (prova); i metodi variantColumn_* non vengono letti; un nome passato solo nei sqlparams dà 'Unknown column' (src/asqueel/compiler.py:139, prova)

In asqueel scrivi

tbl.query(columns='$id, @invoices.aggr(count() AS n)').fetch()

In asqueel ottieni

src/asqueel/compiler.py:377-379 UnsupportedFeatureError '<rel>: a path through the many relation <rel> is not available in this release' (prova); con one_one il percorso diventa LEFT JOIN (src/asqueel/compiler.py:363-364, prova); al suo posto @rel.aggr(...) (riga A4.19)

In asqueel

joinColumn rifiutato alla chiamata con 'joinColumn is not available in this release' (src/asqueel/builder.py:126-129, prova). La relazione su colonna virtuale esiste: weak di default (src/asqueel/builder.py:441-446), join sull'espressione (src/asqueel/compiler.py:428, prova). Il caricatore legacy traduce join_column in virtualRelation più aliasColumn (src/asqueel/legacy_source.py:77-88), ma una virtualRelation non si risolve come percorso verso uno (src/asqueel/compiler.py:354)

In asqueel

query(joinConditions=...) rifiutato con 'query option ... is not available in this release' (src/asqueel/application_table.py:44); setJoinCondition solleva (src/asqueel/application_table.py:80-81); jc_<nome> rifiutati per nome (src/asqueel/application_table.py:397-399); prova su tutti e tre

In asqueel

query(relationDict=...) rifiutato con 'query option ... is not available in this release' (src/asqueel/application_table.py:44, prova); src/asqueel/compiler.py:125 cpl.relationDict contiene solo i path risolti in uscita

In asqueel

getRelation, getJoiner, relations_one, relations_many, manyRelationsList sollevano 'not available in this release' su DbTableObj e su SqlTable (src/asqueel/object_tree.py:334-336). getRelationBlock, resolveRelationPath, oneRelationsList danno AttributeError generico (prova). Esiste solo il metodo privato src/asqueel/table_crud.py:167 _relations_many

In asqueel

relationExplorer solleva 'not available in this release' su DbTableObj e su SqlTable (src/asqueel/object_tree.py:335, prova)

In asqueel

Nessun elemento aliasTable: la chiamata dà AttributeError generico (prova); i nodi aliasTable e table_alias di una source sono rifiutati (src/asqueel/configuration.py:121-123). Il caricatore legacy traduce table_aliases in virtualRelation(relation=...) (src/asqueel/legacy_source.py:98-100), che si risolve solo dentro aggr: @alias.col dà 'Relation @alias not found' (src/asqueel/compiler.py:354, prova)

In asqueel scrivi

pkg = root.packages().package('sales', sqlschema='crm', sqlprefix='c')

In asqueel ottieni

src/asqueel/model_elements.py:38 package(name, sqlschema, sqlprefix, name_full, path, ...) sotto db.packages(); schema del package src/asqueel/object_tree.py:150 (default 'public', 'main' su SQLite); prefisso src/asqueel/object_tree.py:155; sqlschema/sqlname della tabella src/asqueel/object_tree.py:256 e :260. Prova: package 'sales' dà sales_inv in public; sqlprefix='c' e sqlname='customers' danno customers in crm. tenant_schema non esiste: l'attributo multi_tenant della tabella è rifiutato come fuori grammatica (src/asqueel/builder.py:365)

In asqueel scrivi

tbl = pkg.table('category', pkey='id', name_long='Category')

In asqueel ottieni

src/asqueel/elements.py:166 firma chiusa (pkey, caption_field, name_*, rowcaption, newrecord_caption, order_by, lookup, sqlname, sqlschema, deletable, lastTS, logicalDeletionField, draftField, protectionColumn, x_table_class) più la famiglia partition_*; ogni altra chiave solleva ValueError che nomina attributo ed elemento (src/asqueel/builder.py:365). Prova: hierarchical, xtd, multi_tenant, group_x, x_custom, my_attr rifiutati

In asqueel scrivi

tbl = pkg.table('invoice', pkey='id', partition_company_id='company_id')

In asqueel ottieni

Famiglia di attributi partition_ della tabella (src/asqueel/elements.py:164); filtro getPartitionCondition in src/asqueel/compiler.py:876: current_<path> dà $<campo> = :env_current_<path>, altrimenti allowed_<path> dà IS NULL o IN, altrimenti nessun filtro; conta il primo attributo. Manca il ripiego sulla colonna __allowed_partition. Le scritture non leggono la partizione, come nel legacy (prova: insert con current_tenant='a' lascia tenant NULL)

In asqueel scrivi

tbl.column('status', validate_values='o:Open,c:Closed', print_width=10)

In asqueel ottieni

format e print_width dichiarati (src/asqueel/elements.py:272), letti da attributes e da column.print_width (src/asqueel/object_tree.py:348, senza setter); encrypted solleva UnsupportedFeatureError (src/asqueel/builder.py:415); ogni altro attributo (values, cell_*, template_*, x_*) solleva ValueError (src/asqueel/builder.py:365). values si scrive validate_values

In asqueel scrivi

grp = tbl.colgroup('addr', name_long='Address', col_dtype='T')
grp.column('street')

In asqueel ottieni

src/asqueel/model_elements.py:26; group 'nome.NNN' (src/asqueel/builder.py:496); col_* solo per i parametri dichiarati di column (src/asqueel/builder.py:500 e :520). Prova: le colonne ricevono group addr.001 e addr.002 e il dtype da col_dtype; nessun group_<nome> sulla tabella, nessun colgroup_label o colgroup_name_long sulle colonne; colgroup_label come argomento solleva ValueError

In asqueel scrivi

tbl.compositeColumn('identity', columns='code,year', unique=True)

In asqueel ottieni

src/asqueel/elements.py:408 nella collezione composites, con unique=; dtype JS (src/asqueel/object_tree.py:367); pkey risolta sui membri (src/asqueel/model_source.py:148); letta come valore con la formula '[a, b]' (src/asqueel/compiler.py:219). Prova: fetch di $k dà '[1, 2]' e where $k=:k trova la riga. static= rifiutato come attributo sconosciuto

In asqueel scrivi

tbl.index(['code', 'year'], name='doc_code_year', unique=True)

In asqueel ottieni

src/asqueel/elements.py:446 index(columns, name, unique, method, where, tablespace, with_options); lista o tupla unita con ',' e nome di default legacy (src/asqueel/builder.py:458-464, src/asqueel/common.py:88). Un solo argomento posizionale (src/asqueel/builder.py:170): index('a', 'b', True) solleva TypeError. method, where, tablespace, with_options sono in più rispetto al legacy

In asqueel scrivi

class Table:
    def config_db(self, pkg):
        tbl = pkg.table('invoice', pkey='id')

In asqueel ottieni

Table.config_db(self, pkg) di model/<tabella>.py eseguito in ordine alfabetico da src/asqueel/package_layout.py:69; config_db_<pkg> e config_db_custom su Table sollevano UnsupportedFeatureError (src/asqueel/package_layout.py:66-68). Accanto resta la ricetta main(self, root) (src/asqueel/builder.py:123) con override tramite builder.contribution (src/asqueel/builder.py:181)

In asqueel scrivi

model.table('nope.t')
model.table('sales.nope')

In asqueel ottieni

model.table con package sconosciuto restituisce None (src/asqueel/object_tree.py:465); tabella sconosciuta di un package noto: ValueError 'Unknown table' (src/asqueel/object_tree.py:143), nel legacy GnrSqlMissingTable; colonna sconosciuta: None (src/asqueel/object_tree.py:298); model.column con package sconosciuto: ValueError (src/asqueel/object_tree.py:473), nel legacy AttributeError su None. Percorsi @ e AliasColumnWrapper come nel legacy

In asqueel scrivi

tbl = pkg.table('doc', pkey='identity')
tbl.compositeColumn('identity', columns='code,year')

In asqueel ottieni

pkey restituisce il nome della compositeColumn o la colonna (src/asqueel/object_tree.py:252); pkeys è la lista dei membri o [pkey] (src/asqueel/object_tree.py:264); pkey='a,b' su tabella di package solleva ValueError (src/asqueel/model_source.py:145). Prova: pkey 'k', pkeys ['a', 'b']. Senza pkey: None e [] (legacy '' e lista vuota con log critico)

In asqueel scrivi

label = tblobj.name_long

In asqueel ottieni

src/asqueel/object_tree.py:88-97 stessi ripieghi (name_short su name_long e poi sul nome; name_full su name_long); name_plural su name_long (src/asqueel/object_tree.py:284); name_full attributo di package, tabella e colonna. Nessun setter: prova, assegnare name_long solleva AttributeError

In asqueel scrivi

pkg.options().type('money', dtype='N', size='14,2')

In asqueel ottieni

Nel layout legacy Package.custom_type_<dtype>() dà gli attributi della colonna, dtype preso dal risultato e attributi espliciti vincenti (src/asqueel/package_layout.py:76-91); nella ricetta options().type(name, dtype, size, ...) (src/asqueel/model_elements.py:84) risolto in src/asqueel/model_source.py:115. Un dtype sconosciuto solleva ValueError (prova: 'app.t.p: unknown dtype'), nel legacy resta come stringa

In asqueel scrivi

tbl.column('qty', dtype='L', sql_default='0', sql_sqlite_default='1')

In asqueel ottieni

Colonna sql_default, sql_extra, sql_generatedExpression (src/asqueel/elements.py:266-268) e varianti di dialetto sql_pg_* e sql_sqlite_* che vincono sul loro dialetto (src/asqueel/common.py:35); proiettati verso asqueel-migration con le chiavi legacy sqldefault, extra_sql, generated_expression (src/asqueel/common.py:28). Prova: sqldefault, extra_sql, generated_expression e sql_mysql_default rifiutati

In asqueel scrivi

pkg = root.packages().package('sales', path='/path/to/sales')

In asqueel ottieni

package(name, path=<cartella>) (src/asqueel/model_elements.py:38) caricato da src/asqueel/package_layout.py:41: config_attributes() sotto gli attributi scritti sull'elemento, Table.config_db(pkg) in ordine alfabetico, classe di runtime Table più SqlTable. Package.config_db, onBuildingDbobj e la Table di main.py sollevano UnsupportedFeatureError (src/asqueel/package_layout.py:55-60); custom.py, _packages e plugin non sono letti

In asqueel scrivi

tbl.formulaColumn('label', sql_formula='$code')

In asqueel ottieni

src/asqueel/elements.py:346; senza dtype vale 'A' (src/asqueel/object_tree.py:369, prova); src/asqueel/model.py:49-52 vuole esattamente uno fra sql_formula, select, exists e rifiuta sql_formula insieme a select/exists; :62-63 select_<nome>/exists_<nome> senza sql_formula danno errore; :64-66 un select_<nome> non usato nella formula dà errore (prova)

In asqueel scrivi

tbl.subQueryColumn('codes', query=dict(table='app.invoice', columns='$code',
                   where='$customer_id=#THIS.id'), mode='json')

In asqueel ottieni

src/asqueel/elements.py:368; src/asqueel/compiler.py:183-199: query= come legacy, mode solo None, 'json', 'xml'; un altro mode dà ValueError che rimanda ad aggr; mode='xml' con query stringa rifiutato; :341-345 json/xml tramite l'adapter (src/asqueel/adapters/postgres.py:113); su SQLite json/xml rifiutati prima dell'esecuzione (src/asqueel/adapters/sqlite.py:191-192, prova)

In asqueel scrivi

tbl.compositeColumn('identity', columns='code,year')
tblobj.query(columns='$identity').fetch()

In asqueel ottieni

src/asqueel/compiler.py:200-202 e :219-230 stessa formula stringa del legacy; dtype JS (src/asqueel/object_tree.py:366-367); pkey composta letta e filtrata con la stessa formula (tests/test_formula_columns_legacy.py:75, :80). Differenza: src/asqueel/elements.py:408 non accetta static, e '*' non include la compositeColumn (src/asqueel/compiler.py:805-808, prova)

In asqueel scrivi

def formulaColumn_labels(self):
    return dict(name='loud', sql_formula='upper($code)', dtype='T')

In asqueel ottieni

src/asqueel/object_tree.py:224-245 chiama i metodi senza argomenti, dict o lista di dict, attributi in cache in currentEnv['_virtual_columns_<pkg>_<tbl>']; src/asqueel/compiler.py:158-159 le legge dopo le virtuali dichiarate. Differenza: un nome già dichiarato dà ValueError 'redefines a declared column' (src/asqueel/object_tree.py:239-240, prova)

In asqueel scrivi

tbl.column('customer_id').relation('customer.id')

In asqueel ottieni

src/asqueel/model_source.py:155-157 completa 'tbl.col' con il package corrente quando il primo nome non è un package; src/asqueel/object_tree_relations.py:75-82 legge 'x.y' come pkg.tbl quando x è un package e prende la pkey del target; src/asqueel/validators.py:261-265 rifiuta 'tbl' da solo

In asqueel scrivi

tbl.column('customer_id').relation('customer.id', foreign_key=True)

In asqueel ottieni

src/asqueel/elements.py:470 relation(to, foreign_key=, case_insensitive=); mode= rifiutato dalla grammatica chiusa (prova); in un package foreign_key vale True di default e False con cnd (src/asqueel/builder.py:447-451); weak_relation senza FK (src/asqueel/semantic_elements.py:24, src/asqueel/builder.py:438-440); il caricatore legacy traduce mode (src/asqueel/legacy_source.py:115-120). case_insensitive=True non produce lower() nella join, come nel legacy, perché il compilatore confronta il valore con 'Y' (src/asqueel/compiler.py:422, prova)

In asqueel scrivi

tbl.column('customer_id').relation('customer.id', onDelete_sql='C')

In asqueel ottieni

src/asqueel/elements.py:471-473 onDelete, onUpdate, onDelete_sql, onUpdate_sql, deferred; src/asqueel/object_tree_relations.py:35-39 nel joiner, onUpdate_sql 'cascade' di default; src/asqueel/model_source.py:167-171 deferred con setnull; abbreviazioni SQL in src/asqueel/common.py:15; on_delete= rifiutato (prova). Il joiner conserva le azioni in minuscolo e senza spazi, 'no action' diventa None (src/asqueel/object_tree_relations.py:18-25; prova: 'C' diventa 'c'); il legacy le conserva come scritte

In asqueel scrivi

tbl.column('customer_id').relation('customer.id', cnd='$ccode = @customer_id.code')

In asqueel ottieni

src/asqueel/elements.py:483-484 join_on, cnd, between dichiarati; src/asqueel/compiler.py:410-420 sostituiscono la condizione di chiave, join_on prima di cnd (prova); cnd senza FK (src/asqueel/builder.py:448-451, prova); #IN_RANGE dentro cnd rifiutato con 'macro #IN_RANGE is not available in this release' (src/asqueel/compiler.py:429, prova); aggr rifiuta queste relazioni (src/asqueel/compiler.py:604-607). Vale il codice sul commento in src/asqueel/object_tree_relations.py:44, che le dice non eseguite

In asqueel scrivi

lines = dict(table='app.invoice', where='$customer_id=#THIS.id')
customer.subQueryColumn('total', query=lines, aggr='sum($amount)', dtype='N')
customer.subQueryColumn('lines', query=lines, aggr='count()', dtype='L')

In asqueel ottieni

src/asqueel/elements.py:368-369; src/asqueel/compiler.py:193-198: una chiamata della grammatica .aggr() (count, sum, avg, min, max, join, to_json, to_xml) sostituisce le colonne della query; un solo aggregato; aggr con mode dà ValueError; l'order_by della query ordina join, to_json, to_xml (prova)

In asqueel scrivi

customer.formulaColumn('has_big', sql_formula='#big', dtype='B',
    exists_big=dict(table='app.invoice', where='$customer_id=#THIS.id AND $amount > 100'))

In asqueel ottieni

src/asqueel/elements.py:345 famiglia exists_; src/asqueel/model.py:54-61 select_<nome> ed exists_<nome> con lo stesso nome danno errore; src/asqueel/compiler.py:254 #<nome> diventa EXISTS (<sottoquery>)

In asqueel scrivi

db.table('sales.invoice').query(
    columns='$id, @lines.aggr(count() AS line_count, sum($amount) AS amount)')

In asqueel ottieni

src/asqueel/compiler.py:452 expand_many_operations, :523 many_aggr, :627 subquery correlata; src/asqueel/_many_aggregates.py:21 count, sum, avg, min, max, join, to_json, to_xml; order_by ordina join, to_json, to_xml (prova); solo in proiezione: where e order_by rifiutati (src/asqueel/compiler.py:526, prova)

In asqueel scrivi

customer.virtualRelation('direct_invoices', table='app.invoice',
    condition='$customer_id=:var_customer', var_customer='$id')

In asqueel ottieni

src/asqueel/semantic_elements.py:39; src/asqueel/compiler.py:536 ricerca, :566 derivazioni relation= e forma table= (prova su entrambe); ask rifiutato (src/asqueel/compiler.py:577, prova); usabile solo dentro aggr: @nome.col dà 'Relation @nome not found' (prova)

In asqueel scrivi

row.aliasColumn('customer_id', '@invoice_id.customer_id')

In asqueel ottieni

src/asqueel/object_tree_relations.py:127-182 registra una relazione weak sull'alias; src/asqueel/elements.py:332-333 (prova: @alias.name attraversa due join)

In asqueel scrivi

rows = db.table('sales.invoice').query().fetch()

In asqueel

src/asqueel/application_table.py:383 default '*'; columns=None e columns='' sollevano UnsupportedFeatureError 'columns=None is not available in this release' (src/asqueel/application_table.py:385-386, prova)

In asqueel scrivi

rows = db.table('sales.invoice').query(columns='$id, @customer_id.name, @customer_id.city').fetch()

In asqueel

src/asqueel/compiler.py:816-818 UnsupportedFeatureError "column wildcard '*@customer_id' is not available in this release; use * or explicit columns" (prova)

In asqueel scrivi

rows = db.table('sales.invoice').query(where='$closed IS NOT TRUE').fetch()

In asqueel

Nessuna lettura delle condizioni; una chiave env_<tabella>_condition_* nell'ambiente solleva UnsupportedFeatureError all'esecuzione (src/asqueel/runtime.py:433-437, prova)

In asqueel scrivi

rows = db.table('sales.invoice').query(columns='$id', order_by='$id').fetch()

In asqueel

src/asqueel/application_table.py:42-48 in _UNSUPPORTED: UnsupportedFeatureError "query option 'ignoreTableOrderBy' is not available in this release" (src/asqueel/application_table.py:400-403, prova). L'order_by della tabella è applicato (src/asqueel/compiler.py:707-708) ma non si può disattivare. subtable: riga A1.25

In asqueel scrivi

row = db.table('sales.invoice').query(where='$id = :id', id=10).fetchRecord(ignoreMissing=True)

In asqueel ottieni

src/asqueel/application_table.py:426-427 record() solleva UnsupportedFeatureError 'record is not available in this release; use query(...).fetchRecord()' (prova); al suo posto query(...).fetchRecord() (riga A2.27)

In asqueel scrivi

row = db.table('sales.invoice').query(columns='*, $total', where='$code = :code', code='INV-7').fetchRecord()

In asqueel

record() solleva errore (src/asqueel/application_table.py:426-427); lazy, eager, virtual_columns, ignoreMissing, ignoreDuplicate come opzioni di query sono in _UNSUPPORTED (src/asqueel/application_table.py:47) e sollevano UnsupportedFeatureError (prova)

In asqueel scrivi

row = db.table('sales.invoice').query(where='$id = :id', id=10).fetchRecord()
data = dict(row)

In asqueel

Nessun oggetto record: record() solleva errore (src/asqueel/application_table.py:426-427); fetchRecord() restituisce solo la riga NamedList

In asqueel scrivi

row = db.table('sales.invoice').query(where='$id = :id', id=10).fetchRecord()

In asqueel

Nessun oggetto record e nessuna cache: fetchRecord() esegue la query a ogni chiamata

In asqueel scrivi

row = db.table('sales.customer').query(columns='$name', where='$id = :id', id=10).fetchRecord()
total = db.table('sales.customer').query(exclude_logical_deleted=False, exclude_draft=False).count()

In asqueel

src/asqueel/application_table.py:376-379 readColumns, countRecords, recordAs, cachedRecord sollevano UnsupportedFeatureError; db.query in src/asqueel/runtime.py:60; tableCachedData dà AttributeError (prova)

In asqueel scrivi

rows = db.table('sales.invoice').query(where='$total >= :minimum', minimum=100).fetch()

In asqueel

src/asqueel/application_table.py:380-381 sqlWhereFromBag e whereTranslator sollevano UnsupportedFeatureError; db.whereTranslator in src/asqueel/runtime.py:61; opTranslate dà AttributeError (prova)

In asqueel scrivi

rows = db.table('app.doc').query(columns='$id', where="to_tsvector($body) @@ plainto_tsquery(:search)", search='invoice').fetch()

In asqueel

Rifiutate con UnsupportedFeatureError 'macro #<NOME> is not available in this release' (src/asqueel/compiler.py:649-656); tests/test_specific_errors.py:109; tests/object_tree/test_phase4_macros.py:80-83

In asqueel scrivi

tbl.formulaColumn('vat', '$amount * :env_vat_rate', dtype='N')

In asqueel

Rifiutata con UnsupportedFeatureError 'macro #PREF is not available in this release' (src/asqueel/compiler.py:649-656); tests/test_specific_errors.py:109; tests/object_tree/test_phase4_macros.py:80-83

In asqueel scrivi

rows = db.table('sales.customer').query(columns='$name', addPkeyColumn=True).fetch()

In asqueel ottieni

src/asqueel/compiler.py:738-739 aggiunge 'pkey' solo con addPkeyColumn=True; default False (src/asqueel/compiler.py:692); prova: senza opzione la riga non ha 'pkey'

In asqueel scrivi

rows = db.table('sales.invoice').query(where='$total >= :minimum', minimun=100).fetch()

In asqueel ottieni

src/asqueel/application_table.py:408 le kwargs diventano parametri; una kwarg non usata resta parametro, la query parte e src/asqueel/application_table.py:103-112 emette UnusedQueryParameterWarning (src/asqueel/contracts.py:31) con il nome della kwarg e i parametri usati (prova)

In asqueel scrivi

rows = db.table('sales.invoice').query(columns='$id', for_update='NOWAIT').fetch()

In asqueel ottieni

src/asqueel/compiler.py:729 forza bagFields come il legacy; accetta True, 'NOWAIT', 'SKIP LOCKED' (src/asqueel/compiler.py:694-695); rifiuta for_update con distinct o group_by alla costruzione della query (src/asqueel/application_table.py:406-407, prova)

In asqueel scrivi

with db.tempEnv(current_organization=10):
    rows = db.table('app.document').query().fetch()

In asqueel ottieni

src/asqueel/compiler.py:876-891 current_<path>, poi allowed_<path>; valori falsi e contesto mancante non filtrano (prova); manca il ripiego su __allowed_partition

In asqueel scrivi

owner.formulaColumn('within', '#IN_RANGE($id,:low,:high)', var_low=0, var_high=9, dtype='B')

In asqueel ottieni

src/asqueel/compiler.py:258 (#THIS espanso prima della scoperta dei riferimenti), :323 (#THIS nel where delle sottoquery); :261, :746 (#IN_RANGE in formule e WHERE); :747, :827-858 (#PERIOD solo nel WHERE, decodifica di genro_toolbox con workdate e locale). Differenza: #IN_RANGE nella cnd di una relazione dà 'macro #IN_RANGE is not available in this release' (src/asqueel/compiler.py:429, prova)

In asqueel scrivi

with db.tempEnv(user="O'Hara"):
    rows = db.table('app.customer').query(columns='$who').fetch()

In asqueel ottieni

src/asqueel/compiler.py:239-240 e :266-277: stessa sequenza (chiave, fallback, env_<nome>()), solo nella sql_formula di una formulaColumn. Differenze: apici raddoppiati nel valore; senza chiave né metodo ValueError che nomina la chiave; #ENV altrove dà ValueError (src/asqueel/compiler.py:651-652, prova)

In asqueel scrivi

rows = db.table('app.customer').query(columns='$id,#BAG($payload) AS doc', order_by='$id').fetch()

In asqueel ottieni

src/asqueel/compiler.py:716-718 e :279-286 espansi nelle colonne della query principale; src/asqueel/application_table.py:142-150 handleBagColumns dopo fetch, fetchRecord e cursore; tests/test_subquery_aggr_and_macros.py:106, :114. Differenze: un path di relazione (@rel.col) dà ValueError; #BAG fuori dalle colonne dà ValueError (src/asqueel/compiler.py:653-654)

In asqueel scrivi

customer = db.table('sales.customer')
first = customer.query(where='$id = :id', id=1).fetchRecord()
missing = customer.query(where='$id = :id', id=99).fetchRecord(ignoreMissing=True)
lowest = customer.query(order_by='$id').fetchRecord()

In asqueel ottieni

src/asqueel/application_table.py:222-242: una riga restituisce la riga nel formato di fetch(); nessuna riga RecordNotFoundError (:25) o None con ignoreMissing; più righe RecordMultipleRowsError (:29); con order_by esplicito compila con LIMIT 1 e prende la prima (prova); usato dalla rilettura con lock di delete (src/asqueel/table_crud.py:79-84) e da insertOrUpdate (src/asqueel/table_crud.py:66-67)

In asqueel scrivi

query = model.table('app.person').query(
    "#TEMPLATE('${i}: ${n}', $id AS i, $name AS n) AS tag",
    where="#TEMPLATE('${n}!', $name AS n) = :value", sqlparams={'value': 'Ada!'})

In asqueel ottieni

src/asqueel/compiler.py:65-102 espansione nella concatenazione del dialetto (src/asqueel/adapters/base.py:98, src/asqueel/adapters/sqlite.py:206); NULL diventa testo vuoto; $$ è un $ letterale; usata in sql_formula (:246) e in colonne, where, order_by, group_by, having (:712-714); tests/test_template_macro.py:71, :76, :84, :98

In asqueel scrivi

customer.sql_insert([{"id": 11, "name": "Grace"}, {"id": 12, "name": "Alan"}])
customer.sql_update({"id": 11, "name": "Grace Hopper"})
customer.sql_delete({"id": 12})

In asqueel ottieni

Assenti (prova: AttributeError). Al loro posto src/asqueel/application_table.py:434-477 sql_insert (record o lista), sql_update, sql_delete: solo SQL, nessun _onDbChange, nessun controllo require_write_capabilities (prova: sql_insert riuscito su una tabella con colonna default); chiavi mancanti assegnate con checkPkey, interi consecutivi nella lista (src/asqueel/application_table.py:453-468); lista: un executemany per gruppo di record consecutivi con le stesse colonne (src/asqueel/write_compiler.py:136-150); tests/write_compiler/test_write_compiler.py:266, :259; tests/test_record_writes_legacy.py:103

In asqueel scrivi

deleted = tbl.query(where="$total < :minimum", minimum=10).sql_delete()

In asqueel ottieni

Assente (prova: AttributeError). Al suo posto query(...).sql_delete(): src/asqueel/application_table.py:244-249, un solo DELETE ... WHERE (pk) IN (SELECT della query) con filtri, ordine e limit della query (src/asqueel/write_compiler.py:227-231, :275-282); restituisce il numero di righe (src/asqueel/application_table.py:251-255); group_by e having rifiutati; tests/write_compiler/test_write_compiler.py:227, :253

In asqueel scrivi

rows = tbl.query(where="$status = :s", s="closed").delete()

In asqueel ottieni

Assente (prova: AttributeError). Al suo posto query(...).delete(): src/asqueel/application_table.py:264-272 rilegge le righe con tutte le colonne fisiche, bagFields e for_update (src/asqueel/application_table.py:292-302), poi delete() per ogni riga con la chiave come stringa, così una riga già tolta da una cascata è saltata; restituisce le righe; filtri di default della query (bozze e righe cancellate logicamente escluse), mentre deleteSelection le include per default (prova); group_by e having rifiutati; tests/test_selection_writes_legacy.py:82

In asqueel

Assente (prova: AttributeError). query(...).update(updater) copre l'updater dict o callable (riga A5.31); query(...).sql_update() scrive senza hook (riga A5.19)

In asqueel

Assente (prova: AttributeError)

In asqueel

Assenti (prova: AttributeError); una colonna con default o default_from blocca la scrittura (src/asqueel/model_source.py:251, prova: 'write execution of n.default is not available in this release')

In asqueel

Assente (prova: AttributeError)

In asqueel

Nessun _onDbChange (prova: AttributeError sul database). totalizer_<x>, logChanges e notify rifiutati dalla grammatica della tabella come attributi non dichiarati (prova)

In asqueel

Assenti (prova: AttributeError). La proprietà draftField esiste (src/asqueel/object_tree.py:280)

In asqueel

Assenti (prova: AttributeError)

In asqueel

Uno storename in ambiente diverso da '_main_db' solleva UnsupportedFeatureError "environment key storename=...: database stores are not available in this release" (src/asqueel/runtime.py:123-126; prova con 'other' e '*'); execute(storename=...) solleva 'storename is not available in this release' (:203-206). use_store, currentStorename, connection, connectionKey, get_dbname assenti (prova)

In asqueel

Assenti su db e su tabella: hasattr restituisce False (prova)

In asqueel

db.listen e db.notify assenti (prova). L'attributo di tabella notify è rifiutato dalla grammatica con ValueError "Element 'table' does not accept 'notify'" (prova). src/asqueel/db_write.py:5 esclude _onDbChange e NOTIFY dal ciclo di scrittura

In asqueel scrivi

record = customer.insert({"id": 3, "name": "Katherine"})

In asqueel ottieni

src/asqueel/table_crud.py:31-34 delega a db.insert e restituisce il record; src/asqueel/db_write.py:21-33 stesso ordine senza trigger di package, dbo_onInserting e _onDbChange; una tabella con dichiarazioni non eseguite è rifiutata prima degli hook (src/asqueel/db_write.py:22, src/asqueel/model_source.py:231); tests/write_compiler/test_write_cycle.py:130

In asqueel scrivi

customer.update(record, old_record)
customer.update({"id": 3, "name": "Katherine Johnson"})

In asqueel ottieni

src/asqueel/table_crud.py:36-47; src/asqueel/db_write.py:35-54; chiave da old_record, poi pkey, poi record (src/asqueel/write_compiler.py:186-193); pkey composta come stringa serializzata con toTypedJSON, tupla o mapping rifiutati con ValueError (src/asqueel/write_compiler.py:253-264); nessuno storename; storename e altri kwargs accettati e ignorati (prova: update(record, foo=1, storename='x') riuscito); riga mancante: nessun errore, come il legacy (prova); tests/write_compiler/test_write_cycle.py:146; tests/test_record_writes_legacy.py:66

In asqueel scrivi

db.table("sales.line").delete({"id": 101})

In asqueel ottieni

src/asqueel/table_crud.py:49-58 stringa riletta con for_update fuori dai filtri di bozza, cancellazione logica e partizione (src/asqueel/table_crud.py:78-85), stringa mancante: ritorno senza errore; dict cancellato com'è, senza rilettura; src/asqueel/db_write.py:68-72 il DELETE deve togliere una riga, altrimenti RecordNotFoundError (prova su dict mancante); WHERE col sqlname (src/asqueel/write_compiler.py:266-273); deletable solo bool (src/asqueel/elements.py:177), una stringa è rifiutata dal validatore (prova); tests/write_compiler/test_write_cycle.py:171, :176, :189, :194; tests/test_record_writes_legacy.py:115

In asqueel scrivi

def protect_draft(self, record):
    return record.get("status") != "confirmed"

In asqueel ottieni

src/asqueel/db_write.py:29 e :43-44 protect_draft chiamato direttamente, in update prima dei contatori; src/asqueel/db_write.py:77-82 solo se draftField e il metodo esistono; la cascata dell'archiviazione logica, che il legacy esegue in dbo_onUpdating, è nella stessa posizione (src/asqueel/db_write.py:45-48); nessun dbo_* chiamato

In asqueel scrivi

trigger = self.currentTrigger
parent = trigger.parent

In asqueel ottieni

src/asqueel/triggers.py:9-17 stessi campi, nessun level; pop in finally (src/asqueel/triggers.py:52-57); src/asqueel/runtime.py:231-242; src/asqueel/application_table.py:429-432; tests/write_compiler/test_write_cycle.py:139. I comandi sql_* non entrano nello stack, come i raw legacy

In asqueel scrivi

raise self.exception("protect_update", record=record, msg="locked")

In asqueel ottieni

src/asqueel/table_triggers.py:67-77: stesso EXCEPTIONS (src/asqueel/errors.py:69-77), nome sconosciuto ValueError; rowcaption è il valore della pkey (src/asqueel/table_triggers.py:74-76); nessun localizer. Prova: 'The record 1 in table app.t is not updatable: locked'

In asqueel scrivi

columns.column("invoice_id").relation("sales.invoice.id", onDelete="cascade")

In asqueel ottieni

src/asqueel/table_crud.py:185-207 stesse azioni, default ignore (:188), messaggio dopo ':' (tests/write_compiler/test_write_cycle.py:200); forme brevi rifiutate dal validatore con 'invalid onDelete' (src/asqueel/validators.py:297-301, prova); nessun subtable né dbstore; tests/write_compiler/test_write_cycle.py:176

In asqueel scrivi

columns.column("invoice_id").relation("sales.invoice.id", onUpdate="raise")

In asqueel ottieni

src/asqueel/table_crud.py:222-243: continue alla relazione successiva (:231-232); raise con 'save' (:236-238, prova: SaveException 'Record referenced in table app.u'); setnull ignorato come nel legacy (prova); forme brevi rifiutate dal validatore (src/asqueel/validators.py:297-301); senza old_record ValueError esplicito (src/asqueel/table_crud.py:228-229, tests/write_compiler/test_write_cycle.py:207); cascade in tests/write_compiler/test_write_cycle.py:163

In asqueel scrivi

record = customer.insert({"name": "Ada"})

In asqueel ottieni

src/asqueel/table_crud.py:96-144 stesso ordine delle strategie; composta con toTypedJSON come il legacy (src/asqueel/table_crud.py:125); UUID da genro_toolbox get_uuid (:132, :143); __syscode senza sysRecord_<codice> (:138-141); una pkey con sql_default resta al database (src/asqueel/table_crud.py:104, :111-114). Prova: chiave 1, 2 su intero, 'Z0G7...' di 22 caratteri su testo, 'ABC_______' da __syscode su size 10; tests/test_record_writes_legacy.py:50, :57

In asqueel scrivi

tbl.insert({"id": 1, "data": Bag(dict(a=1))})

In asqueel ottieni

src/asqueel/write_compiler.py:117-118 la Bag diventa to_xml() di genro_bag, la Bag vuota NULL; tests/test_record_writes_legacy.py:92. Prova: una Bag con a=1 è scritta come '<a>1</a>', senza la radice GenRoBag e gli attributi di tipo del toXml legacy

In asqueel scrivi

result = customer.insertOrUpdate(record)

In asqueel ottieni

src/asqueel/table_crud.py:60-70 cerca la pkey con for_update e i filtri di default della query (fetchRecord con ignoreMissing), poi insert o update con la riga letta come old_record; pkey composta come stringa serializzata (src/asqueel/application_table.py:411-424); restituisce il record anche dopo l'update, dove il legacy restituisce None (gnrpy/gnr/sql/gnrsqltable/crud.py:263); tests/test_record_writes_legacy.py:75, :82

In asqueel scrivi

old = dict(invoice.query(columns="*", where="$id=:pk", pk="o1").fetchRecord())
invoice.update({**old, "__del_ts": datetime.now()}, old_record=old)

In asqueel ottieni

src/asqueel/table_crud.py:209-220 archiveRelatedRecords: relazioni con onDelete cascade la cui tabella figlia ha logicalDeletionField, scritte con query(...).update() al posto di batchUpdate, quindi ricorsiva; chiamata da src/asqueel/db_write.py:45-48 quando un update con old_record cambia il campo; nessun hook onArchivingRecord da ridefinire (prova: AttributeError), nessun salto dei dbstore, nessun restoreUnifiedRecord; tests/test_selection_writes_legacy.py:97, :107, :116

In asqueel scrivi

db.currentEnv = {"user": "ada"}
snapshot = db.current_env

In asqueel ottieni

src/asqueel/runtime.py:147-166; src/asqueel/environment.py:108-118 dict per thread, il setter solleva TypeError se il valore non è un dict (prova: 'currentEnv must be a dictionary'). current_env in più restituisce una copia in sola lettura senza le code differite e _pendingExceptions (src/asqueel/environment.py:100-106)

In asqueel scrivi

locale = db.locale

In asqueel ottieni

src/asqueel/runtime.py:168-184; src/asqueel/environment.py:120-134 stesso fallback per workdate; locale da GNR_LOCALE o locale.getlocale() senza validazione. Prova: con locale di sistema 'C' asqueel restituisce 'C'; un identificativo 'xx_INVALID' resta tale

In asqueel scrivi

with db.tempEnv(connectionName="worker"):
    customer.insert(record)

In asqueel ottieni

src/asqueel/runtime.py:38-42 e :128-140 stato per thread e per nome; apertura a :452-456. Un nome può avere una connessione dichiarata con un altro database fisico (src/asqueel/application.py:78-86; src/asqueel/configuration.py:306-320); con dichiarazioni esplicite un nome non dichiarato dà ValueError 'Unknown named connection' (:319, prova). Le operazioni sulla connessione devono avvenire nel thread che l'ha creata (src/asqueel/runtime.py:414-416)

In asqueel scrivi

db.commit()

In asqueel ottieni

src/asqueel/runtime.py:264-267 e :520-551 stesso ordine sulla sola connessione selezionata, poi onDbCommitted (riga A6.15). Dentro una scrittura o un hook, commit sulla connessione in uso solleva TransactionStateError (:259-262, prova); su un'altra connessione con nome è consentito (prova)

In asqueel scrivi

db.rollback()

In asqueel ottieni

src/asqueel/runtime.py:296-298; _finish svuota code differite ed eccezioni pendenti della connessione (:494-518, :409-412), come rollbackAll. rollbackAll assente (prova): rollback ha già il suo effetto sull'unico store. Rifiutato dentro una scrittura come il commit (:259-262). Prova: callback registrata e poi rollback non parte al commit successivo

In asqueel scrivi

db.execute("INSERT INTO bad_table VALUES (1)")

In asqueel ottieni

src/asqueel/runtime.py:463-465 e :469-478 rollback e rilancio dell'errore originale; lo stesso per un errore durante la lettura dal cursore (:631-640). Se il rollback fallisce la connessione viene scartata (:506-513). Svuota anche le code differite (riga A6.9). Prova: errore SQL dopo un insert, la riga non resta

In asqueel scrivi

try:
    customer.insert(record)
except ValueError:
    db.rollback()

In asqueel ottieni

src/asqueel/runtime.py:300-318 _write_operation marca la connessione rollback-only; commit, deferToCommit e nuove istruzioni rifiutati finché non si chiama rollback (:428-431; prova: 'Connection is rollback-only; call rollback before reuse')

In asqueel scrivi

self.db.deferredRaise(ValueError("stock below zero"))

In asqueel ottieni

src/asqueel/runtime.py:254-257 e :373-377 (TypeError se non è un'eccezione, prova); lista per connessione con nome in currentEnv['_pendingExceptions__main_db_<connectionName>'] (:348-355); :530-536 DeferredCommitError, lista svuotata e connessione rollback-only. Prova: secondo commit dà TransactionStateError, rollback la svuota

In asqueel scrivi

cursor = db.execute("SELECT id FROM t", cursorname="*")
rows = cursor.fetchall()

In asqueel ottieni

src/asqueel/runtime.py:195-216 stessa firma, restituisce SqlCursor (:586-655: description, rowcount, arraysize, fetchone, fetchmany, fetchall, iterazione, close; righe NamedList lette per nome). sql è una stringa o una CompiledQuery. cursorname apre un cursore server su PostgreSQL ('*' genera il nome, :211-212), SQLite lo ignora (prova). dbtable accettato senza effetto. storename, cursor e _adaptArguments=False sollevano UnsupportedFeatureError (:203-206, prova)

In asqueel scrivi

db.execute(sql, autocommit=True)

In asqueel ottieni

execute(autocommit=True) chiama db.commit() dopo l'istruzione (src/asqueel/runtime.py:214-215; prova: la riga resta dopo closeConnection). Una connessione autocommit è rifiutata: connect_kwargs autocommit dà ValueError (:76-77, :454-455, prova), anche nell'adapter PostgreSQL (src/asqueel/adapters/postgres.py:32-33)

In asqueel scrivi

db.closeConnection()

In asqueel ottieni

src/asqueel/runtime.py:320-346 rollback e chiusura di tutte le connessioni del thread, chiusura dei cursori aperti (:485-492); il database resta usabile (prova). Dentro una scrittura solleva TransactionStateError (:326-327, prova); il primo errore di pulizia viene rilanciato dopo aver chiuso le altre (:335-346, prova)

In asqueel scrivi

customer.lock(mode="SHARE", nowait=True)

In asqueel ottieni

src/asqueel/table_crud.py:72-76 table.lock(mode='ACCESS EXCLUSIVE', nowait=False); src/asqueel/write_compiler.py:233-247: PostgreSQL LOCK ... IN <mode> MODE con NOWAIT; un modo non PostgreSQL dà ValueError (prova); SQLite prende il lock di scrittura con un UPDATE senza effetto (prova)

In asqueel scrivi

customer.query(where="$id = :id", id=1, for_update="SKIP LOCKED").fetch()

In asqueel ottieni

src/asqueel/compiler.py:694-695 for_update vale True, 'NOWAIT' o 'SKIP LOCKED', altrimenti ValueError (prova); PostgreSQL aggiunge il modo dopo FOR UPDATE OF (src/asqueel/adapters/base.py:138-139); SQLite rifiuta un modo stringa con UnsupportedFeatureError 'for_update=NOWAIT is not available on SQLite' (src/asqueel/adapters/sqlite.py:215-218, prova). for_update=True: riga A2.12

In asqueel scrivi

customer.query(where="$id = :id", id=1, for_update=True).fetch()

In asqueel ottieni

src/asqueel/adapters/sqlite.py:54-57 isolation_level='DEFERRED': BEGIN prima della prima INSERT, UPDATE o DELETE, le letture non aprono transazione (prova); :111-121 for_update prende il lock di scrittura (BEGIN IMMEDIATE, o un UPDATE senza effetto in una transazione aperta); FK attive di default (:61, riga A8.8)

In asqueel scrivi

db.setConstraintsDeferred()

In asqueel ottieni

src/asqueel/runtime.py:278-280; PostgreSQL SET CONSTRAINTS ALL DEFERRED nella transazione corrente (src/asqueel/adapters/base.py:219-221); SQLite PRAGMA defer_foreign_keys = ON (src/asqueel/adapters/sqlite.py:93-95)

In asqueel scrivi

db.analyze()
db.vacuum(full=True)

In asqueel ottieni

src/asqueel/runtime.py:282-294; analyze nella transazione corrente (src/asqueel/adapters/base.py:223-225). vacuum con lavoro pendente nel thread solleva TransactionStateError (prova); PostgreSQL VACUUM [FULL] ANALYZE su una connessione autocommit separata (src/asqueel/adapters/postgres.py:42-49); SQLite VACUUM sul file principale e su ogni schema collegato, poi ANALYZE (src/asqueel/adapters/sqlite.py:97-109)

In asqueel scrivi

user = self.db.currentUser

In asqueel ottieni

src/asqueel/runtime.py:157-159 solo il valore user di currentEnv; nessun ricorso alla pagina. Usato dal trigger dei campi utente (src/asqueel/table_triggers.py:59)

In asqueel scrivi

record = customer.insert({"name": "Ada"})
created = record["created_ts"]

In asqueel ottieni

src/asqueel/write_compiler.py:284-309 colonne con sql_value, sql_generatedExpression, sql_default omessa o dtype serial; src/asqueel/db_write.py:84-89 scritte nel record prima dei trigger after; anche sql_insert di un solo record (src/asqueel/application_table.py:446-450); solo con la capability returning_insert, dichiarata da entrambi gli adapter (src/asqueel/adapters/sqlite.py:32-35, src/asqueel/adapters/postgres.py:20-23): RETURNING su PostgreSQL e su SQLite (prova); tests/write_compiler/test_write_compiler.py:73; tests/write_compiler/test_write_cycle.py:130

In asqueel scrivi

changed = db.table("sales.invoice").query(
    where="$total >= :minimum", minimum=100,
).sql_update({"note": "Reviewed"})

In asqueel ottieni

src/asqueel/application_table.py:257-262 un solo UPDATE ... WHERE (pk) IN (SELECT della query) (src/asqueel/write_compiler.py:206-225); group_by e having rifiutati (src/asqueel/application_table.py:304-309); parametri condivisi fra query e valori rifiutati (src/asqueel/write_compiler.py:275-278); tests/write_compiler/test_write_compiler.py:227, :246

In asqueel scrivi

pkeys = db.table("sales.invoice").query(
    where="$total >= :minimum", minimum=100,
).update({"note": "Reviewed"})

In asqueel ottieni

src/asqueel/application_table.py:274-290 rilegge le righe con tutte le colonne fisiche, bagFields e for_update (src/asqueel/application_table.py:292-302), applica l'updater dict o callable a una copia della riga e chiama update(record, old_record=<riga letta>); restituisce le pkey aggiornate; group_by e having rifiutati; tests/test_selection_writes_legacy.py:66, :74

In asqueel scrivi

from asqueel import session

with session(db, user="scheduler"):
    db.table("sales.customer").insert({"id": 5, "name": "Batch"})
    db.commit()

In asqueel ottieni

src/asqueel/runtime.py:666-691: all'ingresso clearCurrentEnv e updateEnv(**env), all'uscita closeConnection anche quando il corpo solleva; una sessione annidata sullo stesso thread solleva TransactionStateError (prova); esportata da asqueel (src/asqueel/__init__.py:53). L'host prende un database aprendo la sessione (src/asqueel/hosting.py:110-115)

In asqueel scrivi

db.table('app.counter').sql_insert([{'text': 'a'}, {'text': 'b'}])

In asqueel ottieni

insertMany assente (prova). Al suo posto sql_insert con una lista (src/asqueel/application_table.py:434-450): un executemany per gruppo di record consecutivi con le stesse colonne (src/asqueel/write_compiler.py:136-151), senza RETURNING; le pkey mancanti sono assegnate prima (src/asqueel/application_table.py:453-468), interi consecutivi in una lista (prova: [1, 2, 10, 11]); executemany dell'adapter in src/asqueel/adapters/base.py:200-205 e src/asqueel/adapters/sqlite.py:129-133; test tests/write_compiler/test_write_compiler.py:259, tests/test_record_writes_legacy.py:103

In asqueel

Assenti: db.listen, db.notify e i metodi corrispondenti dell'adapter non esistono (prova). src/asqueel/db_write.py:5 esclude NOTIFY dal ciclo di scrittura; riga A6.16

In asqueel scrivi

plan = db.migration_plan()
db.migrate()

In asqueel ottieni

Metodi assenti su db e adapter (prova). Al loro posto asqueel-migration: db.migration_plan() e db.migrate() (src/asqueel/application.py:104-125) e la CLI asqueel db plan e db apply; l'adapter PostgreSQL di asqueel-migration crea il database mancante (docs/guide/cli.md:115-117); su SQLite la connessione crea il file e la cartella (src/asqueel/adapters/sqlite.py:51-53)

In asqueel

Assenti: un'implementazione diversa da sqlite, postgres e postgres3 solleva ModuleNotFoundError al caricamento (src/asqueel/runtime.py:68-73; prova con 'mssql'). Il pacchetto di migrazione ha adapter MySQL e SQL Server solo per il DDL (docs/guide/cli.md:141-144)

In asqueel scrivi

db = Database(implementation='postgres')
with db.tempEnv(currentImplementation='postgres'):
    adapter = db.adapter

In asqueel ottieni

src/asqueel/runtime.py:67-73 carica asqueel.adapters.<implementation> oppure il modulo dopo ':' e costruisce SqlDbAdapter(db); src/asqueel/runtime.py:81-86 db.adapter segue currentEnv['currentImplementation'] e carica l'adapter alla prima richiesta; default 'sqlite' (src/asqueel/configuration.py:57, src/asqueel/runtime.py:64); 'postgres' e 'postgres3' caricano lo stesso adapter psycopg 3 (src/asqueel/adapters/postgres3.py:2); un altro nome solleva ModuleNotFoundError (prova con 'postgresql' e 'mssql'); le connessioni nominate usano il dialetto del db (src/asqueel/configuration.py:373-374); test tests/adapters/test_db_adapter.py:10, :23, :53

In asqueel scrivi

db.execute("SELECT ':id' AS v", {'id': 1})

In asqueel ottieni

Solo psycopg 3. src/asqueel/adapters/postgres.py:51-54 espande le collezioni come gnrpostgres3, poi :nome diventa %(nome)s e REGEXP diventa ~* come gnrpostgres; binding lato server del cursore psycopg (src/asqueel/adapters/postgres.py:36-40); SQLite lascia :nome (src/asqueel/adapters/sqlite.py:146-154); \: protetto (src/asqueel/adapters/base.py:149, :156); parametro mancante a None (src/asqueel/adapters/base.py:153-154). Prova: SELECT ':id' con id=1 restituisce '$1' su PostgreSQL e ':id' su SQLite

In asqueel scrivi

db.table('app.item').query('$id', where='$id IN :ids', ids=[1, 2]).fetch()

In asqueel ottieni

SQLite: src/asqueel/adapters/base.py:164-172 stesso algoritmo (nome0, nome1; la lista vuota diventa IN (), che non restituisce righe). PostgreSQL: src/asqueel/adapters/postgres.py:56-81 stesso algoritmo di gnrpostgres3 (nome_0, nome_1; lista vuota sostituita da TRUE o FALSE dopo una colonna "tN"."col", :67-69), con \b che fa corrispondere solo il nome intero del parametro (:80). Collisioni dei nomi generati conservate (tests/adapter_driver/test_legacy_preparation.py:151); un nome prefisso di un altro non lo cattura più (tests/adapter_driver/test_legacy_preparation.py:160); confronto con gli originali in tests/adapter_driver/test_legacy_preparation.py:43; tests/object_tree/test_minimal_select.py:270

In asqueel scrivi

db.table('app.customer').query('$name', where='$name IlIkE :pattern', pattern='ali%')

In asqueel ottieni

src/asqueel/adapters/sqlite.py:20-24 e :150 sostituiscono solo l'operatore ILIKE, in qualsiasi grafia, fuori da stringhe, identificatori quotati e commenti; prova: 'IlIkE' diventa 'lIkE', 'ilike' in una stringa e col_ilike restano invariati; tests/sqlite/test_ilike.py:32, :39, :45

In asqueel scrivi

db.connection(name='/data/shop.db', implementation='sqlite',
              options={'foreignKeys': False, 'timeout': 5})

In asqueel ottieni

src/asqueel/adapters/sqlite.py:56-57 detect_types PARSE_DECLTYPES e PARSE_COLNAMES come legacy; src/asqueel/adapters/sqlite.py:49 timeout 20.0 di default, modificabile insieme a cached_statements (src/asqueel/adapters/sqlite.py:46-48); src/asqueel/adapters/sqlite.py:61 PRAGMA foreign_keys = ON, OFF con l'opzione di connessione foreignKeys=False (src/asqueel/configuration.py:352-353, :392); PostgreSQL rifiuta foreignKeys (src/asqueel/adapters/postgres.py:27-28); test tests/test_sqlite_legacy_connection.py:82, :93, :106

In asqueel scrivi

db.table('app.item').insert({'id': 1, 'price': Decimal('9.90'), 'day': date(2026, 1, 1)})

In asqueel ottieni

src/asqueel/adapters/sqlite.py:76-87 registra i converter date (solo la parte data), time, timestamp, numeric, boolean e bool; src/asqueel/adapters/sqlite.py:135-144 scrive date, datetime e time come stringa ISO (tzinfo conservato) e Decimal come stringa. Prova: D, DH, H, N, B letti come date, datetime, time, Decimal, bool; test tests/sqlite/test_sqlite_legacy_values.py:38

In asqueel scrivi

db.table('app.item').query('$id', for_update=True).fetch()

In asqueel ottieni

src/asqueel/adapters/sqlite.py:54-57 isolation_level DEFERRED: BEGIN differito prima della prima INSERT, UPDATE o DELETE, le letture non aprono transazione, come legacy; src/asqueel/adapters/sqlite.py:111-121 con for_update BEGIN IMMEDIATE se nessuna transazione è aperta, altrimenti un UPDATE senza effetto sulla tabella; nessun FOR UPDATE nel testo (src/asqueel/adapters/sqlite.py:221-222); test tests/sqlite/test_sqlite_legacy_values.py:51, :65

In asqueel scrivi

db.table('app.note').query(columns='$id', for_update='SKIP LOCKED').fetch()

In asqueel ottieni

src/asqueel/compiler.py:694-695 accetta solo True, 'NOWAIT' e 'SKIP LOCKED', ValueError per ogni altro valore (prova con 'FOO'); src/asqueel/adapters/base.py:139 PostgreSQL aggiunge il modo dopo FOR UPDATE OF t0; src/asqueel/adapters/sqlite.py:217-218 SQLite rifiuta i modi stringa con UnsupportedFeatureError (prova con 'SKIP LOCKED'); test tests/test_record_writes_legacy.py:136, :141

In asqueel scrivi

db.table('app.note').lock(mode='SHARE', nowait=True)

In asqueel ottieni

src/asqueel/table_crud.py:72-76 table.lock(mode='ACCESS EXCLUSIVE', nowait=False) esegue lock_table nella transazione corrente; src/asqueel/write_compiler.py:233-245 su PostgreSQL LOCK ... IN <mode> MODE con NOWAIT, modo controllato su LOCK_MODES (src/asqueel/write_compiler.py:23), ValueError per un altro modo; su SQLite la riserva di scrittura con un UPDATE senza effetto (prova: UPDATE "app"."app_item" SET "id"="id" WHERE 0); test tests/test_record_writes_legacy.py:127, tests/write_compiler/test_write_compiler.py:146

In asqueel scrivi

self.db.adapter.mask_field_sql('$email', mode='email')
self.db.adapter.unaccentFormula('$name')

In asqueel ottieni

src/asqueel/adapters/postgres.py:126-128 unaccentFormula come legacy; su SQLite il campo invariato (src/asqueel/adapters/base.py:235-237); mask_field_sql con le espressioni legacy (src/asqueel/adapters/postgres.py:130-184, src/asqueel/adapters/sqlite.py:230-287), un modo non valido solleva ValueError (src/asqueel/adapters/base.py:45-50); ageAtDate come legacy su PostgreSQL (src/asqueel/adapters/base.py:239-246), un timeUnit sconosciuto solleva ValueError, su SQLite UnsupportedFeatureError (src/asqueel/adapters/sqlite.py:227-228); db.whereTranslator rifiutato (src/asqueel/runtime.py:61); colonne variante: riga A3.15; test tests/adapters/test_adapter_functions.py:45, :52, :64, :98

In asqueel scrivi

db.commit()
db.vacuum(table='app.app_item', full=True)

In asqueel ottieni

src/asqueel/runtime.py:282-284 analyze() esegue ANALYZE nella transazione corrente (src/asqueel/adapters/base.py:223-225), come legacy; src/asqueel/runtime.py:286-294 vacuum(table='', full=False) solleva TransactionStateError se il thread ha lavoro pendente, poi delega all'adapter: su PostgreSQL VACUUM [FULL] ANALYZE [table] su una connessione autocommit separata (src/asqueel/adapters/postgres.py:42-49); su SQLite VACUUM su main e su ogni schema allegato, poi ANALYZE [table], su una connessione separata (src/asqueel/adapters/sqlite.py:97-109); test tests/test_execute_and_transactions.py:73, tests/test_read_write_final_touch.py:118, tests/test_sqlite_legacy_connection.py:123

In asqueel scrivi

adapter = PostgresAdapter(db, capabilities=PostgresAdapter.capabilities - {'returning_insert'})

In asqueel ottieni

src/asqueel/adapters/base.py:58 attributo capabilities; src/asqueel/adapters/postgres.py:20-24 e src/asqueel/adapters/sqlite.py:32-36 capability di SQL (select, insert, update, delete, returning_insert, returning_update, returning_delete, left_join, limit, offset, default_values, for_update), riducibili con l'opzione capabilities del costruttore (src/asqueel/adapters/base.py:60-69) e verificate da _require (src/asqueel/adapters/base.py:71-73); nessun has_capability e nessuna capability SCHEMAS, MIGRATIONS, VECTOR, ADMINISTER (prova); test tests/adapter_dialect/test_postgres.py:46

In asqueel scrivi

db.table('app.item').query('$id', limit=0, offset=10).fetch()

In asqueel ottieni

src/asqueel/adapters/base.py:133-137 limit e offset falsi non emettono clausola, come legacy (prova: limit=0 restituisce tutte le righe); src/asqueel/adapters/base.py:117-121 un limit o offset non intero o negativo solleva ValueError; src/asqueel/adapters/sqlite.py:219-220 OFFSET senza LIMIT aggiunge LIMIT 9223372036854775807 (prova)

In asqueel scrivi

tbl.column('note', dtype='X')
tbl.column('code', dtype='A', size='10')

In asqueel ottieni

Il DDL lo produce asqueel-migration 0.3 con i nomi di tipo legacy: PostgreSQL come revTypesDict, SQLite character varying(n), character(n), timestamp, time, blob per O. src/asqueel/projection.py:15-30 proietta X, Z, P e A o C senza size come T senza cambiare la colonna del modello. Prova: A senza size e X diventano text su entrambi i dialetti; DH timestamp su SQLite e timestamp without time zone su PostgreSQL; O blob e bytea. Codici dtype in src/asqueel/elements.py:62-65; lettura inversa PostgreSQL con le voci di typesDict (src/asqueel/importers.py:210-225); test tests/test_sqlite_legacy_connection.py:139, :152

In asqueel scrivi

db.connection(name='/data/shop.db', implementation='sqlite')

In asqueel ottieni

src/asqueel/adapters/sqlite.py:39-40 connect() solleva RuntimeError sotto SQLite 3.35, la versione che introduce RETURNING; RETURNING delle scritture: riga A5.16

In asqueel

src/asqueel/application_table.py:315-316 solleva UnsupportedFeatureError 'selection(): Selection and Bag output are not available in this release' (prova)

In asqueel

Assenti dal ciclo (src/asqueel/db_write.py:6 nel docstring); un metodo trigger_on<Evento>_<pkg> nella classe della tabella è rifiutato con UnsupportedFeatureError (src/asqueel/object_tree.py:173-181, prova); avoid_trigger_<pkg> non esiste

In asqueel

Nessun commento né audit; le chiavi d'ambiente sql_comment e sql_details sollevano UnsupportedFeatureError all'esecuzione (src/asqueel/runtime.py:433-437; prova). debugger assente (prova)