दिलचस्प पोस्ट
सिस्टम से बाहर मेमोरी अपवाद। ड्रॉइंग। इमेज। फ्रॉमफाइल () चयन स्टार्ट / चयनआपके इनपुट प्रकार = "संख्या" पर अब क्रोम में अनुमति नहीं है jQuery – यह कई $ (दस्तावेज़) के लिए खराब है .ready (function () {}); थैलों की सबसे बड़ी संख्या क्या है जो एक साथ जेम्टर में चलाने के लिए उचित है? मिक्स्डस्पेस का मिलान करें, लेकिन नई लाइनें नहीं कैसे एक JSON फ़ाइल को प्रिंट करने के लिए? स्ट्रिंग को datetime ऑब्जेक्ट में परिवर्तित करना कोको उद्देश्य-सी वर्ग के काम में एक चर के सामने एक अंडरस्कोर कैसे होता है? HTML5 ऑडियो स्टॉप फ़ंक्शन क्रोम एक्सटेंशन में jQuery का उपयोग कैसे करें? मैं फ़ेविकॉन रिफ्रेश को कैसे लागू करूं? क्वेरी के लिए पैरामीटर कैसे पास करें? ACCESS_COARSE_LOCATION अनुमति एंड्रॉइड पर एक सेल टॉवर परिशुद्धता देता है मौजूदा प्रकार को टाइप वैरिएबल के साथ संदर्भित करने का कोई तरीका है? सी # में एईएस एन्क्रिप्शन का उपयोग करना

JSON के लिए SqlAlchemy परिणाम serialize करने के लिए कैसे?

डीजे से JSON प्रारूप में लौट आए ओआरएम मॉडलों के डीजेंगो में कुछ अच्छा स्वत: क्रमिकरण है

एसक्यूएलएलईमी क्वेरी परिणाम को JSON प्रारूप में कैसे सीरियल करना है?

मैंने jsonpickle.encode की कोशिश की, लेकिन यह स्वयं क्वेरी ऑब्जेक्ट को एनकोड करता है मैंने json.dumps(items) की कोशिश की, लेकिन यह रिटर्न

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

क्या एसक्यूएलएलईमी ORM ऑब्जेक्ट को JSON / XML में क्रमबद्ध करना बहुत मुश्किल है? इसके लिए कोई डिफ़ॉल्ट सीरियलइज़र नहीं है? आजकल ओआरएम क्वेरी परिणामों को क्रमबद्ध करने के लिए यह बहुत ही सामान्य कार्य है

मुझे क्या चाहिए सिर्फ एसक्यूएलएलईमी क्वेरी परिणाम के JSON या XML डेटा प्रतिनिधित्व को वापस करना है।

जावास्क्रिप्ट डेटागुर्ड (JQGrid http://www.trirand.com/blog/ ) में उपयोग करने के लिए JSON / XML प्रारूप में एसक्यूएललेमी ऑब्जेक्ट्स क्वेरी परिणाम आवश्यक है

वेब के समाधान से एकत्रित समाधान "JSON के लिए SqlAlchemy परिणाम serialize करने के लिए कैसे?"

एक फ्लैट कार्यान्वयन

आप ऐसा कुछ इस्तेमाल कर सकते हैं:

 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) 

और उसके बाद का उपयोग करके JSON में परिवर्तित करें:

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

यह उन क्षेत्रों की अनदेखी करेगा जो एन्कोडेबल नहीं हैं (उन्हें 'कोई नहीं' पर सेट करें)

यह संबंधों को स्वत: विस्तार नहीं करता है (क्योंकि यह आत्म-संदर्भ और हमेशा के लिए लूप को जन्म दे सकता है)।

एक पुनरावर्ती, गैर-परिपत्र कार्यान्वयन

अगर, हालांकि, आप हमेशा के लिए लूप चाहते हैं, तो आप इसका उपयोग कर सकते हैं:

 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 

और फिर वस्तुओं का उपयोग करके एन्कोड करें:

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

यह सभी बच्चों, और उनके सभी बच्चों, और उनके सभी बच्चों को सांकेतिक शब्दों में बदलना होगा … मूल रूप से अपने संपूर्ण डेटाबेस को सांकेतिक रूप से सांकेतिक शब्दों में बदलना जब यह किसी से पहले उसकी एन्कोडेड तक पहुंचता है, तो इसे 'कोई नहीं' के रूप में सांकेतिक शब्दों में बदलना होगा

एक पुनरावर्ती, संभवतः-परिपत्र, चयनात्मक कार्यान्वयन

एक और विकल्प, शायद बेहतर, वह फ़ील्ड निर्दिष्ट करने में सक्षम होना चाहिए, जिसे आप विस्तारित करना चाहते हैं:

 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 

अब आप इसे इस पर कॉल कर सकते हैं:

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

उदाहरण के लिए, 'माता-पिता' नामक एसक्यूएललेमी क्षेत्र को विस्तारित करने के लिए।

तुम सिर्फ एक वस्तु के रूप में अपना ऑब्जेक्ट आउटपुट कर सकते हैं:

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

और फिर आप user.as_dict () का उपयोग अपने ऑब्जेक्ट को सीरियल कर सकते हैं।

जैसा कि अजगर डिक्ट को कन्वर्ट sqlalchemy पंक्ति वस्तु में समझाया

आप एक RowProxy को इस तरह से एक कन्वर्ट करने के लिए परिवर्तित कर सकते हैं:

  d = dict(row.items()) 

फिर JSON को सीरियलाइज़ करना (आपको datetime वैल्यू जैसी चीज़ों के लिए एक एन्कोडर निर्दिष्ट करना होगा) यदि आप सिर्फ एक रिकॉर्ड (और संबंधित रिकॉर्डों का पूर्ण पदानुक्रम नहीं) चाहते हैं, तो यह मुश्किल नहीं है।

 json.dumps([(dict(row.items())) for row in rs]) 

मैं एक हाल ही में सर्किट लाइब्रेरी मार्शमॉलो का उपयोग करने की सलाह देता हूं यह आपको संबंधों और नेस्टेड ऑब्जेक्ट्स के समर्थन के साथ अपने मॉडल उदाहरणों का प्रतिनिधित्व करने के लिए धारावाहिक बनाने की अनुमति देता है।

थियर एसक्यूएललेमी उदाहरण को देखें

फ्लास्क-जेएसन-टूल्स पैकेज में आपके मॉडल्स के लिए जेसनएसरिअलाइज़ेबलबेस बेस क्लास का कार्यान्वयन है।

उपयोग:

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

अब User मॉडल जादुई धारावाहिक है।

यदि आपका ढांचा फ्लास्क नहीं है, तो आप कोड को पकड़ सकते हैं

सुरक्षा कारणों से आपको सभी मॉडल के खेतों को कभी भी वापस नहीं करना चाहिए। मैं चुनिंदा उन्हें चुनने के लिए पसंद करते हैं

फ्लास्क की जेएसएन एन्कोडिंग अब query_class , डेटटाइम और रिश्तों का समर्थन करती है (और query_class डीबी.मोडेल वर्ग के लिए query और queryquery_class जोड़ा गया है)। मैंने एन्कोडर को निम्नानुसार अपडेट किया है:

एप्लिकेशन / 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 

इसके साथ मैं वैकल्पिक रूप से एक __json__ प्रॉपर्टी जोड़ सकता हूं जो कि फ़ील्ड की सूची देता है जिसे मैं एन्कोड करना चाहता हूं:

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'] 

मैं अपने दृश्य में @ जेसनापी को जोड़ूंगा, परिणाम सूची लौटाऊंगा और फिर मेरा आउटपुट इस प्रकार है:

 [ { "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" } ] 

यह इतना तेज नहीं है मैंने ऐसा करने के लिए कुछ कोड लिखा था मैं अभी भी इस पर काम कर रहा हूं, और यह मोचीकिट फ्रेमवर्क का उपयोग करता है यह मूल रूप से एक प्रॉक्सी और पंजीकृत JSON कन्वर्टर्स का उपयोग करते हुए पायथन और जावास्क्रिप्ट के बीच यौगिक ऑब्जेक्ट का अनुवाद करता है।

डेटाबेस ऑब्जेक्ट्स के लिए ब्राउज़र की ओर से है db.js यह प्रॉक्सी .js में मूल पायथन प्रॉक्सी स्रोत की आवश्यकता है

पायथन पक्ष में आधार प्रॉक्सी मॉड्यूल है । आखिर में वेबसर्वर में SQL एल्केमी ऑब्जेक्ट एनकोडर। यह models.py फ़ाइल में मिले मेटाडाटा एक्स्ट्रेक्टर पर भी निर्भर करता है।

कस्टम serialization और deserialization

"से_जसन" (क्लास मेथड) जेएसएन डेटा पर आधारित एक मॉडल ऑब्जेक्ट बनाता है।

"deserialize" को केवल उदाहरण के तौर पर कहा जा सकता है, और json के सभी आंकड़ों को मॉडल उदाहरण में मर्ज कर सकते हैं।

"धारावाहिक" – पुनरावर्ती क्रमिकरण

__write_only__ संपत्ति को केवल लिखने वाले गुणों को परिभाषित करने के लिए आवश्यक है (उदाहरण के लिए "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 

एसक्यूएललेमी में अंतर्निर्मित धारावाहिक उपयोग करें:

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

यदि आप ऑब्जेक्ट को सत्रों के बीच स्थानांतरित कर रहे हैं, तो सत्र को चालू सत्र से ऑब्जेक्ट को अलग करना याद रखें। session.expunge(obj) इसे फिर से जोड़ने के लिए, बस session.add(obj) करो। session.add(obj)

यह एक ऐसा समाधान है जो आपको उन संबंधों को चुनने देता है जो आप अपने आउटपुट में शामिल करना चाहते हैं जैसे कि आप जाना चाहते हैं। नोट: यह एक सूची के बजाय एक आर्ग के रूप में एक dict / str ले रही एक पूर्ण पुनः लिख रहा है। कुछ सामान ठीक करता है ..

 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 

इसलिए व्यक्ति / परिवार / घरों / कमरों का उपयोग करते हुए एक उदाहरण के लिए … यह आपको json में बदलना है

 json.dumps(person.deep_dict(relations={'family':{'homes':'rooms'}})) 
 def alc2json(row): return dict([(col, str(getattr(row,col))) for col in row.__table__.columns.keys()]) 

मैंने सोचा कि मैं इस एक के साथ एक छोटे से कोड गोल्फ खेलेंगे।

एफवाईआई : मैं ऑटोमैप_बेस का उपयोग कर रहा हूं क्योंकि हमारे पास व्यवसाय की आवश्यकताओं के अनुसार अलग से डिजाइन की गई स्कीमा है। मैंने अभी आज एसक्यूएललेमी का उपयोग करना शुरू कर दिया है, लेकिन दस्तावेज़ीकरण में कहा गया है कि automap_base, declarative_base का एक विस्तार है, जो कि एसक्यूएलएलएमी ORM में विशिष्ट प्रतिमान लगता है, इसलिए मेरा मानना ​​है कि यह काम करना चाहिए।

यह प्रति Tjorriemorrie समाधान के लिए निम्नलिखित विदेशी कुंजी के साथ फैंसी नहीं मिलता है, लेकिन यह केवल मानों के लिए कॉलम से मेल खाता है और स्तम्भ मूल्यों से पायथन प्रकारों को संभालता है। हमारे मूल्यों में अजगर दिन-समय सम्मिलित हैं। समय और दशमलव। दशमलव वर्ग प्रकार के परिणाम तो यह काम पूरा हो जाता है।

उम्मीद है कि यह किसी भी यात्री द्वारा मदद करता है!

आप एसक्लएल्की के आत्मनिरीक्षण का प्रयोग इस प्रकार कर सकते हैं:

 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()) 

यहां एक उत्तर से प्रेरित हो जाओ: अजगर डिक्ट के लिए sqlalchemy पंक्ति ऑब्जेक्ट कनवर्ट करें

मुझे पता है यह काफी पुराने पोस्ट है मैंने @ SashaB द्वारा दिए गए समाधान लिया और मेरी जरूरत के अनुसार संशोधित किया।

मैंने इसके लिए निम्नलिखित चीजों को जोड़ा:

  1. फ़ील्ड अनदेखी सूची: धारावाहिक करने के दौरान फ़ील्ड की एक सूची को अनदेखा करना
  2. फ़ील्ड प्रतिस्थापन सूची: धारावाहिक के दौरान मूल्यों के द्वारा प्रतिस्थापित किए जाने वाले फ़ील्ड नामों वाले एक शब्दकोश।
  3. हटाए गए विधियां और बेसैक सीरियल किए गए

मेरा कोड निम्नानुसार है:

 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 

आशा है कि यह किसी को मदद करता है!

मेरे उपयोग का उपयोग (बहुत अधिक?) शब्दकोशों:

 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 

JSON के रूप में आउटपुट प्रिंट करने के लिए फ्लास्क (jsonify सहित) और flask_sqlalchemy के साथ चल रहा है।

फ़ंक्शन को jsonify के साथ कॉल करें (सीरियलize ())।

मैंने अभी तक कोशिश की है सभी SQLAlchemy प्रश्नों के साथ काम करता है (SQLite3 चल रहा है)