def execute(self, q, args=()): """ Send a query to the Salesforce API. """ self.rowcount = None if isinstance(self.query, SalesforceQuery) or self.query is None: response = self.execute_select(q, args) #print("response : %s" % response.text) elif isinstance(self.query, SalesforceRawQuery): response = self.execute_select(q, args) elif isinstance(self.query, subqueries.InsertQuery): response = self.execute_insert(self.query) elif isinstance(self.query, subqueries.UpdateQuery): response = self.execute_update(self.query) elif isinstance(self.query, subqueries.DeleteQuery): response = self.execute_delete(self.query) else: raise DatabaseError("Unsupported query: type %s: %s" % (type(self.query), self.query)) if response and isinstance(response, list): # bulk operation SOAP if all(x['success'] for x in response): self.lastrowid = [item['id'] for item in response] # the encoding is detected automatically, e.g. from headers elif (response and response.text): # parse_float set to decimal.Decimal to avoid precision errors when # converting from the json number to a float to a Decimal object # on a model's DecimalField...converts from json number directly # a Decimal object data = response.json(parse_float=decimal.Decimal) # a SELECT query if ('totalSize' in data): self.rowcount = data['totalSize'] # a successful INSERT query, return after getting PK elif ('success' in data and 'id' in data): self.lastrowid = data['id'] return elif data['hasErrors'] == False: # save id from bulk_create even if Django don't use it if data['results'] and data['results'][0]['result']: self.lastrowid = [ item['result']['id'] for item in data['results'] ] return # something we don't recognize else: raise DatabaseError(data) if q.upper().startswith('SELECT COUNT() FROM'): # COUNT() queries in SOQL are a special case, as they don't actually return rows self.results = iter([[self.rowcount]]) else: if self.query: self.query.first_chunk_len = len(data['records']) self.first_row = data['records'][0] if data['records'] else None self.results = self.query_results(data) else: self.results = iter([])
def __init__(self, message='', data=None, response=None, verbose=False): DatabaseError.__init__(self, message) self.data = data self.response = response self.verbose = verbose if verbose: log.info("Error (debug details) %s\n%s", response.text, response.__dict__)
def __init__(self, message='', data=None, response=None, verbose=False): DatabaseError.__init__(self, message) self.data = data self.response = response self.verbose = verbose if verbose: log.info("Error (debug details) %s\n%s", response.text, response.__dict__)
def reauthenticate(db_alias): if connections['salesforce'].sf_session.auth.dynamic_token is None: expire_token(db_alias) oauth = authenticate(db_alias=db_alias) return oauth['access_token'] else: # It is expected that with dynamic authentication we get a token that # is valid at least for a few future seconds, because we don't get # any password or permanent permission for it from the user. raise DatabaseError("Dynamically authenticated connection can never reauthenticate.")
def reauthenticate(self): if self.dynamic is None: self.del_token() return self.get_auth()['access_token'] else: # It is expected that with dynamic authentication we get a token that # is valid at least for a few future seconds, because we don't get # any password or permanent permission for it from the user. raise DatabaseError( "Dynamically authenticated connection can never reauthenticate." )
def prep_for_deserialize(model, record, using, init_list=None): """ Convert a record from SFDC (decoded JSON) to dict(model string, pk, fields) If fixes fields of some types. If names of required fields `init_list `are specified, then only these fields are processed. """ from salesforce.backend import base # TODO the parameter 'using' is not currently important. attribs = record.pop('attributes') mod = model.__module__.split('.') if (mod[-1] == 'models'): app_label = mod[-2] elif (hasattr(model._meta, 'app_label')): app_label = getattr(model._meta, 'app_label') else: raise ImproperlyConfigured( "Can't discover the app_label for %s, you must specify it via model meta options." ) if len(record.keys()) == 1 and model._meta.db_table in record: # this is for objects with ManyToManyField and OneToOneField while len(record) == 1: record = list(record.values())[0] if record is None: return None fields = prep_for_deserialize_inner(model, record, init_list=init_list) if init_list and set(init_list).difference(fields).difference([SF_PK]): raise DatabaseError("Not found some expected fields") return dict( model='.'.join([app_label, model.__name__]), pk=record.pop('Id'), fields=fields, )
def as_sql(self, with_limits=True, with_col_aliases=False, subquery=False): """ Creates the SQL for this query. Returns the SQL string and list of parameters. If 'with_limits' is False, any limit/offset information is not included in the query. """ # After executing the query, we must get rid of any joins the query # setup created. So, take note of alias counts before the query ran. # However we do not want to get rid of stuff done in pre_sql_setup(), # as the pre_sql_setup will modify query state in a way that forbids # another run of it. if DJANGO_19_PLUS: if with_limits and self.query.low_mark == self.query.high_mark: return '', () self.subquery = subquery refcounts_before = self.query.alias_refcount.copy() soql_trans = self.query_topology() try: extra_select, order_by, group_by = self.pre_sql_setup() if with_limits and self.query.low_mark == self.query.high_mark: return '', () distinct_fields = self.get_distinct() # This must come after 'select', 'ordering', and 'distinct' -- see # docstring of get_from_clause() for details. from_, f_params = self.get_from_clause() if DJANGO_19_PLUS: where, w_params = self.compile( self.where) if self.where is not None else ("", []) having, h_params = self.compile( self.having) if self.having is not None else ("", []) else: where, w_params = self.compile(self.query.where) having, h_params = self.compile(self.query.having) params = [] result = ['SELECT'] if self.query.distinct: result.append( self.connection.ops.distinct_sql(distinct_fields)) out_cols = [] col_idx = 1 for _, (s_sql, s_params), alias in self.select + extra_select: if alias: # fixed by removing 'AS' s_sql = '%s %s' % (s_sql, self.connection.ops.quote_name(alias)) elif with_col_aliases and not isinstance( with_col_aliases, salesforce.backend.base.DatabaseWrapper): s_sql = '%s AS %s' % (s_sql, 'Col%d' % col_idx) col_idx += 1 if soql_trans and re.match(r'^\w+\.\w+$', s_sql): tab_name, col_name = s_sql.split('.') s_sql = '%s.%s' % (soql_trans[tab_name], col_name) params.extend(s_params) out_cols.append(s_sql) result.append(', '.join(out_cols)) result.append('FROM') result.extend(from_) params.extend(f_params) if where: result.append('WHERE %s' % where) params.extend(w_params) grouping = [] for g_sql, g_params in group_by: grouping.append(g_sql) params.extend(g_params) if grouping: if distinct_fields: raise NotImplementedError( "annotate() + distinct(fields) is not implemented.") if not order_by: order_by = self.connection.ops.force_no_ordering() result.append('GROUP BY %s' % ', '.join(grouping)) if having: result.append('HAVING %s' % having) params.extend(h_params) if order_by: ordering = [] for _, (o_sql, o_params, _) in order_by: ordering.append(o_sql) params.extend(o_params) result.append('ORDER BY %s' % ', '.join(ordering)) if with_limits: if self.query.high_mark is not None: result.append('LIMIT %d' % (self.query.high_mark - self.query.low_mark)) if self.query.low_mark: if self.query.high_mark is None: val = self.connection.ops.no_limit_value() if val: result.append('LIMIT %d' % val) result.append('OFFSET %d' % self.query.low_mark) if self.query.select_for_update and self.connection.features.has_select_for_update: if self.connection.get_autocommit(): raise TransactionManagementError( "select_for_update cannot be used outside of a transaction." ) # If we've been asked for a NOWAIT query but the backend does # not support it, raise a DatabaseError otherwise we could get # an unexpected deadlock. nowait = self.query.select_for_update_nowait if nowait and not self.connection.features.has_select_for_update_nowait: raise DatabaseError( 'NOWAIT is not supported on this database backend.') result.append( self.connection.ops.for_update_sql(nowait=nowait)) return ' '.join(result), tuple(params) finally: # Finally do cleanup - get rid of the joins we created above. self.query.reset_refcounts(refcounts_before)