# encoding: utf-8 # module vtkmodules.vtkIOSQL # from C:\Users\xukai\Downloads\发票2\venv\Lib\site-packages\vtkmodules\vtkIOSQL.cp311-win_amd64.pyd # by generator 1.147 # no doc # imports import vtkmodules.vtkCommonCore as __vtkmodules_vtkCommonCore import vtkmodules.vtkCommonExecutionModel as __vtkmodules_vtkCommonExecutionModel import vtkmodules.vtkIOCore as __vtkmodules_vtkIOCore # Variables with simple values VTK_SQL_ALLBACKENDS = '*' VTK_SQL_DEFAULT_COLUMN_SIZE = 32 VTK_SQL_FEATURE_BATCH_OPERATIONS = 1008 VTK_SQL_FEATURE_BLOB = 1002 VTK_SQL_FEATURE_LAST_INSERT_ID = 1007 VTK_SQL_FEATURE_NAMED_PLACEHOLDERS = 1005 VTK_SQL_FEATURE_POSITIONAL_PLACEHOLDERS = 1006 VTK_SQL_FEATURE_PREPARED_QUERIES = 1004 VTK_SQL_FEATURE_QUERY_SIZE = 1001 VTK_SQL_FEATURE_TRANSACTIONS = 1000 VTK_SQL_FEATURE_TRIGGERS = 1009 VTK_SQL_FEATURE_UNICODE = 1003 VTK_SQL_MYSQL = 'vtkMySQLDatabase' VTK_SQL_POSTGRESQL = 'vtkPostgreSQLDatabase' VTK_SQL_SQLITE = 'vtkSQLiteDatabase' # no functions # classes class vtkDatabaseToTableReader(__vtkmodules_vtkCommonExecutionModel.vtkTableAlgorithm): """ vtkDatabaseToTableReader - Read an SQL table as a vtkTable Superclass: vtkTableAlgorithm vtkDatabaseToTableReader reads a table from an SQL database, outputting it as a vtkTable. """ def CheckIfTableExists(self): # real signature unknown; restored from __doc__ """ CheckIfTableExists(self) -> bool C++: bool CheckIfTableExists() Check if the currently specified table name exists in the database. """ return False def GetDatabase(self): # real signature unknown; restored from __doc__ """ GetDatabase(self) -> vtkSQLDatabase C++: vtkSQLDatabase *GetDatabase() """ return vtkSQLDatabase def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBase(self, type:str) -> int C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type) override; Given the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBaseType(type:str) -> int C++: static vtkIdType GetNumberOfGenerationsFromBaseType( const char *type) Given a the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsA(self, type): # real signature unknown; restored from __doc__ """ IsA(self, type:str) -> int C++: vtkTypeBool IsA(const char *type) override; Return 1 if this class is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsTypeOf(self, type): # real signature unknown; restored from __doc__ """ IsTypeOf(type:str) -> int C++: static vtkTypeBool IsTypeOf(const char *type) Return 1 if this class type is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkDatabaseToTableReader C++: vtkDatabaseToTableReader *NewInstance() """ return vtkDatabaseToTableReader def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkDatabaseToTableReader C++: static vtkDatabaseToTableReader *SafeDownCast( vtkObjectBase *o) """ return vtkDatabaseToTableReader def SetDatabase(self, db): # real signature unknown; restored from __doc__ """ SetDatabase(self, db:vtkSQLDatabase) -> bool C++: bool SetDatabase(vtkSQLDatabase *db) Set the database associated with this reader """ return False def SetTableName(self, name): # real signature unknown; restored from __doc__ """ SetTableName(self, name:str) -> bool C++: bool SetTableName(const char *name) Set the name of the table that you'd like to convert to a vtkTable Returns false if the specified table does not exist in the database. """ return False def __delattr__(self, *args, **kwargs): # real signature unknown """ Implement delattr(self, name). """ pass def __getattribute__(self, *args, **kwargs): # real signature unknown """ Return getattr(self, name). """ pass def __init__(self, *args, **kwargs): # real signature unknown pass @staticmethod # known case of __new__ def __new__(*args, **kwargs): # real signature unknown """ Create and return a new object. See help(type) for accurate signature. """ pass def __repr__(self, *args, **kwargs): # real signature unknown """ Return repr(self). """ pass def __setattr__(self, *args, **kwargs): # real signature unknown """ Implement setattr(self, name, value). """ pass def __str__(self, *args, **kwargs): # real signature unknown """ Return str(self). """ pass __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default """Pointer to the C++ object.""" __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkDatabaseToTableReader', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'SetDatabase': , 'SetTableName': , 'CheckIfTableExists': , 'GetDatabase': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkDatabaseToTableReader - Read an SQL table as a vtkTable\\n\\nSuperclass: vtkTableAlgorithm\\n\\nvtkDatabaseToTableReader reads a table from an SQL database,\\noutputting it as a vtkTable.\\n\\n'})" __vtkname__ = 'vtkDatabaseToTableReader' class vtkRowQuery(__vtkmodules_vtkCommonCore.vtkObject): """ vtkRowQuery - abstract interface for queries that return row-oriented results. Superclass: vtkObject The abstract superclass of query classes that return row-oriented (table) results. A subclass will provide database-specific query parameters and implement the vtkRowQuery API to return query results: Execute() - Execute the query. No results need to be retrieved at this point, unless you are performing caching. GetNumberOfFields() - After Execute() is performed, returns the number of fields in the query results. GetFieldName() - The name of the field at an index. GetFieldType() - The data type of the field at an index. NextRow() - Advances the query results by one row, and returns whether there are more rows left in the query. DataValue() - Extract a single data value from the current row. @par Thanks: Thanks to Andrew Wilson from Sandia National Laboratories for his work on the database classes. @sa vtkRowQueryToTable """ def CaseSensitiveFieldNamesOff(self): # real signature unknown; restored from __doc__ """ CaseSensitiveFieldNamesOff(self) -> None C++: virtual void CaseSensitiveFieldNamesOff() """ pass def CaseSensitiveFieldNamesOn(self): # real signature unknown; restored from __doc__ """ CaseSensitiveFieldNamesOn(self) -> None C++: virtual void CaseSensitiveFieldNamesOn() """ pass def DataValue(self, c): # real signature unknown; restored from __doc__ """ DataValue(self, c:int) -> vtkVariant C++: virtual vtkVariant DataValue(vtkIdType c) Return data in current row, field c """ pass def Execute(self): # real signature unknown; restored from __doc__ """ Execute(self) -> bool C++: virtual bool Execute() Execute the query. This must be performed before any field name or data access functions are used. """ return False def GetCaseSensitiveFieldNames(self): # real signature unknown; restored from __doc__ """ GetCaseSensitiveFieldNames(self) -> bool C++: virtual bool GetCaseSensitiveFieldNames() """ return False def GetFieldIndex(self, name): # real signature unknown; restored from __doc__ """ GetFieldIndex(self, name:str) -> int C++: int GetFieldIndex(const char *name) Return the index of the specified query field. Uses GetNumberOfFields() and GetFieldName() to match field name. """ return 0 def GetFieldName(self, i): # real signature unknown; restored from __doc__ """ GetFieldName(self, i:int) -> str C++: virtual const char *GetFieldName(int i) Return the name of the specified query field. """ return "" def GetFieldType(self, i): # real signature unknown; restored from __doc__ """ GetFieldType(self, i:int) -> int C++: virtual int GetFieldType(int i) Return the type of the field, using the constants defined in vtkType.h. """ return 0 def GetLastErrorText(self): # real signature unknown; restored from __doc__ """ GetLastErrorText(self) -> str C++: virtual const char *GetLastErrorText() Get the last error text from the query """ return "" def GetNumberOfFields(self): # real signature unknown; restored from __doc__ """ GetNumberOfFields(self) -> int C++: virtual int GetNumberOfFields() The number of fields in the query result. """ return 0 def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBase(self, type:str) -> int C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type) override; Given the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBaseType(type:str) -> int C++: static vtkIdType GetNumberOfGenerationsFromBaseType( const char *type) Given a the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def HasError(self): # real signature unknown; restored from __doc__ """ HasError(self) -> bool C++: virtual bool HasError() Returns true if an error is set, otherwise false. """ return False def IsA(self, type): # real signature unknown; restored from __doc__ """ IsA(self, type:str) -> int C++: vtkTypeBool IsA(const char *type) override; Return 1 if this class is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsActive(self): # real signature unknown; restored from __doc__ """ IsActive(self) -> bool C++: virtual bool IsActive() Return true if the query is active (i.e. execution was successful and results are ready to be fetched). Returns false on error or inactive query. """ return False def IsTypeOf(self, type): # real signature unknown; restored from __doc__ """ IsTypeOf(type:str) -> int C++: static vtkTypeBool IsTypeOf(const char *type) Return 1 if this class type is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkRowQuery C++: vtkRowQuery *NewInstance() """ return vtkRowQuery def NextRow(self): # real signature unknown; restored from __doc__ """ NextRow(self) -> bool C++: virtual bool NextRow() NextRow(self, rowArray:vtkVariantArray) -> bool C++: bool NextRow(vtkVariantArray *rowArray) Advance row, return false if past end. """ return False def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkRowQuery C++: static vtkRowQuery *SafeDownCast(vtkObjectBase *o) """ return vtkRowQuery def SetCaseSensitiveFieldNames(self, _arg): # real signature unknown; restored from __doc__ """ SetCaseSensitiveFieldNames(self, _arg:bool) -> None C++: virtual void SetCaseSensitiveFieldNames(bool _arg) Many databases do not preserve case in field names. This can cause GetFieldIndex to fail if you search for a field named someFieldName when the database actually stores it as SOMEFIELDNAME. This ivar controls whether GetFieldIndex() expects field names to be case-sensitive. The default is OFF, i.e. case is not preserved. """ pass def __delattr__(self, *args, **kwargs): # real signature unknown """ Implement delattr(self, name). """ pass def __getattribute__(self, *args, **kwargs): # real signature unknown """ Return getattr(self, name). """ pass def __init__(self, *args, **kwargs): # real signature unknown pass @staticmethod # known case of __new__ def __new__(*args, **kwargs): # real signature unknown """ Create and return a new object. See help(type) for accurate signature. """ pass def __repr__(self, *args, **kwargs): # real signature unknown """ Return repr(self). """ pass def __setattr__(self, *args, **kwargs): # real signature unknown """ Implement setattr(self, name, value). """ pass def __str__(self, *args, **kwargs): # real signature unknown """ Return str(self). """ pass __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default """Pointer to the C++ object.""" __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkRowQuery', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'Execute': , 'GetNumberOfFields': , 'GetFieldName': , 'GetFieldType': , 'GetFieldIndex': , 'NextRow': , 'IsActive': , 'DataValue': , 'HasError': , 'GetLastErrorText': , 'SetCaseSensitiveFieldNames': , 'GetCaseSensitiveFieldNames': , 'CaseSensitiveFieldNamesOn': , 'CaseSensitiveFieldNamesOff': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkRowQuery - abstract interface for queries that return row-oriented\\nresults.\\n\\nSuperclass: vtkObject\\n\\nThe abstract superclass of query classes that return row-oriented\\n(table) results. A subclass will provide database-specific query\\nparameters and implement the vtkRowQuery API to return query results:\\n\\nExecute() - Execute the query. No results need to be retrieved at\\nthis\\n point, unless you are performing caching.\\n\\nGetNumberOfFields() - After Execute() is performed, returns the\\nnumber\\n of fields in the query results.\\n\\nGetFieldName() - The name of the field at an index.\\n\\nGetFieldType() - The data type of the field at an index.\\n\\nNextRow() - Advances the query results by one row, and returns\\nwhether\\n there are more rows left in the query.\\n\\nDataValue() - Extract a single data value from the current row.\\n\\n@par Thanks: Thanks to Andrew Wilson from Sandia National\\nLaboratories for his work on the database classes.\\n\\n@sa\\nvtkRowQueryToTable\\n\\n'})" __vtkname__ = 'vtkRowQuery' class vtkRowQueryToTable(__vtkmodules_vtkCommonExecutionModel.vtkTableAlgorithm): """ vtkRowQueryToTable - executes an sql query and retrieves results into a table Superclass: vtkTableAlgorithm vtkRowQueryToTable creates a vtkTable with the results of an arbitrary SQL query. To use this filter, you first need an instance of a vtkSQLDatabase subclass. You may use the database class to obtain a vtkRowQuery instance. Set that query on this filter to extract the query as a table. @par Thanks: Thanks to Andrew Wilson from Sandia National Laboratories for his work on the database classes. @sa vtkSQLDatabase vtkRowQuery """ def GetMTime(self): # real signature unknown; restored from __doc__ """ GetMTime(self) -> int C++: vtkMTimeType GetMTime() override; Update the modified time based on the query. """ return 0 def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBase(self, type:str) -> int C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type) override; Given the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBaseType(type:str) -> int C++: static vtkIdType GetNumberOfGenerationsFromBaseType( const char *type) Given a the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetQuery(self): # real signature unknown; restored from __doc__ """ GetQuery(self) -> vtkRowQuery C++: virtual vtkRowQuery *GetQuery() """ return vtkRowQuery def IsA(self, type): # real signature unknown; restored from __doc__ """ IsA(self, type:str) -> int C++: vtkTypeBool IsA(const char *type) override; Return 1 if this class is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsTypeOf(self, type): # real signature unknown; restored from __doc__ """ IsTypeOf(type:str) -> int C++: static vtkTypeBool IsTypeOf(const char *type) Return 1 if this class type is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkRowQueryToTable C++: vtkRowQueryToTable *NewInstance() """ return vtkRowQueryToTable def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkRowQueryToTable C++: static vtkRowQueryToTable *SafeDownCast(vtkObjectBase *o) """ return vtkRowQueryToTable def SetQuery(self, query): # real signature unknown; restored from __doc__ """ SetQuery(self, query:vtkRowQuery) -> None C++: void SetQuery(vtkRowQuery *query) The query to execute. """ pass def __delattr__(self, *args, **kwargs): # real signature unknown """ Implement delattr(self, name). """ pass def __getattribute__(self, *args, **kwargs): # real signature unknown """ Return getattr(self, name). """ pass def __init__(self, *args, **kwargs): # real signature unknown pass @staticmethod # known case of __new__ def __new__(*args, **kwargs): # real signature unknown """ Create and return a new object. See help(type) for accurate signature. """ pass def __repr__(self, *args, **kwargs): # real signature unknown """ Return repr(self). """ pass def __setattr__(self, *args, **kwargs): # real signature unknown """ Implement setattr(self, name, value). """ pass def __str__(self, *args, **kwargs): # real signature unknown """ Return str(self). """ pass __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default """Pointer to the C++ object.""" __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkRowQueryToTable', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'SetQuery': , 'GetQuery': , 'GetMTime': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkRowQueryToTable - executes an sql query and retrieves results into\\na table\\n\\nSuperclass: vtkTableAlgorithm\\n\\nvtkRowQueryToTable creates a vtkTable with the results of an\\narbitrary SQL query. To use this filter, you first need an instance\\nof a vtkSQLDatabase subclass. You may use the database class to\\nobtain a vtkRowQuery instance. Set that query on this filter to\\nextract the query as a table.\\n\\n@par Thanks: Thanks to Andrew Wilson from Sandia National\\nLaboratories for his work on the database classes.\\n\\n@sa\\nvtkSQLDatabase vtkRowQuery\\n\\n'})" __vtkname__ = 'vtkRowQueryToTable' class vtkSQLDatabase(__vtkmodules_vtkCommonCore.vtkObject): """ vtkSQLDatabase - maintain a connection to an sql database Superclass: vtkObject Abstract base class for all SQL database connection classes. Manages a connection to the database, and is responsible for creating instances of the associated vtkSQLQuery objects associated with this class in order to perform execute queries on the database. To allow connections to a new type of database, create both a subclass of this class and vtkSQLQuery, and implement the required functions: Open() - open the database connection, if possible. Close() - close the connection. GetQueryInstance() - create and return an instance of the vtkSQLQuery subclass associated with the database type. The subclass should also provide API to set connection parameters. This class also provides the function EffectSchema to transform a database schema into a SQL database. @par Thanks: Thanks to Andrew Wilson from Sandia National Laboratories for his work on the database classes and for the SQLite example. Thanks to David Thompson and Philippe Pebay from Sandia National Laboratories for implementing this class. @sa vtkSQLQuery vtkSQLDatabaseSchema """ def Close(self): # real signature unknown; restored from __doc__ """ Close(self) -> None C++: virtual void Close() Close the connection to the database. """ pass def CreateFromURL(self, URL): # real signature unknown; restored from __doc__ """ CreateFromURL(URL:str) -> vtkSQLDatabase C++: static vtkSQLDatabase *CreateFromURL(const char *URL) Create a the proper subclass given a URL. The URL format for SQL databases is a true URL of the form: 'protocol://'[[username[':'password]'@']hostname[':'port]]'/'[dbna me] . """ return vtkSQLDatabase def DATABASE(self): # real signature unknown; restored from __doc__ """ DATABASE() -> vtkInformationObjectBaseKey C++: static vtkInformationObjectBaseKey *DATABASE() Stores the database class pointer as an information key. This is currently used to store database pointers as part of 'data on demand' data objects. For example: The application may have a table/tree/whatever of documents, the data structure is storing the meta-data but not the full text. Further down the pipeline algorithms or views may want to retrieve additional information (full text)for specific documents. """ pass def EffectSchema(self, __a, dropIfExists=False): # real signature unknown; restored from __doc__ """ EffectSchema(self, __a:vtkSQLDatabaseSchema, dropIfExists:bool=False) -> bool C++: virtual bool EffectSchema(vtkSQLDatabaseSchema *, bool dropIfExists=false) Effect a database schema. """ return False def GetColumnSpecification(self, schema, tblHandle, colHandle): # real signature unknown; restored from __doc__ """ GetColumnSpecification(self, schema:vtkSQLDatabaseSchema, tblHandle:int, colHandle:int) -> str C++: virtual vtkStdString GetColumnSpecification( vtkSQLDatabaseSchema *schema, int tblHandle, int colHandle) Return the SQL string with the syntax to create a column inside a "CREATE TABLE" SQL statement. NB: this method implements the following minimally-portable syntax: It must be overwritten for those SQL backends which have a different syntax such as, e.g., MySQL. """ return "" def GetDatabaseType(self): # real signature unknown; restored from __doc__ """ GetDatabaseType(self) -> str C++: virtual const char *GetDatabaseType() Get the type of the database (e.g. mysql, psql,..). """ return "" def GetIndexSpecification(self, schema, tblHandle, idxHandle, skipped): # real signature unknown; restored from __doc__ """ GetIndexSpecification(self, schema:vtkSQLDatabaseSchema, tblHandle:int, idxHandle:int, skipped:bool) -> str C++: virtual vtkStdString GetIndexSpecification( vtkSQLDatabaseSchema *schema, int tblHandle, int idxHandle, bool &skipped) Return the SQL string with the syntax to create an index inside a "CREATE TABLE" SQL statement. NB1: this method implements the following minimally-portable syntax: [] (,... ) It must be overwritten for those SQL backends which have a different syntax such as, e.g., MySQL. NB2: this method does not assume that INDEX creation is supported within a CREATE TABLE statement. Therefore, should such an INDEX arise in the schema, a CREATE INDEX statement is returned and skipped is set to true. Otherwise, skipped will always be returned false. """ return "" def GetLastErrorText(self): # real signature unknown; restored from __doc__ """ GetLastErrorText(self) -> str C++: virtual const char *GetLastErrorText() Get the last error text from the database I'm using const so that people do NOT use the standard vtkGetStringMacro in their implementation, because 99% of the time that will not be the correct thing to do... """ return "" def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBase(self, type:str) -> int C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type) override; Given the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBaseType(type:str) -> int C++: static vtkIdType GetNumberOfGenerationsFromBaseType( const char *type) Given a the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetQueryInstance(self): # real signature unknown; restored from __doc__ """ GetQueryInstance(self) -> vtkSQLQuery C++: virtual vtkSQLQuery *GetQueryInstance() Return an empty query on this database. """ return vtkSQLQuery def GetRecord(self, table): # real signature unknown; restored from __doc__ """ GetRecord(self, table:str) -> vtkStringArray C++: virtual vtkStringArray *GetRecord(const char *table) Get the list of fields for a particular table. """ pass def GetTablePreamble(self, __a): # real signature unknown; restored from __doc__ """ GetTablePreamble(self, __a:bool) -> str C++: virtual vtkStdString GetTablePreamble(bool) Return the SQL string with the syntax of the preamble following a "CREATE TABLE" SQL statement. NB: by default, this method returns an empty string. It must be overwritten for those SQL backends which allow such preambles such as, e.g., MySQL. """ return "" def GetTables(self): # real signature unknown; restored from __doc__ """ GetTables(self) -> vtkStringArray C++: virtual vtkStringArray *GetTables() Get the list of tables from the database. """ pass def GetTriggerSpecification(self, schema, tblHandle, trgHandle): # real signature unknown; restored from __doc__ """ GetTriggerSpecification(self, schema:vtkSQLDatabaseSchema, tblHandle:int, trgHandle:int) -> str C++: virtual vtkStdString GetTriggerSpecification( vtkSQLDatabaseSchema *schema, int tblHandle, int trgHandle) Return the SQL string with the syntax to create a trigger using a "CREATE TRIGGER" SQL statement. NB1: support is contingent on VTK_FEATURE_TRIGGERS being recognized as a supported feature. Not all backends (e.g., SQLite) support it. NB2: this method implements the following minimally-portable syntax: {BEFORE | AFTER} ON FOR EACH ROW It must be overwritten for those SQL backends which have a different syntax such as, e.g., PostgreSQL. """ return "" def GetURL(self): # real signature unknown; restored from __doc__ """ GetURL(self) -> str C++: virtual vtkStdString GetURL() Get the URL of the database. """ return "" def HasError(self): # real signature unknown; restored from __doc__ """ HasError(self) -> bool C++: virtual bool HasError() Did the last operation generate an error """ return False def IsA(self, type): # real signature unknown; restored from __doc__ """ IsA(self, type:str) -> int C++: vtkTypeBool IsA(const char *type) override; Return 1 if this class is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsOpen(self): # real signature unknown; restored from __doc__ """ IsOpen(self) -> bool C++: virtual bool IsOpen() Return whether the database has an open connection. """ return False def IsSupported(self, feature): # real signature unknown; restored from __doc__ """ IsSupported(self, feature:int) -> bool C++: virtual bool IsSupported(int feature) Return whether a feature is supported by the database. """ return False def IsTypeOf(self, type): # real signature unknown; restored from __doc__ """ IsTypeOf(type:str) -> int C++: static vtkTypeBool IsTypeOf(const char *type) Return 1 if this class type is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkSQLDatabase C++: vtkSQLDatabase *NewInstance() """ return vtkSQLDatabase def Open(self, password): # real signature unknown; restored from __doc__ """ Open(self, password:str) -> bool C++: virtual bool Open(const char *password) Open a new connection to the database. You need to set up any database parameters before calling this function. For database connections that do not require a password, pass an empty string. Returns true is the database was opened successfully, and false otherwise. """ return False def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkSQLDatabase C++: static vtkSQLDatabase *SafeDownCast(vtkObjectBase *o) """ return vtkSQLDatabase def UnRegisterAllCreateFromURLCallbacks(self): # real signature unknown; restored from __doc__ """ UnRegisterAllCreateFromURLCallbacks() -> None C++: static void UnRegisterAllCreateFromURLCallbacks() """ pass def __delattr__(self, *args, **kwargs): # real signature unknown """ Implement delattr(self, name). """ pass def __getattribute__(self, *args, **kwargs): # real signature unknown """ Return getattr(self, name). """ pass def __init__(self, *args, **kwargs): # real signature unknown pass @staticmethod # known case of __new__ def __new__(*args, **kwargs): # real signature unknown """ Create and return a new object. See help(type) for accurate signature. """ pass def __repr__(self, *args, **kwargs): # real signature unknown """ Return repr(self). """ pass def __setattr__(self, *args, **kwargs): # real signature unknown """ Implement setattr(self, name, value). """ pass def __str__(self, *args, **kwargs): # real signature unknown """ Return str(self). """ pass __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default """Pointer to the C++ object.""" __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkSQLDatabase', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'Open': , 'Close': , 'IsOpen': , 'GetQueryInstance': , 'HasError': , 'GetLastErrorText': , 'GetDatabaseType': , 'GetTables': , 'GetRecord': , 'IsSupported': , 'GetURL': , 'GetTablePreamble': , 'GetColumnSpecification': , 'GetIndexSpecification': , 'GetTriggerSpecification': , 'CreateFromURL': , 'EffectSchema': , 'UnRegisterAllCreateFromURLCallbacks': , 'DATABASE': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkSQLDatabase - maintain a connection to an sql database\\n\\nSuperclass: vtkObject\\n\\nAbstract base class for all SQL database connection classes. Manages\\na connection to the database, and is responsible for creating\\ninstances of the associated vtkSQLQuery objects associated with this\\nclass in order to perform execute queries on the database. To allow\\nconnections to a new type of database, create both a subclass of this\\nclass and vtkSQLQuery, and implement the required functions:\\n\\nOpen() - open the database connection, if possible. Close() - close\\nthe connection. GetQueryInstance() - create and return an instance of\\nthe vtkSQLQuery\\n subclass associated with the database type.\\n\\nThe subclass should also provide API to set connection parameters.\\n\\nThis class also provides the function EffectSchema to transform a\\ndatabase schema into a SQL database.\\n\\n@par Thanks: Thanks to Andrew Wilson from Sandia National\\nLaboratories for his work on the database classes and for the SQLite\\nexample. Thanks to David Thompson and Philippe Pebay from Sandia\\nNational Laboratories for implementing this class.\\n\\n@sa\\nvtkSQLQuery vtkSQLDatabaseSchema\\n\\n'})" __vtkname__ = 'vtkSQLDatabase' class vtkSQLDatabaseSchema(__vtkmodules_vtkCommonCore.vtkObject): """ vtkSQLDatabaseSchema - represent an SQL database schema Superclass: vtkObject This class stores the information required to create an SQL database from scratch. Information on each table's columns, indices, and triggers is stored. You may also store an arbitrary number of preamble statements, intended to be executed before any tables are created; this provides a way to create procedures or functions that may be invoked as part of a trigger action. Triggers and table options may be specified differently for each backend database type you wish to support. @par Thanks: Thanks to Philippe Pebay and David Thompson from Sandia National Laboratories for implementing this class. @sa vtkSQLDatabase """ def AddColumnToIndex(self, tblHandle, idxHandle, colHandle): # real signature unknown; restored from __doc__ """ AddColumnToIndex(self, tblHandle:int, idxHandle:int, colHandle:int) -> int C++: virtual int AddColumnToIndex(int tblHandle, int idxHandle, int colHandle) AddColumnToIndex(self, tblName:str, idxName:str, colName:str) -> int C++: virtual int AddColumnToIndex(const char *tblName, const char *idxName, const char *colName) Add a column to a table index. * The returned value is an index-column handle or -1 if an error occurred. """ return 0 def AddColumnToTable(self, tblHandle, colType, colName, colSize, colOpts): # real signature unknown; restored from __doc__ """ AddColumnToTable(self, tblHandle:int, colType:int, colName:str, colSize:int, colOpts:str) -> int C++: virtual int AddColumnToTable(int tblHandle, int colType, const char *colName, int colSize, const char *colOpts) AddColumnToTable(self, tblName:str, colType:int, colName:str, colSize:int, colAttribs:str) -> int C++: virtual int AddColumnToTable(const char *tblName, int colType, const char *colName, int colSize, const char *colAttribs) Add a column to table. * The returned value is a column handle or -1 if an error occurred. """ return 0 def AddIndexToTable(self, tblHandle, idxType, idxName): # real signature unknown; restored from __doc__ """ AddIndexToTable(self, tblHandle:int, idxType:int, idxName:str) -> int C++: virtual int AddIndexToTable(int tblHandle, int idxType, const char *idxName) AddIndexToTable(self, tblName:str, idxType:int, idxName:str) -> int C++: virtual int AddIndexToTable(const char *tblName, int idxType, const char *idxName) Add an index to table. * The returned value is an index handle or -1 if an error occurred. """ return 0 def AddOptionToTable(self, tblHandle, optText, optBackend, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ AddOptionToTable(self, tblHandle:int, optText:str, optBackend:str=...) -> int C++: virtual int AddOptionToTable(int tblHandle, const char *optText, const char *optBackend=VTK_SQL_ALLBACKENDS) AddOptionToTable(self, tblName:str, optStr:str, optBackend:str=...) -> int C++: virtual int AddOptionToTable(const char *tblName, const char *optStr, const char *optBackend=VTK_SQL_ALLBACKENDS) Add (possibly backend-specific) text to the end of a CREATE TABLE (...) statement. * This is most useful for specifying storage semantics of tables * that are specific to the backend. For example, table options * can be used to specify the TABLESPACE of a PostgreSQL table or * the ENGINE of a MySQL table. * The returned value is an option handle or -1 if an error occurred. """ pass def AddPreamble(self, preName, preAction, preBackend, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ AddPreamble(self, preName:str, preAction:str, preBackend:str=...) -> int C++: virtual int AddPreamble(const char *preName, const char *preAction, const char *preBackend=VTK_SQL_ALLBACKENDS) Add a preamble to the schema This can be used, in particular, to create functions and/or load languages in a backend-specific manner. Example usage: vtkSQLDatabaseSchema* schema = vtkSQLDatabaseSchema::New(); schema->SetName( "Example" ); schema->AddPreamble( "dropPLPGSQL", "DROP LANGUAGE IF EXISTS PLPGSQL CASCADE", VTK_SQL_POSTGRESQL ); schema->AddPreamble( "loadPLPGSQL", "CREATE LANGUAGE PLPGSQL", VTK_SQL_POSTGRESQL ); schema->AddPreamble( "createsomefunction", "CREATE OR REPLACE FUNCTION somefunction() RETURNS TRIGGER AS $btable$ " "BEGIN " "INSERT INTO btable (somevalue) VALUES (NEW.somenmbr); " "RETURN NEW; " "END; $btable$ LANGUAGE PLPGSQL", VTK_SQL_POSTGRESQL ); """ pass def AddTable(self, tblName): # real signature unknown; restored from __doc__ """ AddTable(self, tblName:str) -> int C++: virtual int AddTable(const char *tblName) Add a table to the schema """ return 0 def AddTableMultipleArguments(self, tblName): # real signature unknown; restored from __doc__ """ AddTableMultipleArguments(self, tblName:str) -> int C++: int AddTableMultipleArguments(const char *tblName, ...) An unwrappable but useful routine to construct built-in schema. Example usage: int main() { vtkSQLDatabaseSchema* schema = vtkSQLDatabaseSchema::New(); schema->SetName( "Example" ); schema->AddTableMultipleArguments( "atable", vtkSQLDatabaseSchema::COLUMN_TOKEN, vtkSQLDatabaseSchema::INTEGER, "tablekey", 0, "", vtkSQLDatabaseSchema::COLUMN_TOKEN, vtkSQLDatabaseSchema::VARCHAR, "somename", 11, "NOT nullptr", vtkSQLDatabaseSchema::COLUMN_TOKEN, vtkSQLDatabaseSchema::BIGINT, "somenmbr", 17, "DEFAULT 0", vtkSQLDatabaseSchema::INDEX_TOKEN, vtkSQLDatabaseSchema::PRIMARY_KEY, "bigkey", vtkSQLDatabaseSchema::INDEX_COLUMN_TOKEN, "tablekey", vtkSQLDatabaseSchema::END_INDEX_TOKEN, vtkSQLDatabaseSchema::INDEX_TOKEN, vtkSQLDatabaseSchema::UNIQUE, "reverselookup", vtkSQLDatabaseSchema::INDEX_COLUMN_TOKEN, "somename", vtkSQLDatabaseSchema::INDEX_COLUMN_TOKEN, "somenmbr", vtkSQLDatabaseSchema::END_INDEX_TOKEN, vtkSQLDatabaseSchema::TRIGGER_TOKEN, vtkSQLDatabaseSchema::AFTER_INSERT, "InsertTrigger", "DO NOTHING", VTK_SQL_SQLITE, vtkSQLDatabaseSchema::TRIGGER_TOKEN, vtkSQLDatabaseSchema::AFTER_INSERT, "InsertTrigger", "FOR EACH ROW EXECUTE PROCEDURE somefunction ()", VTK_SQL_POSTGRESQL, vtkSQLDatabaseSchema::TRIGGER_TOKEN, vtkSQLDatabaseSchema::AFTER_INSERT, "InsertTrigger", "FOR EACH ROW INSERT INTO btable SET SomeValue = NEW.SomeNmbr", VTK_SQL_MYSQL, vtkSQLDatabaseSchema::END_TABLE_TOKEN ); return 0; } """ return 0 def AddTriggerToTable(self, tblHandle, trgType, trgName, trgAction, trgBackend, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ AddTriggerToTable(self, tblHandle:int, trgType:int, trgName:str, trgAction:str, trgBackend:str=...) -> int C++: virtual int AddTriggerToTable(int tblHandle, int trgType, const char *trgName, const char *trgAction, const char *trgBackend=VTK_SQL_ALLBACKENDS) AddTriggerToTable(self, tblName:str, trgType:int, trgName:str, trgAction:str, trgBackend:str=...) -> int C++: virtual int AddTriggerToTable(const char *tblName, int trgType, const char *trgName, const char *trgAction, const char *trgBackend=VTK_SQL_ALLBACKENDS) Add a (possibly backend-specific) trigger action to a table. * Triggers must be given unique, non-nullptr names as some database backends require them. * The returned value is a trigger handle or -1 if an error occurred. """ pass def GetColumnAttributesFromHandle(self, tblHandle, colHandle): # real signature unknown; restored from __doc__ """ GetColumnAttributesFromHandle(self, tblHandle:int, colHandle:int) -> str C++: const char *GetColumnAttributesFromHandle(int tblHandle, int colHandle) Given the handles of a table and a column, get the attributes of the column. """ return "" def GetColumnHandleFromName(self, tblName, colName): # real signature unknown; restored from __doc__ """ GetColumnHandleFromName(self, tblName:str, colName:str) -> int C++: int GetColumnHandleFromName(const char *tblName, const char *colName) Given the names of a table and a column, get the handle of the column in this table. """ return 0 def GetColumnNameFromHandle(self, tblHandle, colHandle): # real signature unknown; restored from __doc__ """ GetColumnNameFromHandle(self, tblHandle:int, colHandle:int) -> str C++: const char *GetColumnNameFromHandle(int tblHandle, int colHandle) Given the handles of a table and a column, get the name of the column. """ return "" def GetColumnSizeFromHandle(self, tblHandle, colHandle): # real signature unknown; restored from __doc__ """ GetColumnSizeFromHandle(self, tblHandle:int, colHandle:int) -> int C++: int GetColumnSizeFromHandle(int tblHandle, int colHandle) Given the handles of a table and a column, get the size of the column. """ return 0 def GetColumnTypeFromHandle(self, tblHandle, colHandle): # real signature unknown; restored from __doc__ """ GetColumnTypeFromHandle(self, tblHandle:int, colHandle:int) -> int C++: int GetColumnTypeFromHandle(int tblHandle, int colHandle) Given the handles of a table and a column, get the type of the column. """ return 0 def GetIndexColumnNameFromHandle(self, tblHandle, idxHandle, cnmHandle): # real signature unknown; restored from __doc__ """ GetIndexColumnNameFromHandle(self, tblHandle:int, idxHandle:int, cnmHandle:int) -> str C++: const char *GetIndexColumnNameFromHandle(int tblHandle, int idxHandle, int cnmHandle) Given the handles of a table, an index, and a column name, get the column name. """ return "" def GetIndexHandleFromName(self, tblName, idxName): # real signature unknown; restored from __doc__ """ GetIndexHandleFromName(self, tblName:str, idxName:str) -> int C++: int GetIndexHandleFromName(const char *tblName, const char *idxName) Given the names of a table and an index, get the handle of the index in this table. """ return 0 def GetIndexNameFromHandle(self, tblHandle, idxHandle): # real signature unknown; restored from __doc__ """ GetIndexNameFromHandle(self, tblHandle:int, idxHandle:int) -> str C++: const char *GetIndexNameFromHandle(int tblHandle, int idxHandle) Given the handles of a table and an index, get the name of the index. """ return "" def GetIndexTypeFromHandle(self, tblHandle, idxHandle): # real signature unknown; restored from __doc__ """ GetIndexTypeFromHandle(self, tblHandle:int, idxHandle:int) -> int C++: int GetIndexTypeFromHandle(int tblHandle, int idxHandle) Given the handles of a table and an index, get the type of the index. """ return 0 def GetName(self): # real signature unknown; restored from __doc__ """ GetName(self) -> str C++: virtual char *GetName() """ return "" def GetNumberOfColumnNamesInIndex(self, tblHandle, idxHandle): # real signature unknown; restored from __doc__ """ GetNumberOfColumnNamesInIndex(self, tblHandle:int, idxHandle:int) -> int C++: int GetNumberOfColumnNamesInIndex(int tblHandle, int idxHandle) Get the number of column names associated to a particular index in a particular table . """ return 0 def GetNumberOfColumnsInTable(self, tblHandle): # real signature unknown; restored from __doc__ """ GetNumberOfColumnsInTable(self, tblHandle:int) -> int C++: int GetNumberOfColumnsInTable(int tblHandle) Get the number of columns in a particular table . """ return 0 def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBase(self, type:str) -> int C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type) override; Given the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBaseType(type:str) -> int C++: static vtkIdType GetNumberOfGenerationsFromBaseType( const char *type) Given a the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetNumberOfIndicesInTable(self, tblHandle): # real signature unknown; restored from __doc__ """ GetNumberOfIndicesInTable(self, tblHandle:int) -> int C++: int GetNumberOfIndicesInTable(int tblHandle) Get the number of indices in a particular table . """ return 0 def GetNumberOfOptionsInTable(self, tblHandle): # real signature unknown; restored from __doc__ """ GetNumberOfOptionsInTable(self, tblHandle:int) -> int C++: int GetNumberOfOptionsInTable(int tblHandle) Get the number of options associated with a particular table. """ return 0 def GetNumberOfPreambles(self): # real signature unknown; restored from __doc__ """ GetNumberOfPreambles(self) -> int C++: int GetNumberOfPreambles() Get the number of preambles. """ return 0 def GetNumberOfTables(self): # real signature unknown; restored from __doc__ """ GetNumberOfTables(self) -> int C++: int GetNumberOfTables() Get the number of tables. """ return 0 def GetNumberOfTriggersInTable(self, tblHandle): # real signature unknown; restored from __doc__ """ GetNumberOfTriggersInTable(self, tblHandle:int) -> int C++: int GetNumberOfTriggersInTable(int tblHandle) Get the number of triggers defined for a particular table. """ return 0 def GetOptionBackendFromHandle(self, tblHandle, optHandle): # real signature unknown; restored from __doc__ """ GetOptionBackendFromHandle(self, tblHandle:int, optHandle:int) -> str C++: const char *GetOptionBackendFromHandle(int tblHandle, int optHandle) Given the handles of a table and one of its options, get the backend of the option. """ return "" def GetOptionTextFromHandle(self, tblHandle, optHandle): # real signature unknown; restored from __doc__ """ GetOptionTextFromHandle(self, tblHandle:int, optHandle:int) -> str C++: const char *GetOptionTextFromHandle(int tblHandle, int optHandle) Given the handles of a table and one of its options, return the text of the option. """ return "" def GetPreambleActionFromHandle(self, preHandle): # real signature unknown; restored from __doc__ """ GetPreambleActionFromHandle(self, preHandle:int) -> str C++: const char *GetPreambleActionFromHandle(int preHandle) Given a preamble handle, get its action. """ return "" def GetPreambleBackendFromHandle(self, preHandle): # real signature unknown; restored from __doc__ """ GetPreambleBackendFromHandle(self, preHandle:int) -> str C++: const char *GetPreambleBackendFromHandle(int preHandle) Given a preamble handle, get its backend. """ return "" def GetPreambleHandleFromName(self, preName): # real signature unknown; restored from __doc__ """ GetPreambleHandleFromName(self, preName:str) -> int C++: int GetPreambleHandleFromName(const char *preName) Given a preamble name, get its handle. """ return 0 def GetPreambleNameFromHandle(self, preHandle): # real signature unknown; restored from __doc__ """ GetPreambleNameFromHandle(self, preHandle:int) -> str C++: const char *GetPreambleNameFromHandle(int preHandle) Given a preamble handle, get its name. """ return "" def GetTableHandleFromName(self, tblName): # real signature unknown; restored from __doc__ """ GetTableHandleFromName(self, tblName:str) -> int C++: int GetTableHandleFromName(const char *tblName) Given a table name, get its handle. """ return 0 def GetTableNameFromHandle(self, tblHandle): # real signature unknown; restored from __doc__ """ GetTableNameFromHandle(self, tblHandle:int) -> str C++: const char *GetTableNameFromHandle(int tblHandle) Given a table handle, get its name. """ return "" def GetTriggerActionFromHandle(self, tblHandle, trgHandle): # real signature unknown; restored from __doc__ """ GetTriggerActionFromHandle(self, tblHandle:int, trgHandle:int) -> str C++: const char *GetTriggerActionFromHandle(int tblHandle, int trgHandle) Given the handles of a table and a trigger, get the action of the trigger. """ return "" def GetTriggerBackendFromHandle(self, tblHandle, trgHandle): # real signature unknown; restored from __doc__ """ GetTriggerBackendFromHandle(self, tblHandle:int, trgHandle:int) -> str C++: const char *GetTriggerBackendFromHandle(int tblHandle, int trgHandle) Given the handles of a table and a trigger, get the backend of the trigger. """ return "" def GetTriggerHandleFromName(self, tblName, trgName): # real signature unknown; restored from __doc__ """ GetTriggerHandleFromName(self, tblName:str, trgName:str) -> int C++: int GetTriggerHandleFromName(const char *tblName, const char *trgName) Given the names of a trigger and a table, get the handle of the trigger in this table. """ return 0 def GetTriggerNameFromHandle(self, tblHandle, trgHandle): # real signature unknown; restored from __doc__ """ GetTriggerNameFromHandle(self, tblHandle:int, trgHandle:int) -> str C++: const char *GetTriggerNameFromHandle(int tblHandle, int trgHandle) Given the handles of a table and a trigger, get the name of the trigger. """ return "" def GetTriggerTypeFromHandle(self, tblHandle, trgHandle): # real signature unknown; restored from __doc__ """ GetTriggerTypeFromHandle(self, tblHandle:int, trgHandle:int) -> int C++: int GetTriggerTypeFromHandle(int tblHandle, int trgHandle) Given the handles of a table and a trigger, get the type of the trigger. """ return 0 def IsA(self, type): # real signature unknown; restored from __doc__ """ IsA(self, type:str) -> int C++: vtkTypeBool IsA(const char *type) override; Return 1 if this class is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsTypeOf(self, type): # real signature unknown; restored from __doc__ """ IsTypeOf(type:str) -> int C++: static vtkTypeBool IsTypeOf(const char *type) Return 1 if this class type is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkSQLDatabaseSchema C++: vtkSQLDatabaseSchema *NewInstance() """ return vtkSQLDatabaseSchema def Reset(self): # real signature unknown; restored from __doc__ """ Reset(self) -> None C++: void Reset() Reset the schema to its initial, empty state. """ pass def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkSQLDatabaseSchema C++: static vtkSQLDatabaseSchema *SafeDownCast(vtkObjectBase *o) """ return vtkSQLDatabaseSchema def SetName(self, _arg): # real signature unknown; restored from __doc__ """ SetName(self, _arg:str) -> None C++: virtual void SetName(const char *_arg) Set/Get the name of the schema. """ pass def __delattr__(self, *args, **kwargs): # real signature unknown """ Implement delattr(self, name). """ pass def __getattribute__(self, *args, **kwargs): # real signature unknown """ Return getattr(self, name). """ pass def __init__(self, *args, **kwargs): # real signature unknown pass @staticmethod # known case of __new__ def __new__(*args, **kwargs): # real signature unknown """ Create and return a new object. See help(type) for accurate signature. """ pass def __repr__(self, *args, **kwargs): # real signature unknown """ Return repr(self). """ pass def __setattr__(self, *args, **kwargs): # real signature unknown """ Implement setattr(self, name, value). """ pass def __str__(self, *args, **kwargs): # real signature unknown """ Return str(self). """ pass __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default """Pointer to the C++ object.""" AFTER_DELETE = 5 AFTER_INSERT = 1 AFTER_UPDATE = 3 BEFORE_DELETE = 4 BEFORE_INSERT = 0 BEFORE_UPDATE = 2 BIGINT = 3 BLOB = 8 COLUMN_TOKEN = 58 DatabaseColumnType = None # (!) real value is "" DatabaseIndexType = None # (!) real value is "" DatabaseTriggerType = None # (!) real value is "" DATE = 10 DOUBLE = 7 END_INDEX_TOKEN = 75 END_TABLE_TOKEN = 99 INDEX = 0 INDEX_COLUMN_TOKEN = 65 INDEX_TOKEN = 63 INTEGER = 2 OPTION_TOKEN = 86 PRIMARY_KEY = 2 REAL = 6 SERIAL = 0 SMALLINT = 1 TEXT = 5 TIME = 9 TIMESTAMP = 11 TRIGGER_TOKEN = 81 UNIQUE = 1 VarargTokens = None # (!) real value is "" VARCHAR = 4 __dict__ = None # (!) real value is 'mappingproxy({\'__vtkname__\': \'vtkSQLDatabaseSchema\', \'IsTypeOf\': , \'IsA\': , \'SafeDownCast\': , \'NewInstance\': , \'GetNumberOfGenerationsFromBaseType\': , \'GetNumberOfGenerationsFromBase\': , \'AddPreamble\': , \'AddTable\': , \'AddColumnToTable\': , \'AddIndexToTable\': , \'AddColumnToIndex\': , \'AddTriggerToTable\': , \'AddOptionToTable\': , \'GetPreambleHandleFromName\': , \'GetPreambleNameFromHandle\': , \'GetPreambleActionFromHandle\': , \'GetPreambleBackendFromHandle\': , \'GetTableHandleFromName\': , \'GetTableNameFromHandle\': , \'GetIndexHandleFromName\': , \'GetIndexNameFromHandle\': , \'GetIndexTypeFromHandle\': , \'GetIndexColumnNameFromHandle\': , \'GetColumnHandleFromName\': , \'GetColumnNameFromHandle\': , \'GetColumnTypeFromHandle\': , \'GetColumnSizeFromHandle\': , \'GetColumnAttributesFromHandle\': , \'GetTriggerHandleFromName\': , \'GetTriggerNameFromHandle\': , \'GetTriggerTypeFromHandle\': , \'GetTriggerActionFromHandle\': , \'GetTriggerBackendFromHandle\': , \'GetOptionTextFromHandle\': , \'GetOptionBackendFromHandle\': , \'Reset\': , \'GetNumberOfPreambles\': , \'GetNumberOfTables\': , \'GetNumberOfColumnsInTable\': , \'GetNumberOfIndicesInTable\': , \'GetNumberOfColumnNamesInIndex\': , \'GetNumberOfTriggersInTable\': , \'GetNumberOfOptionsInTable\': , \'SetName\': , \'GetName\': , \'AddTableMultipleArguments\': , \'DatabaseColumnType\': , \'DatabaseIndexType\': , \'DatabaseTriggerType\': , \'VarargTokens\': , \'SERIAL\': 0, \'SMALLINT\': 1, \'INTEGER\': 2, \'BIGINT\': 3, \'VARCHAR\': 4, \'TEXT\': 5, \'REAL\': 6, \'DOUBLE\': 7, \'BLOB\': 8, \'TIME\': 9, \'DATE\': 10, \'TIMESTAMP\': 11, \'INDEX\': 0, \'UNIQUE\': 1, \'PRIMARY_KEY\': 2, \'BEFORE_INSERT\': 0, \'AFTER_INSERT\': 1, \'BEFORE_UPDATE\': 2, \'AFTER_UPDATE\': 3, \'BEFORE_DELETE\': 4, \'AFTER_DELETE\': 5, \'COLUMN_TOKEN\': 58, \'INDEX_TOKEN\': 63, \'INDEX_COLUMN_TOKEN\': 65, \'END_INDEX_TOKEN\': 75, \'TRIGGER_TOKEN\': 81, \'OPTION_TOKEN\': 86, \'END_TABLE_TOKEN\': 99, \'__new__\': , \'__repr__\': , \'__str__\': , \'__getattribute__\': , \'__setattr__\': , \'__delattr__\': , \'__dict__\': , \'__this__\': , \'__doc__\': "vtkSQLDatabaseSchema - represent an SQL database schema\\n\\nSuperclass: vtkObject\\n\\nThis class stores the information required to create an SQL database\\nfrom scratch. Information on each table\'s columns, indices, and\\ntriggers is stored. You may also store an arbitrary number of\\npreamble statements, intended to be executed before any tables are\\ncreated; this provides a way to create procedures or functions that\\nmay be invoked as part of a trigger action. Triggers and table\\noptions may be specified differently for each backend database type\\nyou wish to support.\\n\\n@par Thanks: Thanks to Philippe Pebay and David Thompson from Sandia\\nNational Laboratories for implementing this class.\\n\\n@sa\\nvtkSQLDatabase\\n\\n"})' __vtkname__ = 'vtkSQLDatabaseSchema' class vtkSQLDatabaseTableSource(__vtkmodules_vtkCommonExecutionModel.vtkTableAlgorithm): """ vtkSQLDatabaseTableSource - Generates a vtkTable based on an SQL query. Superclass: vtkTableAlgorithm This class combines vtkSQLDatabase, vtkSQLQuery, and vtkQueryToTable to provide a convenience class for generating tables from databases. Also this class can be easily wrapped and used within ParaView / OverView. """ def GeneratePedigreeIdsOff(self): # real signature unknown; restored from __doc__ """ GeneratePedigreeIdsOff(self) -> None C++: virtual void GeneratePedigreeIdsOff() """ pass def GeneratePedigreeIdsOn(self): # real signature unknown; restored from __doc__ """ GeneratePedigreeIdsOn(self) -> None C++: virtual void GeneratePedigreeIdsOn() """ pass def GetGeneratePedigreeIds(self): # real signature unknown; restored from __doc__ """ GetGeneratePedigreeIds(self) -> bool C++: virtual bool GetGeneratePedigreeIds() """ return False def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBase(self, type:str) -> int C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type) override; Given the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBaseType(type:str) -> int C++: static vtkIdType GetNumberOfGenerationsFromBaseType( const char *type) Given a the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetPedigreeIdArrayName(self): # real signature unknown; restored from __doc__ """ GetPedigreeIdArrayName(self) -> str C++: virtual char *GetPedigreeIdArrayName() """ return "" def GetQuery(self): # real signature unknown; restored from __doc__ """ GetQuery(self) -> str C++: vtkStdString GetQuery() """ return "" def GetURL(self): # real signature unknown; restored from __doc__ """ GetURL(self) -> str C++: vtkStdString GetURL() """ return "" def IsA(self, type): # real signature unknown; restored from __doc__ """ IsA(self, type:str) -> int C++: vtkTypeBool IsA(const char *type) override; Return 1 if this class is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsTypeOf(self, type): # real signature unknown; restored from __doc__ """ IsTypeOf(type:str) -> int C++: static vtkTypeBool IsTypeOf(const char *type) Return 1 if this class type is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkSQLDatabaseTableSource C++: vtkSQLDatabaseTableSource *NewInstance() """ return vtkSQLDatabaseTableSource def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkSQLDatabaseTableSource C++: static vtkSQLDatabaseTableSource *SafeDownCast( vtkObjectBase *o) """ return vtkSQLDatabaseTableSource def SetGeneratePedigreeIds(self, _arg): # real signature unknown; restored from __doc__ """ SetGeneratePedigreeIds(self, _arg:bool) -> None C++: virtual void SetGeneratePedigreeIds(bool _arg) If on (default), generates pedigree ids automatically. If off, assign one of the arrays to be the pedigree id. """ pass def SetPassword(self, password): # real signature unknown; restored from __doc__ """ SetPassword(self, password:str) -> None C++: void SetPassword(const vtkStdString &password) """ pass def SetPedigreeIdArrayName(self, _arg): # real signature unknown; restored from __doc__ """ SetPedigreeIdArrayName(self, _arg:str) -> None C++: virtual void SetPedigreeIdArrayName(const char *_arg) The name of the array for generating or assigning pedigree ids (default "id"). """ pass def SetQuery(self, query): # real signature unknown; restored from __doc__ """ SetQuery(self, query:str) -> None C++: void SetQuery(const vtkStdString &query) """ pass def SetURL(self, url): # real signature unknown; restored from __doc__ """ SetURL(self, url:str) -> None C++: void SetURL(const vtkStdString &url) """ pass def __delattr__(self, *args, **kwargs): # real signature unknown """ Implement delattr(self, name). """ pass def __getattribute__(self, *args, **kwargs): # real signature unknown """ Return getattr(self, name). """ pass def __init__(self, *args, **kwargs): # real signature unknown pass @staticmethod # known case of __new__ def __new__(*args, **kwargs): # real signature unknown """ Create and return a new object. See help(type) for accurate signature. """ pass def __repr__(self, *args, **kwargs): # real signature unknown """ Return repr(self). """ pass def __setattr__(self, *args, **kwargs): # real signature unknown """ Implement setattr(self, name, value). """ pass def __str__(self, *args, **kwargs): # real signature unknown """ Return str(self). """ pass __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default """Pointer to the C++ object.""" __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkSQLDatabaseTableSource', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'GetURL': , 'SetURL': , 'SetPassword': , 'GetQuery': , 'SetQuery': , 'SetPedigreeIdArrayName': , 'GetPedigreeIdArrayName': , 'SetGeneratePedigreeIds': , 'GetGeneratePedigreeIds': , 'GeneratePedigreeIdsOn': , 'GeneratePedigreeIdsOff': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkSQLDatabaseTableSource - Generates a vtkTable based on an SQL\\nquery.\\n\\nSuperclass: vtkTableAlgorithm\\n\\nThis class combines vtkSQLDatabase, vtkSQLQuery, and vtkQueryToTable\\nto provide a convenience class for generating tables from databases.\\nAlso this class can be easily wrapped and used within ParaView /\\nOverView.\\n\\n'})" __vtkname__ = 'vtkSQLDatabaseTableSource' class vtkSQLiteDatabase(vtkSQLDatabase): """ vtkSQLiteDatabase - maintain a connection to an SQLite database Superclass: vtkSQLDatabase SQLite (http://www.sqlite.org) is a public-domain SQL database written in C++. It's small, fast, and can be easily embedded inside other applications. Its databases are stored in files. This class provides a VTK interface to SQLite. You do not need to download any external libraries: we include a copy of SQLite 3.3.16 in VTK/Utilities/vtksqlite. If you want to open a database that stays in memory and never gets written to disk, pass in the URL sqlite://:memory:; otherwise, specify the file path by passing the URL sqlite://. @par Thanks: Thanks to Andrew Wilson and Philippe Pebay from Sandia National Laboratories for implementing this class. @sa vtkSQLiteQuery """ def Close(self): # real signature unknown; restored from __doc__ """ Close(self) -> None C++: void Close() override; Close the connection to the database. """ pass def GetColumnSpecification(self, schema, tblHandle, colHandle): # real signature unknown; restored from __doc__ """ GetColumnSpecification(self, schema:vtkSQLDatabaseSchema, tblHandle:int, colHandle:int) -> str C++: vtkStdString GetColumnSpecification( vtkSQLDatabaseSchema *schema, int tblHandle, int colHandle) override; Return the SQL string with the syntax to create a column inside a "CREATE TABLE" SQL statement. NB: this method implements the SQLite-specific syntax: """ return "" def GetDatabaseFileName(self): # real signature unknown; restored from __doc__ """ GetDatabaseFileName(self) -> str C++: virtual char *GetDatabaseFileName() String representing the database filename. """ return "" def GetDatabaseType(self): # real signature unknown; restored from __doc__ """ GetDatabaseType(self) -> str C++: const char *GetDatabaseType() override; String representing database type (e.g. "sqlite"). """ return "" def GetLastErrorText(self): # real signature unknown; restored from __doc__ """ GetLastErrorText(self) -> str C++: const char *GetLastErrorText() override; Get the last error text from the database """ return "" def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBase(self, type:str) -> int C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type) override; Given the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBaseType(type:str) -> int C++: static vtkIdType GetNumberOfGenerationsFromBaseType( const char *type) Given a the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetQueryInstance(self): # real signature unknown; restored from __doc__ """ GetQueryInstance(self) -> vtkSQLQuery C++: vtkSQLQuery *GetQueryInstance() override; Return an empty query on this database. """ return vtkSQLQuery def GetRecord(self, table): # real signature unknown; restored from __doc__ """ GetRecord(self, table:str) -> vtkStringArray C++: vtkStringArray *GetRecord(const char *table) override; Get the list of fields for a particular table """ pass def GetTables(self): # real signature unknown; restored from __doc__ """ GetTables(self) -> vtkStringArray C++: vtkStringArray *GetTables() override; Get the list of tables from the database """ pass def GetURL(self): # real signature unknown; restored from __doc__ """ GetURL(self) -> str C++: vtkStdString GetURL() override; Get the URL of the database. """ return "" def HasError(self): # real signature unknown; restored from __doc__ """ HasError(self) -> bool C++: bool HasError() override; Did the last operation generate an error """ return False def IsA(self, type): # real signature unknown; restored from __doc__ """ IsA(self, type:str) -> int C++: vtkTypeBool IsA(const char *type) override; Return 1 if this class is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsOpen(self): # real signature unknown; restored from __doc__ """ IsOpen(self) -> bool C++: bool IsOpen() override; Return whether the database has an open connection """ return False def IsSupported(self, feature): # real signature unknown; restored from __doc__ """ IsSupported(self, feature:int) -> bool C++: bool IsSupported(int feature) override; Return whether a feature is supported by the database. """ return False def IsTypeOf(self, type): # real signature unknown; restored from __doc__ """ IsTypeOf(type:str) -> int C++: static vtkTypeBool IsTypeOf(const char *type) Return 1 if this class type is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkSQLiteDatabase C++: vtkSQLiteDatabase *NewInstance() """ return vtkSQLiteDatabase def Open(self, password): # real signature unknown; restored from __doc__ """ Open(self, password:str) -> bool C++: bool Open(const char *password) override; Open(self, password:str, mode:int) -> bool C++: bool Open(const char *password, int mode) Open a new connection to the database. You need to set the filename before calling this function. Returns true if the database was opened successfully; false otherwise. - USE_EXISTING (default) - Fail if the file does not exist. - USE_EXISTING_OR_CREATE - Create a new file if necessary. - CREATE_OR_CLEAR - Create new or clear existing file. - CREATE - Create new, fail if file exists. """ return False def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkSQLiteDatabase C++: static vtkSQLiteDatabase *SafeDownCast(vtkObjectBase *o) """ return vtkSQLiteDatabase def SetDatabaseFileName(self, _arg): # real signature unknown; restored from __doc__ """ SetDatabaseFileName(self, _arg:str) -> None C++: virtual void SetDatabaseFileName(const char *_arg) """ pass def __delattr__(self, *args, **kwargs): # real signature unknown """ Implement delattr(self, name). """ pass def __getattribute__(self, *args, **kwargs): # real signature unknown """ Return getattr(self, name). """ pass def __init__(self, *args, **kwargs): # real signature unknown pass @staticmethod # known case of __new__ def __new__(*args, **kwargs): # real signature unknown """ Create and return a new object. See help(type) for accurate signature. """ pass def __repr__(self, *args, **kwargs): # real signature unknown """ Return repr(self). """ pass def __setattr__(self, *args, **kwargs): # real signature unknown """ Implement setattr(self, name, value). """ pass def __str__(self, *args, **kwargs): # real signature unknown """ Return str(self). """ pass __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default """Pointer to the C++ object.""" CREATE = 3 CREATE_OR_CLEAR = 2 USE_EXISTING = 0 USE_EXISTING_OR_CREATE = 1 __dict__ = None # (!) real value is 'mappingproxy({\'__vtkname__\': \'vtkSQLiteDatabase\', \'IsTypeOf\': , \'IsA\': , \'SafeDownCast\': , \'NewInstance\': , \'GetNumberOfGenerationsFromBaseType\': , \'GetNumberOfGenerationsFromBase\': , \'Open\': , \'Close\': , \'IsOpen\': , \'GetQueryInstance\': , \'GetTables\': , \'GetRecord\': , \'IsSupported\': , \'HasError\': , \'GetLastErrorText\': , \'GetDatabaseType\': , \'GetDatabaseFileName\': , \'SetDatabaseFileName\': , \'GetURL\': , \'GetColumnSpecification\': , \'USE_EXISTING\': 0, \'USE_EXISTING_OR_CREATE\': 1, \'CREATE_OR_CLEAR\': 2, \'CREATE\': 3, \'__new__\': , \'__repr__\': , \'__str__\': , \'__getattribute__\': , \'__setattr__\': , \'__delattr__\': , \'__dict__\': , \'__this__\': , \'__doc__\': "vtkSQLiteDatabase - maintain a connection to an SQLite database\\n\\nSuperclass: vtkSQLDatabase\\n\\nSQLite (http://www.sqlite.org) is a public-domain SQL database\\nwritten in C++. It\'s small, fast, and can be easily embedded inside\\nother applications. Its databases are stored in files.\\n\\nThis class provides a VTK interface to SQLite. You do not need to\\ndownload any external libraries: we include a copy of SQLite 3.3.16\\nin VTK/Utilities/vtksqlite.\\n\\nIf you want to open a database that stays in memory and never gets\\nwritten to disk, pass in the URL sqlite://:memory:; otherwise,\\nspecify the file path by passing the URL sqlite://.\\n\\n@par Thanks: Thanks to Andrew Wilson and Philippe Pebay from Sandia\\nNational Laboratories for implementing this class.\\n\\n@sa\\nvtkSQLiteQuery\\n\\n"})' __vtkname__ = 'vtkSQLiteDatabase' class vtkSQLQuery(vtkRowQuery): """ vtkSQLQuery - executes an sql query and retrieves results Superclass: vtkRowQuery The abstract superclass of SQL query classes. Instances of subclasses of vtkSQLQuery are created using the GetQueryInstance() function in vtkSQLDatabase. To implement a query connection for a new database type, subclass both vtkSQLDatabase and vtkSQLQuery, and implement the required functions. For the query class, this involves the following: Execute() - Execute the query on the database. No results need to be retrieved at this point, unless you are performing caching. GetNumberOfFields() - After Execute() is performed, returns the number of fields in the query results. GetFieldName() - The name of the field at an index. GetFieldType() - The data type of the field at an index. NextRow() - Advances the query results by one row, and returns whether there are more rows left in the query. DataValue() - Extract a single data value from the current row. Begin/Rollback/CommitTransaction() - These methods are optional but recommended if the database supports transactions. @par Thanks: Thanks to Andrew Wilson from Sandia National Laboratories for his work on the database classes. @sa vtkSQLDatabase """ def BeginTransaction(self): # real signature unknown; restored from __doc__ """ BeginTransaction(self) -> bool C++: virtual bool BeginTransaction() Begin, commit, or roll back a transaction. If the underlying database does not support transactions these calls will do nothing. """ return False def BindParameter(self, index, value): # real signature unknown; restored from __doc__ """ BindParameter(self, index:int, value:int) -> bool C++: virtual bool BindParameter(int index, int value) BindParameter(self, index:int, value:int) -> bool C++: virtual bool BindParameter(int index, long value) BindParameter(self, index:int, value:int) -> bool C++: virtual bool BindParameter(int index, long long value) BindParameter(self, index:int, value:float) -> bool C++: virtual bool BindParameter(int index, double value) BindParameter(self, index:int, stringValue:str, length:int) -> bool C++: virtual bool BindParameter(int index, const char *stringValue, size_t length) BindParameter(self, index:int, string:str) -> bool C++: virtual bool BindParameter(int index, const vtkStdString &string) BindParameter(self, index:int, var:vtkVariant) -> bool C++: virtual bool BindParameter(int index, vtkVariant var) BindParameter(self, index:int, data:Pointer, length:int) -> bool C++: virtual bool BindParameter(int index, const void *data, size_t length) """ return False def ClearParameterBindings(self): # real signature unknown; restored from __doc__ """ ClearParameterBindings(self) -> bool C++: virtual bool ClearParameterBindings() Reset all parameter bindings to nullptr. """ return False def CommitTransaction(self): # real signature unknown; restored from __doc__ """ CommitTransaction(self) -> bool C++: virtual bool CommitTransaction() """ return False def EscapeString(self, s, addSurroundingQuotes=True): # real signature unknown; restored from __doc__ """ EscapeString(self, s:str, addSurroundingQuotes:bool=True) -> str C++: virtual vtkStdString EscapeString(vtkStdString s, bool addSurroundingQuotes=true) Escape a string for inclusion into an SQL query. If addSurroundingQuotes is true, then quotation marks appropriate to the backend database will be added to enclose the escaped string. This argument defaults to true. * A default, simple-minded implementation is provided for * database backends that do not provde a way to escape * strings for use inside queries. """ return "" def Execute(self): # real signature unknown; restored from __doc__ """ Execute(self) -> bool C++: bool Execute() override = 0; Execute the query. This must be performed before any field name or data access functions are used. """ return False def GetDatabase(self): # real signature unknown; restored from __doc__ """ GetDatabase(self) -> vtkSQLDatabase C++: virtual vtkSQLDatabase *GetDatabase() Return the database associated with the query. """ return vtkSQLDatabase def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBase(self, type:str) -> int C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type) override; Given the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBaseType(type:str) -> int C++: static vtkIdType GetNumberOfGenerationsFromBaseType( const char *type) Given a the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetQuery(self): # real signature unknown; restored from __doc__ """ GetQuery(self) -> str C++: virtual const char *GetQuery() """ return "" def IsA(self, type): # real signature unknown; restored from __doc__ """ IsA(self, type:str) -> int C++: vtkTypeBool IsA(const char *type) override; Return 1 if this class is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsActive(self): # real signature unknown; restored from __doc__ """ IsActive(self) -> bool C++: bool IsActive() override; Return true if the query is active (i.e. execution was successful and results are ready to be fetched). Returns false on error or inactive query. """ return False def IsTypeOf(self, type): # real signature unknown; restored from __doc__ """ IsTypeOf(type:str) -> int C++: static vtkTypeBool IsTypeOf(const char *type) Return 1 if this class type is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkSQLQuery C++: vtkSQLQuery *NewInstance() """ return vtkSQLQuery def RollbackTransaction(self): # real signature unknown; restored from __doc__ """ RollbackTransaction(self) -> bool C++: virtual bool RollbackTransaction() """ return False def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkSQLQuery C++: static vtkSQLQuery *SafeDownCast(vtkObjectBase *o) """ return vtkSQLQuery def SetQuery(self, query): # real signature unknown; restored from __doc__ """ SetQuery(self, query:str) -> bool C++: virtual bool SetQuery(const char *query) The query string to be executed. Since some databases will process the query string as soon as it's set, this method returns a boolean to indicate success or failure. """ return False def __delattr__(self, *args, **kwargs): # real signature unknown """ Implement delattr(self, name). """ pass def __getattribute__(self, *args, **kwargs): # real signature unknown """ Return getattr(self, name). """ pass def __init__(self, *args, **kwargs): # real signature unknown pass @staticmethod # known case of __new__ def __new__(*args, **kwargs): # real signature unknown """ Create and return a new object. See help(type) for accurate signature. """ pass def __repr__(self, *args, **kwargs): # real signature unknown """ Return repr(self). """ pass def __setattr__(self, *args, **kwargs): # real signature unknown """ Implement setattr(self, name, value). """ pass def __str__(self, *args, **kwargs): # real signature unknown """ Return str(self). """ pass __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default """Pointer to the C++ object.""" __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkSQLQuery', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'SetQuery': , 'GetQuery': , 'IsActive': , 'Execute': , 'BeginTransaction': , 'CommitTransaction': , 'RollbackTransaction': , 'GetDatabase': , 'BindParameter': , 'ClearParameterBindings': , 'EscapeString': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkSQLQuery - executes an sql query and retrieves results\\n\\nSuperclass: vtkRowQuery\\n\\nThe abstract superclass of SQL query classes. Instances of\\nsubclasses of vtkSQLQuery are created using the GetQueryInstance()\\nfunction in vtkSQLDatabase. To implement a query connection for a\\nnew database type, subclass both vtkSQLDatabase and vtkSQLQuery, and\\nimplement the required functions. For the query class, this involves\\nthe following:\\n\\nExecute() - Execute the query on the database. No results need to be\\n retrieved at this point, unless you are performing\\ncaching.\\n\\nGetNumberOfFields() - After Execute() is performed, returns the\\nnumber\\n of fields in the query results.\\n\\nGetFieldName() - The name of the field at an index.\\n\\nGetFieldType() - The data type of the field at an index.\\n\\nNextRow() - Advances the query results by one row, and returns\\nwhether\\n there are more rows left in the query.\\n\\nDataValue() - Extract a single data value from the current row.\\n\\nBegin/Rollback/CommitTransaction() - These methods are optional but\\nrecommended if the database supports transactions.\\n\\n@par Thanks: Thanks to Andrew Wilson from Sandia National\\nLaboratories for his work on the database classes.\\n\\n@sa\\nvtkSQLDatabase\\n\\n'})" __vtkname__ = 'vtkSQLQuery' class vtkSQLiteQuery(vtkSQLQuery): """ vtkSQLiteQuery - vtkSQLQuery implementation for SQLite databases Superclass: vtkSQLQuery This is an implementation of vtkSQLQuery for SQLite databases. See the documentation for vtkSQLQuery for information about what the methods do. @bug Sometimes Execute() will return false (meaning an error) but GetLastErrorText() winds up null. I am not certain why this is happening. @par Thanks: Thanks to Andrew Wilson from Sandia National Laboratories for implementing this class. @sa vtkSQLDatabase vtkSQLQuery vtkSQLiteDatabase """ def BeginTransaction(self): # real signature unknown; restored from __doc__ """ BeginTransaction(self) -> bool C++: bool BeginTransaction() override; Begin, abort (roll back), or commit a transaction. """ return False def BindParameter(self, index, value): # real signature unknown; restored from __doc__ """ BindParameter(self, index:int, value:int) -> bool C++: bool BindParameter(int index, int value) override; BindParameter(self, index:int, value:int) -> bool C++: bool BindParameter(int index, long value) override; BindParameter(self, index:int, value:int) -> bool C++: bool BindParameter(int index, long long value) override; BindParameter(self, index:int, value:float) -> bool C++: bool BindParameter(int index, double value) override; BindParameter(self, index:int, stringValue:str, length:int) -> bool C++: bool BindParameter(int index, const char *stringValue, size_t length) override; BindParameter(self, index:int, string:str) -> bool C++: bool BindParameter(int index, const vtkStdString &string) override; BindParameter(self, index:int, value:vtkVariant) -> bool C++: bool BindParameter(int index, vtkVariant value) override; BindParameter(self, index:int, data:Pointer, length:int) -> bool C++: bool BindParameter(int index, const void *data, size_t length) override; """ return False def ClearParameterBindings(self): # real signature unknown; restored from __doc__ """ ClearParameterBindings(self) -> bool C++: bool ClearParameterBindings() override; Reset all parameter bindings to nullptr. """ return False def CommitTransaction(self): # real signature unknown; restored from __doc__ """ CommitTransaction(self) -> bool C++: bool CommitTransaction() override; """ return False def DataValue(self, c): # real signature unknown; restored from __doc__ """ DataValue(self, c:int) -> vtkVariant C++: vtkVariant DataValue(vtkIdType c) override; Return data in current row, field c """ pass def Execute(self): # real signature unknown; restored from __doc__ """ Execute(self) -> bool C++: bool Execute() override; Execute the query. This must be performed before any field name or data access functions are used. """ return False def GetFieldName(self, i): # real signature unknown; restored from __doc__ """ GetFieldName(self, i:int) -> str C++: const char *GetFieldName(int i) override; Return the name of the specified query field. """ return "" def GetFieldType(self, i): # real signature unknown; restored from __doc__ """ GetFieldType(self, i:int) -> int C++: int GetFieldType(int i) override; Return the type of the field, using the constants defined in vtkType.h. """ return 0 def GetLastErrorText(self): # real signature unknown; restored from __doc__ """ GetLastErrorText(self) -> str C++: const char *GetLastErrorText() override; Get the last error text from the query """ return "" def GetNumberOfFields(self): # real signature unknown; restored from __doc__ """ GetNumberOfFields(self) -> int C++: int GetNumberOfFields() override; The number of fields in the query result. """ return 0 def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBase(self, type:str) -> int C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type) override; Given the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBaseType(type:str) -> int C++: static vtkIdType GetNumberOfGenerationsFromBaseType( const char *type) Given a the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def HasError(self): # real signature unknown; restored from __doc__ """ HasError(self) -> bool C++: bool HasError() override; Return true if there is an error on the current query. """ return False def IsA(self, type): # real signature unknown; restored from __doc__ """ IsA(self, type:str) -> int C++: vtkTypeBool IsA(const char *type) override; Return 1 if this class is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsTypeOf(self, type): # real signature unknown; restored from __doc__ """ IsTypeOf(type:str) -> int C++: static vtkTypeBool IsTypeOf(const char *type) Return 1 if this class type is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkSQLiteQuery C++: vtkSQLiteQuery *NewInstance() """ return vtkSQLiteQuery def NextRow(self): # real signature unknown; restored from __doc__ """ NextRow(self) -> bool C++: bool NextRow() override; Advance row, return false if past end. """ return False def RollbackTransaction(self): # real signature unknown; restored from __doc__ """ RollbackTransaction(self) -> bool C++: bool RollbackTransaction() override; """ return False def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkSQLiteQuery C++: static vtkSQLiteQuery *SafeDownCast(vtkObjectBase *o) """ return vtkSQLiteQuery def SetQuery(self, query): # real signature unknown; restored from __doc__ """ SetQuery(self, query:str) -> bool C++: bool SetQuery(const char *query) override; Set the SQL query string. This must be performed before Execute() or BindParameter() can be called. """ return False def __delattr__(self, *args, **kwargs): # real signature unknown """ Implement delattr(self, name). """ pass def __getattribute__(self, *args, **kwargs): # real signature unknown """ Return getattr(self, name). """ pass def __init__(self, *args, **kwargs): # real signature unknown pass @staticmethod # known case of __new__ def __new__(*args, **kwargs): # real signature unknown """ Create and return a new object. See help(type) for accurate signature. """ pass def __repr__(self, *args, **kwargs): # real signature unknown """ Return repr(self). """ pass def __setattr__(self, *args, **kwargs): # real signature unknown """ Implement setattr(self, name, value). """ pass def __str__(self, *args, **kwargs): # real signature unknown """ Return str(self). """ pass __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default """Pointer to the C++ object.""" __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkSQLiteQuery', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'SetQuery': , 'Execute': , 'GetNumberOfFields': , 'GetFieldName': , 'GetFieldType': , 'NextRow': , 'HasError': , 'BeginTransaction': , 'RollbackTransaction': , 'CommitTransaction': , 'DataValue': , 'GetLastErrorText': , 'BindParameter': , 'ClearParameterBindings': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkSQLiteQuery - vtkSQLQuery implementation for SQLite databases\\n\\nSuperclass: vtkSQLQuery\\n\\nThis is an implementation of vtkSQLQuery for SQLite databases. See\\nthe documentation for vtkSQLQuery for information about what the\\nmethods do.\\n\\n@bug Sometimes Execute() will return false (meaning an error) but\\nGetLastErrorText() winds up null. I am not certain why this is\\nhappening.\\n\\n@par Thanks: Thanks to Andrew Wilson from Sandia National\\nLaboratories for implementing this class.\\n\\n@sa\\nvtkSQLDatabase vtkSQLQuery vtkSQLiteDatabase\\n\\n'})" __vtkname__ = 'vtkSQLiteQuery' class vtkSQLiteToTableReader(vtkDatabaseToTableReader): """ vtkSQLiteToTableReader - Read an SQLite table as a vtkTable Superclass: vtkDatabaseToTableReader vtkSQLiteToTableReader reads a table from an SQLite database and outputs it as a vtkTable. """ def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBase(self, type:str) -> int C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type) override; Given the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBaseType(type:str) -> int C++: static vtkIdType GetNumberOfGenerationsFromBaseType( const char *type) Given a the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsA(self, type): # real signature unknown; restored from __doc__ """ IsA(self, type:str) -> int C++: vtkTypeBool IsA(const char *type) override; Return 1 if this class is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsTypeOf(self, type): # real signature unknown; restored from __doc__ """ IsTypeOf(type:str) -> int C++: static vtkTypeBool IsTypeOf(const char *type) Return 1 if this class type is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkSQLiteToTableReader C++: vtkSQLiteToTableReader *NewInstance() """ return vtkSQLiteToTableReader def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkSQLiteToTableReader C++: static vtkSQLiteToTableReader *SafeDownCast(vtkObjectBase *o) """ return vtkSQLiteToTableReader def __delattr__(self, *args, **kwargs): # real signature unknown """ Implement delattr(self, name). """ pass def __getattribute__(self, *args, **kwargs): # real signature unknown """ Return getattr(self, name). """ pass def __init__(self, *args, **kwargs): # real signature unknown pass @staticmethod # known case of __new__ def __new__(*args, **kwargs): # real signature unknown """ Create and return a new object. See help(type) for accurate signature. """ pass def __repr__(self, *args, **kwargs): # real signature unknown """ Return repr(self). """ pass def __setattr__(self, *args, **kwargs): # real signature unknown """ Implement setattr(self, name, value). """ pass def __str__(self, *args, **kwargs): # real signature unknown """ Return str(self). """ pass __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default """Pointer to the C++ object.""" __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkSQLiteToTableReader', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkSQLiteToTableReader - Read an SQLite table as a vtkTable\\n\\nSuperclass: vtkDatabaseToTableReader\\n\\nvtkSQLiteToTableReader reads a table from an SQLite database and\\noutputs it as a vtkTable.\\n\\n'})" __vtkname__ = 'vtkSQLiteToTableReader' class vtkTableToDatabaseWriter(__vtkmodules_vtkIOCore.vtkWriter): """ vtkTableToDatabaseWriter - in a SQL database. Superclass: vtkWriter vtkTableToDatabaseWriter abstract parent class that reads a vtkTable and inserts it into an SQL database. """ def GetDatabase(self): # real signature unknown; restored from __doc__ """ GetDatabase(self) -> vtkSQLDatabase C++: vtkSQLDatabase *GetDatabase() """ return vtkSQLDatabase def GetInput(self): # real signature unknown; restored from __doc__ """ GetInput(self) -> vtkTable C++: vtkTable *GetInput() GetInput(self, port:int) -> vtkTable C++: vtkTable *GetInput(int port) Get the input to this writer. """ pass def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBase(self, type:str) -> int C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type) override; Given the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBaseType(type:str) -> int C++: static vtkIdType GetNumberOfGenerationsFromBaseType( const char *type) Given a the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsA(self, type): # real signature unknown; restored from __doc__ """ IsA(self, type:str) -> int C++: vtkTypeBool IsA(const char *type) override; Return 1 if this class is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsTypeOf(self, type): # real signature unknown; restored from __doc__ """ IsTypeOf(type:str) -> int C++: static vtkTypeBool IsTypeOf(const char *type) Return 1 if this class type is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkTableToDatabaseWriter C++: vtkTableToDatabaseWriter *NewInstance() """ return vtkTableToDatabaseWriter def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkTableToDatabaseWriter C++: static vtkTableToDatabaseWriter *SafeDownCast( vtkObjectBase *o) """ return vtkTableToDatabaseWriter def SetDatabase(self, db): # real signature unknown; restored from __doc__ """ SetDatabase(self, db:vtkSQLDatabase) -> bool C++: bool SetDatabase(vtkSQLDatabase *db) Set the database. Must already be open. """ return False def SetTableName(self, name): # real signature unknown; restored from __doc__ """ SetTableName(self, name:str) -> bool C++: bool SetTableName(const char *name) Set the name of the new SQL table that you'd this writer to create. Returns false if the specified table already exists in the database. """ return False def TableNameIsNew(self): # real signature unknown; restored from __doc__ """ TableNameIsNew(self) -> bool C++: bool TableNameIsNew() Check if the currently specified table name exists in the database. """ return False def __delattr__(self, *args, **kwargs): # real signature unknown """ Implement delattr(self, name). """ pass def __getattribute__(self, *args, **kwargs): # real signature unknown """ Return getattr(self, name). """ pass def __init__(self, *args, **kwargs): # real signature unknown pass @staticmethod # known case of __new__ def __new__(*args, **kwargs): # real signature unknown """ Create and return a new object. See help(type) for accurate signature. """ pass def __repr__(self, *args, **kwargs): # real signature unknown """ Return repr(self). """ pass def __setattr__(self, *args, **kwargs): # real signature unknown """ Implement setattr(self, name, value). """ pass def __str__(self, *args, **kwargs): # real signature unknown """ Return str(self). """ pass __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default """Pointer to the C++ object.""" __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkTableToDatabaseWriter', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'SetDatabase': , 'SetTableName': , 'TableNameIsNew': , 'GetDatabase': , 'GetInput': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkTableToDatabaseWriter - in a SQL database.\\n\\nSuperclass: vtkWriter\\n\\nvtkTableToDatabaseWriter abstract parent class that reads a vtkTable\\nand inserts it into an SQL database.\\n\\n'})" __vtkname__ = 'vtkTableToDatabaseWriter' class vtkTableToSQLiteWriter(vtkTableToDatabaseWriter): """ vtkTableToSQLiteWriter - store a vtkTable in an SQLite database Superclass: vtkTableToDatabaseWriter vtkTableToSQLiteWriter reads a vtkTable and inserts it into an SQLite database. """ def GetInput(self): # real signature unknown; restored from __doc__ """ GetInput(self) -> vtkTable C++: vtkTable *GetInput() GetInput(self, port:int) -> vtkTable C++: vtkTable *GetInput(int port) Get the input to this writer. """ pass def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBase(self, type:str) -> int C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type) override; Given the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBaseType(type:str) -> int C++: static vtkIdType GetNumberOfGenerationsFromBaseType( const char *type) Given a the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsA(self, type): # real signature unknown; restored from __doc__ """ IsA(self, type:str) -> int C++: vtkTypeBool IsA(const char *type) override; Return 1 if this class is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsTypeOf(self, type): # real signature unknown; restored from __doc__ """ IsTypeOf(type:str) -> int C++: static vtkTypeBool IsTypeOf(const char *type) Return 1 if this class type is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkTableToSQLiteWriter C++: vtkTableToSQLiteWriter *NewInstance() """ return vtkTableToSQLiteWriter def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkTableToSQLiteWriter C++: static vtkTableToSQLiteWriter *SafeDownCast(vtkObjectBase *o) """ return vtkTableToSQLiteWriter def __delattr__(self, *args, **kwargs): # real signature unknown """ Implement delattr(self, name). """ pass def __getattribute__(self, *args, **kwargs): # real signature unknown """ Return getattr(self, name). """ pass def __init__(self, *args, **kwargs): # real signature unknown pass @staticmethod # known case of __new__ def __new__(*args, **kwargs): # real signature unknown """ Create and return a new object. See help(type) for accurate signature. """ pass def __repr__(self, *args, **kwargs): # real signature unknown """ Return repr(self). """ pass def __setattr__(self, *args, **kwargs): # real signature unknown """ Implement setattr(self, name, value). """ pass def __str__(self, *args, **kwargs): # real signature unknown """ Return str(self). """ pass __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default """Pointer to the C++ object.""" __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkTableToSQLiteWriter', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'GetInput': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkTableToSQLiteWriter - store a vtkTable in an SQLite database\\n\\nSuperclass: vtkTableToDatabaseWriter\\n\\nvtkTableToSQLiteWriter reads a vtkTable and inserts it into an SQLite\\ndatabase.\\n\\n'})" __vtkname__ = 'vtkTableToSQLiteWriter' # variables with complex values __loader__ = None # (!) real value is '<_frozen_importlib_external.ExtensionFileLoader object at 0x000001D5BDA6BC50>' __spec__ = None # (!) real value is "ModuleSpec(name='vtkmodules.vtkIOSQL', loader=<_frozen_importlib_external.ExtensionFileLoader object at 0x000001D5BDA6BC50>, origin='C:\\\\Users\\\\xukai\\\\Downloads\\\\??2\\\\venv\\\\Lib\\\\site-packages\\\\vtkmodules\\\\vtkIOSQL.cp311-win_amd64.pyd')"