tables_db_decrement_row_column
Decrease a numeric value in a specific database table cell by a defined amount, useful for updating counters, inventory quantities, or scores.
Instructions
Decrement a specific column of a row by a given value.
Input Schema
TableJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| database_id | Yes | Database ID. | |
| table_id | Yes | Table ID. | |
| row_id | Yes | Row ID. | |
| column | Yes | Column key. | |
| value | No | Value to increment the column by. The value must be a number. | |
| min | No | Minimum value for the column. If the current value is lesser than this value, an exception will be thrown. | |
| transaction_id | No | Transaction ID for staging the operation. |
Implementation Reference
- MCP server tool handler that executes the tool 'tables_db_decrement_row_column' by calling the bound method from the TablesDB service.@server.call_tool() async def handle_call_tool( name: str, arguments: dict | None ) -> list[types.TextContent | types.ImageContent | types.EmbeddedResource]: try: tool_info = tools_manager.get_tool(name) if not tool_info: raise McpError(f"Tool {name} not found") bound_method = tool_info["function"] result = bound_method(**(arguments or {})) if hasattr(result, 'to_dict'): result_dict = result.to_dict() return [types.TextContent(type="text", text=str(result_dict))] return [types.TextContent(type="text", text=str(result))] except AppwriteException as e: return [types.TextContent(type="text", text=f"Appwrite Error: {str(e)}")] except Exception as e: return [types.TextContent(type="text", text=f"Error: {str(e)}")]
- src/mcp_server_appwrite/server.py:62-95 (registration)Registers the 'tables_db' service wrapping Appwrite TablesDB(client), which exposes its methods as MCP tools prefixed with 'tables_db_', including 'tables_db_decrement_row_column'.def register_services(args): # If --all is specified, enable all services if args.all: args.tables_db = args.users = args.teams = args.storage = True args.functions = args.messaging = args.locale = args.avatars = True args.sites = True # Register services based on CLI arguments if args.tables_db: tools_manager.register_service(Service(TablesDB(client), "tables_db")) if args.users: tools_manager.register_service(Service(Users(client), "users")) if args.teams: tools_manager.register_service(Service(Teams(client), "teams")) if args.storage: tools_manager.register_service(Service(Storage(client), "storage")) if args.functions: tools_manager.register_service(Service(Functions(client), "functions")) if args.messaging: tools_manager.register_service(Service(Messaging(client), "messaging")) if args.locale: tools_manager.register_service(Service(Locale(client), "locale")) if args.avatars: tools_manager.register_service(Service(Avatars(client), "avatars")) if args.sites: tools_manager.register_service(Service(Sites(client), "sites")) if args.databases: tools_manager.register_service(Service(Databases(client), "databases")) # If no services were specified, enable tables_db by default if not any([args.databases, args.tables_db, args.users, args.teams, args.storage, args.functions, args.messaging, args.locale, args.avatars, args.sites]): tools_manager.register_service(Service(TablesDB(client), "tables_db"))
- Dynamically generates tool definitions and input schemas for all public methods of the TablesDB service, constructing names like 'tables_db_decrement_row_column' and parsing parameters from signatures and docstrings.def list_tools(self) -> Dict[str, Dict]: """Lists all available tools for this service""" tools = {} for name, func in inspect.getmembers(self.service, predicate=inspect.ismethod): if name.startswith('_'): # Skip private methods continue original_func = func.__func__ # Skip if not from the service's module if original_func.__module__ != self.service.__class__.__module__: continue # Get the overridden name if it exists tool_name = self._method_name_overrides.get(name, f"{self.service_name}_{name}") docstring = parse(original_func.__doc__) signature = inspect.signature(original_func) type_hints = get_type_hints(original_func) properties = {} required = [] for param_name, param in signature.parameters.items(): if param_name == 'self': continue param_type = type_hints.get(param_name, str) properties[param_name] = self.python_type_to_json_schema(param_type) properties[param_name]["description"] = f"Parameter '{param_name}'" for doc_param in docstring.params: if doc_param.arg_name == param_name: properties[param_name]["description"] = doc_param.description if param.default is param.empty: required.append(param_name) tool_definition = Tool( name=tool_name, description=f"{docstring.short_description or "No description available"}", inputSchema={ "type": "object", "properties": properties, "required": required } ) tools[tool_name] = { "definition": tool_definition, "function": func } return tools
- Helper function that converts Python type annotations to JSON Schema for tool input parameters.def python_type_to_json_schema(self, py_type: Any) -> dict: """Converts Python type hints to JSON Schema types.""" type_mapping = { str: "string", int: "integer", float: "number", bool: "boolean", list: "array", dict: "object" } # Handle basic types if py_type in type_mapping: return {"type": type_mapping[py_type]} # Handle Optional types (Union[type, None]) if hasattr(py_type, "__origin__") and py_type.__origin__ is Union: args = getattr(py_type, "__args__", ()) if len(args) == 2 and args[1] is type(None): schema = self.python_type_to_json_schema(args[0]) return schema # Handle List, Dict, and other generic types if hasattr(py_type, "__origin__"): origin = py_type.__origin__ args = getattr(py_type, "__args__", ()) # Handle List[T] if origin is list or origin is List: if args: item_schema = self.python_type_to_json_schema(args[0]) return { "type": "array", "items": item_schema } return {"type": "array"} # Handle Dict[K, V] if origin is dict or origin is Dict: if len(args) >= 2: value_schema = self.python_type_to_json_schema(args[1]) return { "type": "object", "additionalProperties": value_schema } return {"type": "object"} # Default to string for unknown types return {"type": "string"}