Kaip konvertuoti SqlAlchemy rezultatus į JSON?

„Django“ turi gerą automatizuotą ORM modelių seriją, grąžintą iš DB į JSON formatą.

Kaip serializuoti SQLAlchemy užklausos rezultatą JSON formatu?

Bandžiau jsonpickle.encode , bet ji koduoja užklausos objektą. Aš bandžiau json.dumps(items) , bet jis grįžta

 TypeError: <Product('3', 'some name', 'some desc')> is not JSON serializable 

Ar tikrai sunku serializuoti ORM SQLAlchemy objektus JSON / XML? Ar šiuo atveju nėra numatytojo serializavimo? Tai labai paprasta užduotis, kad ORM užklausos rezultatus serializuotų dabar.

Aš tiesiog turiu grąžinti JSON arba XML reprezentacijos SQLAlchemy užklausos rezultatus.

SQLAlchemy objektų JSON / XML formatu užklausų rezultatas reikalingas naudoti „JavaScript“ duomenų bazėje (JQGrid http://www.trirand.com/blog/ )

129
17 февр. „Zelid“ nustatytas vasario 17 d 2011-02-17 00:04 '11 - 0:04 2011-02-17 00:04
@ 19 atsakymų

Platus įgyvendinimas

Galite naudoti kažką panašaus:

 from sqlalchemy.ext.declarative import DeclarativeMeta class AlchemyEncoder(json.JSONEncoder): def default(self, obj): if isinstance(obj.__class__, DeclarativeMeta): # an SQLAlchemy class fields = {} for field in [x for x in dir(obj) if not x.startswith('_') and x != 'metadata']: data = obj.__getattribute__(field) try: json.dumps(data) # this will fail on non-encodable values, like other classes fields[field] = data except TypeError: fields[field] = None # a json-encodable dict return fields return json.JSONEncoder.default(self, obj) 

ir tada konvertuokite į „Json“ naudodami:

 c = YourAlchemyClass() print json.dumps(c, cls=AlchemyEncoder) 

Jis ignoruos laukus, kurie nėra užkoduoti (nustatykite juos į „Ne“).

Jis automatiškai nepadidina santykių (nes tai gali lemti savęs nuorodą ir ciklą amžinai).

Rekursinis, netiesinis įgyvendinimas

Tačiau, jei norite, kad ciklas būtų amžinai, galite naudoti:

 from sqlalchemy.ext.declarative import DeclarativeMeta def new_alchemy_encoder(): _visited_objs = [] class AlchemyEncoder(json.JSONEncoder): def default(self, obj): if isinstance(obj.__class__, DeclarativeMeta): # don't re-visit self if obj in _visited_objs: return None _visited_objs.append(obj) # an SQLAlchemy class fields = {} for field in [x for x in dir(obj) if not x.startswith('_') and x != 'metadata']: fields[field] = obj.__getattribute__(field) # a json-encodable dict return fields return json.JSONEncoder.default(self, obj) return AlchemyEncoder 

Tada koduokite objektus su:

 print json.dumps(e, cls=new_alchemy_encoder(), check_circular=False) 

Tai koduos visus vaikus ir visus jų vaikus bei visus vaikus ... Galiausiai, iš esmės, koduos visą savo duomenų bazę. Kai jis pasiekia kažką, kuris buvo užkoduotas anksčiau, jis koduoja jį kaip „Ne“.

Rekursinis, galbūt apvalus, selektyvus įgyvendinimas

Kita alternatyva, galbūt geresnė, yra galimybė nurodyti laukus, kuriuos norite išplėsti:

 def new_alchemy_encoder(revisit_self = False, fields_to_expand = []): _visited_objs = [] class AlchemyEncoder(json.JSONEncoder): def default(self, obj): if isinstance(obj.__class__, DeclarativeMeta): # don't re-visit self if revisit_self: if obj in _visited_objs: return None _visited_objs.append(obj) # go through each field in this SQLalchemy class fields = {} for field in [x for x in dir(obj) if not x.startswith('_') and x != 'metadata']: val = obj.__getattribute__(field) # is this field another SQLalchemy object, or a list of SQLalchemy objects? if isinstance(val.__class__, DeclarativeMeta) or (isinstance(val, list) and len(val) > 0 and isinstance(val[0].__class__, DeclarativeMeta)): # unless we're expanding this field, stop here if field not in fields_to_expand: # not expanding this field: set it to None and continue fields[field] = None continue fields[field] = val # a json-encodable dict return fields return json.JSONEncoder.default(self, obj) return AlchemyEncoder 

Dabar galite skambinti naudodami:

 print json.dumps(e, cls=new_alchemy_encoder(False, ['parents']), check_circular=False) 

Pavyzdžiui, išplėsti tik SQLAlchemy laukus, vadinamus „tėvais“.

103
19 мая '12 в 13:05 2012-05-19 13:05 atsakymą pateikė Sasha B gegužės 19, 12 d. 13:05 13:05

Jūs galite tiesiog išleisti savo objektą kaip diktuojamą:

 class User: def as_dict(self): return {c.name: getattr(self, c.name) for c in self.__table__.columns} 

Ir tada naudokite User.as_dict (), kad serializuotumėte savo objektą.

Kaip paaiškinta „sqlalchemy“ eilutės objekto konvertavimas „python dict“

205
09 авг. atsakymas pateikiamas 09 rug . 2012-08-09 16:42 '12 at 4:42 pm 2012-08-09 16:42

RowProxy galite konvertuoti taip:

  d = dict(row.items()) 

Tada serializuokite JSON (jums reikės nurodyti koderį tokiems dalykams kaip datetime ). Ne taip sunku, jei jums reikia tik vieno įrašo (o ne visos susijusių įrašų hierarchijos).

 json.dumps([(dict(row.items())) for row in rs]) 
43
11 авг. Nicko Perkinso atsakymas 11 rug. 2011-08-11 23:20 '11, 23:20, 2011-08-11 23:20

Aš rekomenduoju naudoti naują moliūgų biblioteką. Tai leidžia jums sukurti serializatorius, kurie atstovautų modelių pavyzdžius, palaikant ryšius ir įdėtus objektus.

Pažvelkite į SQLAlchemy pavyzdį .

33
12 мая '14 в 14:31 2014-05-12 14:31 Atsakymą pateikė Yasir Hantoush gegužės 12 d. 14, 14:31 2014-05-12 14:31

„Flask-JsonTools“ pakete yra įdiegta „ JsonSerializableBase“ bazės klasė jūsų modeliams.

Naudoti:

 from sqlalchemy.ext.declarative import declarative_base from flask.ext.jsontools import JsonSerializableBase Base = declarative_base(cls=(JsonSerializableBase,)) class User(Base): #... 

Dabar User modelis yra magiškai serializuojamas.

Jei jūsų sistema nėra kolba, galite tiesiog patraukti kodą

14
06 сент. atsakymą pateikė kolypto 06 sep . 2014-09-06 06:37 '14, 6:37 AM 2014-09-06 06:37

Saugumo sumetimais niekada neturėtumėte grąžinti visų modelių laukų. Aš norėčiau juos pasirinkti pasirinktinai.

Dabar kodavimo kolba „Json“ palaiko UUID, datetime ir ryšius (ir pridėtą query ir query query_class „flask_sqlalchemy db.Model klasei). Aš atnaujinau kodavimo kodą taip:

application / json_encoder.py

  from sqlalchemy.ext.declarative import DeclarativeMeta from flask import json class AlchemyEncoder(json.JSONEncoder): def default(self, o): if isinstance(o.__class__, DeclarativeMeta): data = {} fields = o.__json__() if hasattr(o, '__json__') else dir(o) for field in [f for f in fields if not f.startswith('_') and f not in ['metadata', 'query', 'query_class']]: value = o.__getattribute__(field) try: json.dumps(value) data[field] = value except TypeError: data[field] = None return data return json.JSONEncoder.default(self, o) 

app/__init__.py

 # json encoding from app.json_encoder import AlchemyEncoder app.json_encoder = AlchemyEncoder 

Tai galiu papildomai pridėti __json__ nuosavybę, kuri grąžina laukų, kuriuos noriu koduoti, sąrašą:

app/models.py

 class Queue(db.Model): id = db.Column(db.Integer, primary_key=True) song_id = db.Column(db.Integer, db.ForeignKey('song.id'), unique=True, nullable=False) song = db.relationship('Song', lazy='joined') type = db.Column(db.String(20), server_default=u'audio/mpeg') src = db.Column(db.String(255), nullable=False) created_at = db.Column(db.DateTime, server_default=db.func.now()) updated_at = db.Column(db.DateTime, server_default=db.func.now(), onupdate=db.func.now()) def __init__(self, song): self.song = song self.src = song.full_path def __json__(self): return ['song', 'src', 'type', 'created_at'] 

Mano nuomone, pridedu @jsonapi, grąžinu gautą sąrašą ir tada mano išvaizda atrodo taip:

 [ { "created_at": "Thu, 23 Jul 2015 11:36:53 GMT", "song": { "full_path": "/static/music/Audioslave/Audioslave [2002]/1 Cochise.mp3", "id": 2, "path_name": "Audioslave/Audioslave [2002]/1 Cochise.mp3" }, "src": "/static/music/Audioslave/Audioslave [2002]/1 Cochise.mp3", "type": "audio/mpeg" } ] 
11
22 июля '15 в 19:48 2015-07-22 19:48 Atsakymą įteikė Tjorriemorrie liepos 15 d. 15 val. 19:48 2015-07-22 19:48

Galite naudoti „SqlAlchemy“ introspekciją taip:

 mysql = SQLAlchemy() from sqlalchemy import inspect class Contacts(mysql.Model): __tablename__ = 'CONTACTS' id = mysql.Column(mysql.Integer, primary_key=True) first_name = mysql.Column(mysql.String(128), nullable=False) last_name = mysql.Column(mysql.String(128), nullable=False) phone = mysql.Column(mysql.String(128), nullable=False) email = mysql.Column(mysql.String(128), nullable=False) street = mysql.Column(mysql.String(128), nullable=False) zip_code = mysql.Column(mysql.String(128), nullable=False) city = mysql.Column(mysql.String(128), nullable=False) def toDict(self): return { c.key: getattr(self, c.key) for c in inspect(self).mapper.column_attrs } @app.route('/contacts',methods=['GET']) def getContacts(): contacts = Contacts.query.all() contactsArr = [] for contact in contacts: contactsArr.append(contact.toDict()) return jsonify(contactsArr) @app.route('/contacts/<int:id>',methods=['GET']) def getContact(id): contact = Contacts.query.get(id) return jsonify(contact.toDict()) 

Gaukite įkvėpimo iš atsakymo čia: sqlalchemy eilutės objekto konvertavimas python dict

8
12 сент. Atsakymą pateikė phico 12 Sep. 2017-09-12 18:38 '17, 18:38 pm 2017-09-12 18:38

Išsamesnis paaiškinimas. Į savo modelį pridėkite:

 def as_dict(self): return {c.name: str(getattr(self, c.name)) for c in self.__table__.columns} 

str() python 3, taigi, jei naudojate 2 python, naudokite unicode() . Tai turėtų padėti datų nustatymui. Jį galite ištrinti, jei su jais nesusiję.

Dabar duomenų bazėje galite pateikti užklausą taip:

 some_result = User.query.filter_by(id=current_user.id).first().as_dict() 

First() būtina norint išvengti keistų klaidų. as_dict() dabar deserializuoja rezultatą. Po deserializacijos ji yra pasirengusi Džonsui

 jsonify(some_result) 
4
11 мая '18 в 22:29 2018-05-11 22:29 Patrick Mutuku atsakymas gegužės 11 d. 18 val. 10:29 2018-05-11 22:29

Tai nėra taip baisu. Aš parašiau šį kodą. Aš vis dar dirbau jame naudojama „MochiKit“ struktūra. Jis iš esmės verčia sudėtingus objektus tarp „Python“ ir „Javascript“, naudojant proxy ir registruotus JSON keitiklius.

Duomenų bazių objektų šoninė naršyklė db.js Tam reikia pagrindinio „Python“ tarpinio serverio šaltinio proxy.js .

Python pusėje yra pagrindinis proxy modulis . Tada, galiausiai, „SqlAlchemy“ objekto koduotojas žiniatinklio serveryje.py . Tai taip pat priklauso nuo metaduomenų ištraukų, rastų modeliuose.py .

3
17 февр. Atsakymą pateikė Keithas vasario 17 d. 2011-02-17 01:23 '11 prie 1:23 2011-02-17 01:23

Vartotojo serializavimas ir deserializavimas.

„from_json“ (klasės metodas) sukuria modelio objektą, pagrįstą „Json“ duomenimis.

„deserializuotas“ gali būti vadinamas tik egzemplioriuje ir sujungti visus duomenis iš „Json“ į modelio pavyzdį.

"serialize" - rekursinis serializavimas

__ write_only __ ypatybė reikalinga įrašo savybėms nustatyti (pvz., password_hash).

 class Serializable(object): __exclude__ = ('id',) __include__ = () __write_only__ = () @classmethod def from_json(cls, json, selfObj=None): if selfObj is None: self = cls() else: self = selfObj exclude = (cls.__exclude__ or ()) + Serializable.__exclude__ include = cls.__include__ or () if json: for prop, value in json.iteritems(): # ignore all non user data, eg only if (not (prop in exclude) | (prop in include)) and isinstance( getattr(cls, prop, None), QueryableAttribute): setattr(self, prop, value) return self def deserialize(self, json): if not json: return None return self.__class__.from_json(json, selfObj=self) @classmethod def serialize_list(cls, object_list=[]): output = [] for li in object_list: if isinstance(li, Serializable): output.append(li.serialize()) else: output.append(li) return output def serialize(self, **kwargs): # init write only props if len(getattr(self.__class__, '__write_only__', ())) == 0: self.__class__.__write_only__ = () dictionary = {} expand = kwargs.get('expand', ()) or () prop = 'props' if expand: # expand all the fields for key in expand: getattr(self, key) iterable = self.__dict__.items() is_custom_property_set = False # include only properties passed as parameter if (prop in kwargs) and (kwargs.get(prop, None) is not None): is_custom_property_set = True iterable = kwargs.get(prop, None) # loop trough all accessible properties for key in iterable: accessor = key if isinstance(key, tuple): accessor = key[0] if not (accessor in self.__class__.__write_only__) and not accessor.startswith('_'): # force select from db to be able get relationships if is_custom_property_set: getattr(self, accessor, None) if isinstance(self.__dict__.get(accessor), list): dictionary[accessor] = self.__class__.serialize_list(object_list=self.__dict__.get(accessor)) # check if those properties are read only elif isinstance(self.__dict__.get(accessor), Serializable): dictionary[accessor] = self.__dict__.get(accessor).serialize() else: dictionary[accessor] = self.__dict__.get(accessor) return dictionary 
2
04 апр. Artem Fedorov atsakymas 04 balandžio. 2016-04-04 18:16 '16 at 18:16 PM 2016-04-04 18:16

Nors pradinis klausimas kartojamas jau kurį laiką, čia pateiktų atsakymų skaičius (ir mano patirtis) suteikia jam nežymus klausimą, turintį daug skirtingų skirtingo sudėtingumo metodų, susijusių su skirtingais kompromisais.

Štai kodėl aš pastatiau SQLAthanor biblioteką , kuri praplečia deklaracinį SQLAlchemy ORM su pasirinkta serializavimo / de-serializavimo parama, kurią galite peržiūrėti.

Biblioteka palaiko:

  • Python 2.7, 3.4, 3.5 ir 3.6.
  • Versija SQLAlchemy versija 0.9 ir naujesnė
  • serializacija / de-serializacija į / iš JSON, CSV, YAML ir Python dict
  • stulpelių / atributų, santykių, hibridinių savybių ir proxy asociacijų serializavimas / de-serializavimas
  • įgalinti arba išjungti tam tikrų formatų ir stulpelių / ryšių / atributų serializavimą (pvz., norite išsaugoti gaunamo password vertę, bet niekada neįtraukti išeinančių)
  • preliminari serializacija ir apdorojimas po deserizacijos (tikrinimo ar priverstinio tipo)
  • gana paprasta sintaksė, kuri yra tiek „Pythonic“, tiek visiškai suderinama su savimi „SQLAlchemy“

Jūs galite perskaityti išsamius dokumentus (tikiuosi!) Čia: https://sqlathanor.readthedocs.io/en/latest

Tikiuosi, kad tai padės!

2
22 июля '18 в 23:58 2018-07-22 23:58 Atsakymą davė Chrisas Modzelewskis liepos 22 d. 18 val. 11:58 val. 2018-07-22 23:58

Čia pateikiamas sprendimas, leidžiantis pasirinkti santykius, kuriuos norite įtraukti į savo išvadą, kuo giliau. PASTABA. Tai yra pilnas perrašymas naudojant dict / str kaip argumentą, o ne sąrašą. pataiso kai kuriuos dalykus ..

 def deep_dict(self, relations={}): """Output a dict of an SA object recursing as deep as you want. Takes one argument, relations which is a dictionary of relations we'd like to pull out. The relations dict items can be a single relation name or deeper relation names connected by sub dicts Example: Say we have a Person object with a family relationship person.deep_dict(relations={'family':None}) Say the family object has homes as a relation then we can do person.deep_dict(relations={'family':{'homes':None}}) OR person.deep_dict(relations={'family':'homes'}) Say homes has a relation like rooms you can do person.deep_dict(relations={'family':{'homes':'rooms'}}) and so on... """ mydict = dict((c, str(a)) for c, a in self.__dict__.items() if c != '_sa_instance_state') if not relations: # just return ourselves return mydict # otherwise we need to go deeper if not isinstance(relations, dict) and not isinstance(relations, str): raise Exception("relations should be a dict, it is of type {}".format(type(relations))) # got here so check and handle if we were passed a dict if isinstance(relations, dict): # we were passed deeper info for left, right in relations.items(): myrel = getattr(self, left) if isinstance(myrel, list): mydict[left] = [rel.deep_dict(relations=right) for rel in myrel] else: mydict[left] = myrel.deep_dict(relations=right) # if we get here check and handle if we were passed a string elif isinstance(relations, str): # passed a single item myrel = getattr(self, relations) left = relations if isinstance(myrel, list): mydict[left] = [rel.deep_dict(relations=None) for rel in myrel] else: mydict[left] = myrel.deep_dict(relations=None) return mydict 

taip, pavyzdžiui, naudodami asmenį / šeimą / namą / kambarį ... paverčiant jį į „Json“, jums reikia tik

 json.dumps(person.deep_dict(relations={'family':{'homes':'rooms'}})) 
2
18 дек. Atsakymas pateikiamas 18 d. 2016-12-18 03:03 '16 at 3:03 2016-12-18 03:03

Šis kodas bus serializuotas sqlalchemy rezultatui.

 import json from collections import OrderedDict def asdict(self): result = OrderedDict() for key in self.__mapper__.c.keys(): if getattr(self, key) is not None: result[key] = str(getattr(self, key)) else: result[key] = getattr(self, key) return result def to_array(all_vendors): v = [ ven.asdict() for ven in all_vendors ] return json.dumps(v) 

Pramogos

 def all_products(): all_products = Products.query.all() return to_array(all_products) 
1
13 июня '18 в 15:02 2018-06-13 15:02 Atsakymą pateikė Chirag Vora birželio 13 d. 18 val. 15:02 2018-06-13 15:02
 def alc2json(row): return dict([(col, str(getattr(row,col))) for col in row.__table__.columns.keys()]) 

Maniau, kad šį karalių žaisčiau golfą.

FYI: aš naudoju automap_base , nes turime atskirai parengtą schemą, atitinkančią verslo reikalavimus. Šiandien aš ką tik pradėjau naudoti SQLAlchemy, tačiau dokumentuose teigiama, kad automap_base yra deklaracinės bazės išplėtimas, kuris, atrodo, yra tipiškas ORM SQLAlchemy paradigma, todėl manau, kad tai turėtų veikti.

Tai nėra panaši į užsienio raktų buvimą „ Tjorriemorrie“ , tačiau ji tiesiog padaro stulpelius į vertes ir apdoroja Python tipus, naudodama str () - stulpelių reikšmes. Mūsų vertes sudaro Python datetime.time ir dešimtainis. Rezultatas yra klasės tipas, todėl atlieka užduotį.

Tikiuosi, kad tai padės visiems praeiviams!

1
05 мая '16 в 3:09 2016-05-05 03:09 atsakymą pateikė hpatel71 gegužės 05 d. 16 d. 3:09 2016-05-05 03:09

Naudokite įmontuotą serialerį SQLAlchemy:

 from sqlalchemy.ext.serializer import loads, dumps obj = MyAlchemyObject() # serialize object serialized_obj = dumps(obj) # deserialize object obj = loads(serialized_obj) 

Jei perkeliate objektą tarp sesijų, nepamirškite atskirti objekto iš dabartinės sesijos, naudodami sesiją. Norėdami jį vėl prijungti, tiesiog session.add(obj) .

0
13 дек. Atsakymas pateikiamas chribsen 13 d. 2016-12-13 14:31 '16 at 14:31 pm 2016-12-13 14:31

Po kolba jis apdoroja ir apdoroja duomenų laukus, konvertuodamas tipo lauką
'time': datetime.datetime(2018, 3, 22, 15, 40)
"time": "2018-03-22 15:40:00" :

 obj = {c.name: str(getattr(self, c.name)) for c in self.__table__.columns} # This to get the JSON body return json.dumps(obj) # Or this to get a response object return jsonify(obj) 
0
11 марта '18 в 1:15 2018-03-11 01:15 atsakymas pateikiamas belvederef kovo 11 d. 18 val. 1:15 2018-03-11 01:15

Žinau, kad tai gana senas straipsnis. Aš priėmė sprendimą @SashaB ir pakeitiau pagal mano poreikius.

Pridėjau šiuos dalykus:

  • Laukas Ignoruoti sąrašą: laukų, į kuriuos negalima ignoruoti, sąrašas
  • Laukų pakeitimų sąrašas: žodynas, kuriame yra laukų, kurie bus pakeisti serializavimo metu, pavadinimai.
  • Nuotoliniai metodai ir „BaseQuery“ serija.

Mano kodas atrodo taip:

 def alchemy_json_encoder(revisit_self = False, fields_to_expand = [], fields_to_ignore = [], fields_to_replace = {}): """ Serialize SQLAlchemy result into JSon :param revisit_self: True / False :param fields_to_expand: Fields which are to be expanded for including their children and all :param fields_to_ignore: Fields to be ignored while encoding :param fields_to_replace: Field keys to be replaced by values assigned in dictionary :return: Json serialized SQLAlchemy object """ _visited_objs = [] class AlchemyEncoder(json.JSONEncoder): def default(self, obj): if isinstance(obj.__class__, DeclarativeMeta): # don't re-visit self if revisit_self: if obj in _visited_objs: return None _visited_objs.append(obj) # go through each field in this SQLalchemy class fields = {} for field in [x for x in dir(obj) if not x.startswith('_') and x != 'metadata' and x not in fields_to_ignore]: val = obj.__getattribute__(field) # is this field method defination, or an SQLalchemy object if not hasattr(val, "__call__") and not isinstance(val, BaseQuery): field_name = fields_to_replace[field] if field in fields_to_replace else field # is this field another SQLalchemy object, or a list of SQLalchemy objects? if isinstance(val.__class__, DeclarativeMeta) or \ (isinstance(val, list) and len(val) > 0 and isinstance(val[0].__class__, DeclarativeMeta)): # unless we're expanding this field, stop here if field not in fields_to_expand: # not expanding this field: set it to None and continue fields[field_name] = None continue fields[field_name] = val # a json-encodable dict return fields return json.JSONEncoder.default(self, obj) return AlchemyEncoder 

Tikiuosi, kad tai padės kam nors!

0
13 мая '16 в 17:04 2016-05-13 17:04 atsakymas pateikiamas srahul07 gegužės 13, 16 d. 17:04 2016-05-13 17:04

Įterptos serializerinės droselės su utf-8 negali dekoduoti netinkamų pradinio baito kai kuriems įvestims. Vietoj to nuėjau:

 def row_to_dict(row): temp = row.__dict__ temp.pop('_sa_instance_state', None) return temp def rows_to_list(rows): ret_rows = [] for row in rows: ret_rows.append(row_to_dict(row)) return ret_rows @website_blueprint.route('/api/v1/some/endpoint', methods=['GET']) def some_api(): ''' /some_endpoint ''' rows = rows_to_list(SomeModel.query.all()) response = app.response_class( response=jsonplus.dumps(rows), status=200, mimetype='application/json' ) return response 
0
05 февр. RobotHumans paskelbė atsakymą vasario 05 d 2019-02-05 19:53 '19 , 19:53 2019-02-05 19:53

Mano technika naudoja (per daug?) Žodynai:

 def serialize(_query): #d = dictionary written to per row #D = dictionary d is written to each time, then reset #Master = dictionary of dictionaries; the id Key (int, unique from database) from D is used as the Key for the dictionary D entry in Master Master = {} D = {} x = 0 for u in _query: d = u.__dict__ D = {} for n in d.keys(): if n != '_sa_instance_state': D[n] = d[n] x = d['id'] Master[x] = D return Master 

Kolba (įskaitant jsonify) ir flask_sqlalchemy spausdinama kaip JSON.

Skambinkite funkcijai su jsonify (serialize ()).

Dirba su visomis iki šiol išbandytomis „SQLAlchemy“ užklausomis („SQLite3“ darbai)

-2
08 июня '16 в 18:17 2016-06-08 18:17 atsakymą pateikė Sawyer Brooks birželio 8 d., 16 d., 18:17, 2016-06-08 18:17

Kiti klausimai apie „ arba Užduoti klausimą