<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Dev Manual on ShardingSphere</title>
    <link>https://shardingsphere.apache.org/document/current/en/dev-manual/</link>
    <description>Recent content in Dev Manual on ShardingSphere</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en-us</language>
    
	<atom:link href="https://shardingsphere.apache.org/document/current/en/dev-manual/index.xml" rel="self" type="application/rss+xml" />
    
    
    <item>
      <title>SQL Parser</title>
      <link>https://shardingsphere.apache.org/document/current/en/dev-manual/sql-parser/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://shardingsphere.apache.org/document/current/en/dev-manual/sql-parser/</guid>
      <description>SQLParserFacade    SPI Name Description     SQLParserFacade SQL parser facade for lexer and parser       Implementation Class Description     MySQLParserFacade SQL parser facade for MySQL   PostgreSQLParserFacade SQL parser facade for PostgreSQL   SQLServerParserFacade SQL parser facade for SQLServer   OracleParserFacade SQL parser facade for Oracle   SQL92ParserFacade SQL parser facade for SQL92    SQLVisitorFacade    SPI Name Description     SQLVisitorFacade SQL AST visitor facade       Implementation Class Description     MySQLStatementSQLVisitorFacade SQL visitor of statement extracted facade for MySQL   PostgreSQLStatementSQLVisitorFacade SQL visitor of statement extracted facade for PostgreSQL   SQLServerStatementSQLVisitorFacade SQL visitor of statement extracted facade for SQLServer   OracleStatementSQLVisitorFacade SQL visitor of statement extracted facade for Oracle   SQL92StatementSQLVisitorFacade SQL visitor of statement extracted facade for SQL92    </description>
    </item>
    
    <item>
      <title>Configuration</title>
      <link>https://shardingsphere.apache.org/document/current/en/dev-manual/configuration/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://shardingsphere.apache.org/document/current/en/dev-manual/configuration/</guid>
      <description>ShardingSphereRuleBuilder    SPI Name Description     ShardingSphereRuleBuilder Used to convert user configurations to rule objects       Implementation Class Description     ShardingRuleBuilder Used to convert user sharding configurations to sharding rule objects   ReplicaQueryRuleBuilder Used to convert user replica query configurations to replica query rule objects   EncryptRuleBuilder Used to convert user encryption configurations to encryption rule objects   ShadowRuleBuilder Used to convert user shadow database configurations to shadow database rule objects    YamlRuleConfigurationSwapper    SPI Name Description     YamlRuleConfigurationSwapper Used to convert YAML configuration to standard user configuration       Implementation Class Description     ShardingRuleConfigurationYamlSwapper Used to convert YAML sharding configuration to standard sharding configuration   ReplicaQueryRuleConfigurationYamlSwapper Used to convert YAML replica query configuration to standard replica query configuration   EncryptRuleConfigurationYamlSwapper Used to convert YAML encryption configuration to standard encryption configuration   ShadowRuleConfigurationYamlSwapper Used to convert YAML shadow database configuration to standard shadow database configuration    ShardingSphereYamlConstruct    SPI Name Description     ShardingSphereYamlConstruct Used to convert customized objects and YAML to each other       Implementation Class Description     NoneShardingStrategyConfigurationYamlConstruct Used to convert non sharding strategy and YAML to each other    </description>
    </item>
    
    <item>
      <title>Kernel</title>
      <link>https://shardingsphere.apache.org/document/current/en/dev-manual/kernel/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://shardingsphere.apache.org/document/current/en/dev-manual/kernel/</guid>
      <description>DatabaseType    SPI Name Description     DatabaseType Supported database type       Implementation Class Description     SQL92DatabaseType SQL92 database type   MySQLDatabaseType MySQL database   MariaDBDatabaseType MariaDB database   PostgreSQLDatabaseType PostgreSQL database   OracleDatabaseType Oracle database   SQLServerDatabaseType SQLServer database   H2DatabaseType H2 database    DialectTableMetaDataLoader    SPI Name Description     DialectTableMetaDataLoader Use SQL dialect to load meta data rapidly       Implementation Class Description     MySQLTableMetaDataLoader Use MySQL dialect to load meta data   OracleTableMetaDataLoader Use Oracle dialect to load meta data   PostgreSQLTableMetaDataLoader Use PostgreSQL dialect to load meta data   SQLServerTableMetaDataLoader Use SQLServer dialect to load meta data   H2TableMetaDataLoader Use H2 dialect to load meta data    SQLRouter    SPI Name Description     SQLRouter Used to process routing results       Implementation Class Description     ShardingSQLRouter Used to process sharding routing results   ReplicaQuerySQLRouter Used to process replica query routing results   ShadowRouteSQLRouter Used to process shadow database routing results    SQLRewriteContextDecorator    SPI Name Description     SQLRewriteContextDecorator Used to process SQL rewrite results       SPI Name Description     ShardingSQLRewriteContextDecorator Used to process sharding SQL rewrite results   EncryptSQLRewriteContextDecorator Used to process encryption SQL rewrite results   ShadowSQLRewriteContextDecorator Used to process shadow SQL rewrite results    SQLExecutionHook    SPI Name Description     SQLExecutionHook Hook of SQL execution       Implementation Class Description     TransactionalSQLExecutionHook Transaction hook of SQL execution   OpenTracingSQLExecutionHook Open tracing hook of SQL execution    ResultProcessEngine    SPI Name Description     ResultProcessEngine Used by merge engine to process result set       Implementation Class Description     ShardingResultMergerEngine Used by merge engine to process sharding result set   EncryptResultDecoratorEngine Used by merge engine to process encryption result set    StoragePrivilegeLoader    SPI Name Description     StoragePrivilegeLoader Use SQL dialect to load privilege metadata       Implementation Class Description     MySQLPrivilegeLoader Use MySQL dialect to load privilege metadata   OraclePrivilegeLoader Use Oracle dialect to load privilege metadata   PostgreSQLPrivilegeLoader Use PostgreSQL dialect to load privilege metadata    </description>
    </item>
    
    <item>
      <title>Data Sharding</title>
      <link>https://shardingsphere.apache.org/document/current/en/dev-manual/sharding/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://shardingsphere.apache.org/document/current/en/dev-manual/sharding/</guid>
      <description>ShardingAlgorithm    SPI Name Description     ShardingAlgorithm Sharding algorithm       Implementation Class Description     InlineShardingAlgorithm Inline sharding algorithm   ModShardingAlgorithm Modulo sharding algorithm   HashModShardingAlgorithm Hash modulo sharding algorithm   FixedIntervalShardingAlgorithm Fixed interval sharding algorithm   MutableIntervalShardingAlgorithm Mutable interval sharding algorithm   VolumeBasedRangeShardingAlgorithm Volume based range sharding algorithm   BoundaryBasedRangeShardingAlgorithm Boundary based range sharding algorithm   ClassBasedShardingAlgorithm Class based sharding algorithm    KeyGenerateAlgorithm    SPI Name Description     KeyGenerateAlgorithm Key generate algorithm       Implementation Class Description     SnowflakeKeyGenerateAlgorithm Snowflake key generate algorithm   UUIDKeyGenerateAlgorithm UUID key generate algorithm    TimeService    SPI Name Description     TimeService Use current time for routing       Implementation Class Description     DefaultTimeService Get the current time from the application system for routing   DatabaseTimeServiceDelegate Get the current time from the database for routing    DatabaseSQLEntry    SPI Name Description     DatabaseSQLEntry Database dialect for get current time       Implementation Class Description     MySQLDatabaseSQLEntry MySQL dialect for get current time   PostgreSQLDatabaseSQLEntry PostgreSQL dialect for get current time   OracleDatabaseSQLEntry Oracle dialect for get current time   SQLServerDatabaseSQLEntry SQLServer dialect for get current time    </description>
    </item>
    
    <item>
      <title>Read write splitting</title>
      <link>https://shardingsphere.apache.org/document/current/en/dev-manual/read-write-splitting/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://shardingsphere.apache.org/document/current/en/dev-manual/read-write-splitting/</guid>
      <description>ReplicaLoadBalanceAlgorithm    SPI Name Description     ReplicaLoadBalanceAlgorithm Load balance algorithm of replica databases       Implementation Class Description     RoundRobinReplicaLoadBalanceAlgorithm Round robin load balance algorithm of replica databases   RandomReplicaLoadBalanceAlgorithm Random load balance algorithm of replica databases    </description>
    </item>
    
    <item>
      <title>Data Encryption</title>
      <link>https://shardingsphere.apache.org/document/current/en/dev-manual/data-encryption/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://shardingsphere.apache.org/document/current/en/dev-manual/data-encryption/</guid>
      <description>EncryptAlgorithm    SPI Name Description     EncryptAlgorithm Data encrypt algorithm       Implementation Class Description     MD5EncryptAlgorithm MD5 data encrypt algorithm   AESEncryptAlgorithm AES data encrypt algorithm   RC4EncryptAlgorithm Rc4 data encrypt algorithm    QueryAssistedEncryptAlgorithm    SPI Name Description     QueryAssistedEncryptAlgorithm Data encrypt algorithm which include query assisted column       Implementation Class Description     None     </description>
    </item>
    
    <item>
      <title>SQL Audit</title>
      <link>https://shardingsphere.apache.org/document/current/en/dev-manual/sql-audit/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://shardingsphere.apache.org/document/current/en/dev-manual/sql-audit/</guid>
      <description>SQLAuditor    SPI Name Description     SQLAuditor SQL auditor       Implementation Class Description     None     </description>
    </item>
    
    <item>
      <title>Distributed Transaction</title>
      <link>https://shardingsphere.apache.org/document/current/en/dev-manual/transaction/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://shardingsphere.apache.org/document/current/en/dev-manual/transaction/</guid>
      <description>ShardingTransactionManager    SPI Name Description     ShardingTransactionManager Distributed transaction manager       Implementation Class Description     XAShardingTransactionManager XA distributed transaction manager   SeataATShardingTransactionManager Seata distributed transaction manager    XATransactionManager    SPI Name Description     XATransactionManager XA distributed transaction manager       Implementation Class Description     AtomikosTransactionManager XA distributed transaction manager based on Atomikos   NarayanaXATransactionManager XA distributed transaction manager based on Narayana   BitronixXATransactionManager XA distributed transaction manager based on Bitronix    XADataSourceDefinition    SPI Name Description     XADataSourceDefinition Auto convert Non XA data source to XA data source       Implementation Class Description     MySQLXADataSourceDefinition Auto convert Non XA MySQL data source to XA MySQL data source   MariaDBXADataSourceDefinition Auto convert Non XA MariaDB data source to XA MariaDB data source   PostgreSQLXADataSourceDefinition Auto convert Non XA PostgreSQL data source to XA PostgreSQL data source   OracleXADataSourceDefinition Auto convert Non XA Oracle data source to XA Oracle data source   SQLServerXADataSourceDefinition Auto convert Non XA SQLServer data source to XA SQLServer data source   H2XADataSourceDefinition Auto convert Non XA H2 data source to XA H2 data source    DataSourcePropertyProvider    SPI Name Description     DataSourcePropertyProvider Used to get standard properties of data source pool       Implementation Class Description     HikariCPPropertyProvider Used to get standard properties of HikariCP    </description>
    </item>
    
    <item>
      <title>Distributed Governance</title>
      <link>https://shardingsphere.apache.org/document/current/en/dev-manual/governance/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://shardingsphere.apache.org/document/current/en/dev-manual/governance/</guid>
      <description>ConfigurationRepository    SPI Name Description     ConfigurationRepository Config repository       Implementation Class Description     CuratorZookeeperRepository ZooKeeper config repository   EtcdRepository etcd config repository    RegistryRepository    SPI Name Description     RegistryRepository Registry repository       Implementation Class Description     CuratorZookeeperRepository ZooKeeper registry repository   EtcdRepository etcd registry repository    </description>
    </item>
    
    <item>
      <title>Scaling</title>
      <link>https://shardingsphere.apache.org/document/current/en/dev-manual/scaling/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://shardingsphere.apache.org/document/current/en/dev-manual/scaling/</guid>
      <description>ScalingEntry    SPI Name Description     ScalingEntry Entry of scaling       Implementation Class Description     MySQLScalingEntry MySQL entry of scaling   PostgreSQLScalingEntry PostgreSQL entry of scaling    </description>
    </item>
    
    <item>
      <title>Proxy</title>
      <link>https://shardingsphere.apache.org/document/current/en/dev-manual/proxy/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://shardingsphere.apache.org/document/current/en/dev-manual/proxy/</guid>
      <description>DatabaseProtocolFrontendEngine    SPI Name Description     DatabaseProtocolFrontendEngine Regulate parse and adapter protocol of database access for ShardingSphere-Proxy       Implementation Class Description     MySQLFrontendEngine Base on MySQL database protocol   PostgreSQLFrontendEngine Base on PostgreSQL database protocol    JDBCDriverURLRecognizer    SPI Name Description     JDBCDriverURLRecognizer Use JDBC driver to execute SQL       Implementation Class Description     MySQLRecognizer Use MySQL JDBC driver to execute SQL   PostgreSQLRecognizer Use PostgreSQL JDBC driver to execute SQL   OracleRecognizer Use Oracle JDBC driver to execute SQL   SQLServerRecognizer Use SQLServer JDBC driver to execute SQL   H2Recognizer Use H2 JDBC driver to execute SQL    </description>
    </item>
    
  </channel>
</rss>