         @_set_fields = []
         # Which fields *must* be included in any set query
         @_required_set_fields = {}
-        @_allowed_set_fields = {}  # and which are *allowed* to be set
         for field in misc.keys(@_query[@_table][0])
             if @_client_query?.set?.fields?[field]?
                 @_set_fields.push(field)
-                @_allowed_set_fields[field] = true
             if @_client_query?.set?.required_fields?[field]?
                 @_required_set_fields[field] = true
 

            return

        changed = @_changes()

        # Send our changes to the server.
        query = []
        saved_objs = []
        for key in misc.keys(changed).sort()  # sort so that behavior is more predictable = faster (e.g., sync patches are in order); the keys are strings so default sort is fine
            c = changed[key]
            obj = {"#{@_primary_key}":key}   # NOTE: this may get replaced below with proper javascript, e.g., for compound primary key
            for k in @_set_fields
                v = c.new_val.get(k)
                if v? and @_allowed_set_fields[k]
                    if @_required_set_fields[k] or not immutable.is(v, c.old_val?.get(k))
                        if immutable.Iterable.isIterable(v)
                            obj[k] = v.toJS()

                    # while we weren't connected, so we know it but the
                    # backend server doesn't, which case we should keep it,
                    # and set conflict=true, so it gets saved to the backend.

                    if @_value_local.get(key).equals(@_value_server.get(key))
                        # The local value for this key was saved to the backend before
                        # we got disconnected, so there's definitely no need to try
                        # keep it around, given that the backend no longer has it
                        # as part of the query.  CRITICAL: This doesn't necessarily mean
                        # the value was deleted from the database, but instead that
                        # it doesn't satisfy the synctable query, e.g., it isn't one
                        # of the 150 most recent file_use notifications, or it isn't
                        # a patch that is at least as new as the newest snapshot.
                        #console.log("removing local value: #{key}")
                        @_value_local = @_value_local.delete(key)
                        changed_keys.push(key)
                    else
                        conflict = true

            # NEWLY ADDED:
            # Next check through each key in what's on the remote database,
